15.io流,递归

一。file的常用api

二。算法：递归
1.定义：递归算法是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数（或过程）来表示问题的解。
一个过程(或函数)直接或间接调用自己本身,这种过程(或函数)叫递归过程(或函数).

案例：计算10的阶乘： 10*9*8*7*6*5*4*3*2*1

三。文件处理IO
1.字节流：可以处理任何文件类型
字节输入流
InputStream in = BufferedInputStream FileInputStream File
in.read()
字节输出流
OutputStream os = BufferedOutputStream FileOutputStream File
in.write(byte[])
2.字符流：只能处理文本型文件类型
Reader r = BufferedReader FileReader File
r.readerLine()
Write w = BufferedWrite FileWrite File
w.write

四、作业及练习

1.做一个模拟dos窗口的命令集合：dir和cd功能
dir是显示当前目录下的所有子目录和文件名 还有文件大小
cd是将当前目录进入到指定文件目录下
要求从d盘开始

2.输入一个字符串，要求把字符串从第一个字符每次叠加一个字符输出，用递归算法
例如：“白日依山尽” 输出：白 白日 白日依 白日依山 白日依山尽

3.输入一个文件夹路径，打印输出该文件夹下所有文件路径

test
    html
        html
            index.html
        index.html
    java
        First.java
        HelloWorld.java
    oracle
        sql
            my.sql
        hard.txt
        read.txt
    hello.txt
    Huwa.java

public void directory(String path){
    //构造file
    //拿到目录结构下的所有file
    //循环file数组，判断如果是文件打印输出，如果是目录则继续调用自己递归
}

4.写一个方法，用来替换文章中的字符串

5.写一个方法，用来统计文章中字符串出现的次数

1.将一篇没有自动换行的文章按规则实现换行。
规则为：句号，分号，省略号，感叹号，疑问号。
遇到以上符号就换行

2.将成绩文档中的所有成绩求平均成绩，最高分，和总人数？

学号,姓名,学科,成绩
1,张安,语文,88
2,刘鹗,语文,67
3,修改,语文,87
4,鳄鱼,语文,55
5,没地方,语文,45
6,大飞哥,语文,66
7,苟富贵,语文,78
8,表单,语文,98
9,放到,语文,78
10,二维热无,语文,99
11,都是,语文,87
12,放到,语文,67
13,的v,语文,56
14,地方,语文,76
15,水电费,语文,87
16,大飞,语文,99
17,同意,语文,89
18,回滚,语文,78
19,交换机,语文,67
20,玩儿,语文,87

五、例子

　　文件基本操作+dos操作系统模拟实例：

 package com.demo1120;

 import java.io.File;
 import java.io.IOException;
 import java.util.Scanner;

 import org.junit.Test;

 public class FileDemo {
     @Test
     public void test(){
         File file = new File("d:/test/stu.txt");
         try {
             file.createNewFile();
         } catch (IOException e) {
             e.printStackTrace();
         }
         file.delete();
         System.out.println(file.exists());

         File test = new File("d:/test");
         File[] files = test.listFiles();
         for (int i = 0; i < files.length; i++) {
             System.out.println(files[i].getName());
         }
     }

     @Test
     public void dos(){
         Scanner sc = new Scanner(System.in);
         String path = "d:/";

         System.out.println("d:/>");
         while(true){
             String command = sc.nextLine();
             if("dir".equals(command)){
                 File file = new File(path);
                 File[] files = file.listFiles();
                 for (int i = 0; i < files.length; i++) {
                     System.out.println(files[i].getName());
                 }
                 System.out.println(path+">");
             }

             if(command.startsWith("cd")){
                 path += "/"+command.substring(command.indexOf(" ")+1);
                 File file = new File(path);
                 System.out.println(path+">");
             }
         }
     }
 }

　　递归实例：

 package com.demo1120;

 import org.junit.Test;

 public class RecursionDemo {
     public static void main(String[] args) {
         RecursionDemo r = new RecursionDemo();
 //        int result = r.factoril(10);
 //        System.out.println(result);
         r.string("白日依山尽");
     }

     //计算阶乘
     public int factoril(int num){
         if(num==1){
             return 1;
         }else{
             int result = num*factoril(num-1);
             System.out.println(result);
             return result;
         }
     }

     public String string(String s){
         if(s.length()==1){
             System.out.println(s);
             return s;
         }else{
             String result = s+string(s.substring(0,s.length()-1));
             System.out.println(s);
             return result;
         }
     }
 }

　　打印文件夹下所有文件实例

 package com.demo1120;

 import java.io.File;

 public class Work {
     public static void main(String[] args) {
         Work w = new Work();
         w.directory("d:/test",0);
     }

     public void directory(String path,int table){
         //构造file
         File file = new File(path);
         //拿到目录结构下的所有file
         File[] files = file.listFiles();

         //循环file数组，判断如果是文件打印输出，如果是目录则继续调用自己递归
         for (int i = 0; i < files.length; i++) {
             for (int j = 0; j < table; j++) {
                 System.out.print("\t");
             }
             if(files[i].isFile()){
                 System.out.println(files[i].getName());
             }
             if(files[i].isDirectory()){
                 System.out.println(files[i].getName());
                 directory(path+"/"+files[i].getName(),table+1);
             }
         }
     }
 }

　　读取一个文件中的内容并写入到另一个文件中的实例（字节流）：

 package com.demo1120;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;

 public class StreamDemo {

     public static void main(String[] args) {
         StreamDemo sd = new StreamDemo();
         byte[] b = sd.readFile("d:/test/笔记");
         sd.writeFile("d:/海文", b);
     }
     public byte[] readFile(String path){

         File file = new File(path);
         //把文件读成字节输入流
         InputStream in = null;
         byte[] bytes = new byte[(int)file.length()];
         try{
             in = new BufferedInputStream(new FileInputStream(file));
             //从流中把字节内容存入到java内存，字节数组
             int offset = 0;//记录每次读取的初始位置
             int num = 0;//记录每次读取的量
             //循环从流中把字节存储到字节数组中
             while(offset<bytes.length&&num>=0){
                 num = in.read(bytes, offset, bytes.length-offset);
                 offset = num;
             }
             //将字节数组构造成字符创  “gbk”是支持中文的字符集编码
             System.out.println(new String(bytes, "gbk"));
         }catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 in.close();//关闭资源
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return bytes;
     }

     public void writeFile(String path,byte[] bytes){
         //字节输出流
         OutputStream os = null;
         try {
             os = new BufferedOutputStream(new FileOutputStream(new File(path)));
             os.write(bytes);
             os.flush();//清空缓存，如果不清空有可能有一部分在缓存中无法输出到文件
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 os.close();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }
 }

　　读取一个文件中的内容并写入到另一个文件中的实例（字符流）：

 package com.demo1120;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.Writer;

 /**
  * 字符流案例
  */
 public class CharStreamDemo {

     public static void main(String[] args) {
         CharStreamDemo cd = new CharStreamDemo();
 //        cd.readFile("d:/test/笔记");
         cd.writeFile("d:/测试");
     }

     public String readFile(String path){
         File file = new File(path);
         BufferedReader reader = null;
         StringBuilder sb = new StringBuilder();
         try {
             reader = new BufferedReader(new FileReader(file));
             String s;
             while((s = reader.readLine())!=null){
                 sb.append(s+"\n");
             }
             System.out.println(sb.toString());
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } finally{
             try {
                 reader.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return sb.toString();
     }

     public void writeFile(String path){
         File file = new File(path);
         Writer w = null;
         try {
             w = new BufferedWriter(new FileWriter(file));
             w.write("你好啊。\r\n我不好");//内存输出到文件，换行符是\r\n
             w.flush();//清空缓存
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 w.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }