Java-IO流

一、流的概念

二、流的分类

1. 按方向【重点】：
   1. 输入流：将<存储设备>中的内容读入到<内存>中。
   2. 输出流：将<内存>中的内容写入到<存储设备>中。
      
2. 按单位：
   1. 字节流：以字节为单位，可以读写所有数据。
   2. 字符流：以字符为单位，只能读写文本数据。
3. 按功能：
   1. 节点流：具有实际传输数据的读写功能。
   2. 过滤流：在节点流的基础之上增强功能。

三、字节流

字节流的父类

文件字节流

1. FileInputStream：
   1. public int read(byte[] b)：从流中读取多个字节，将读到的内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。
2. FileOutputStream：
   1. public void write(byte[] b)：一次写多个字节，将b数组中所有字节，写入输入流。

FileInputStream的使用-代码实现：

package JavaTest;
/**
 * FileInputStream的使用
 * 文件字节输入流
 */
import java.io.FileInputStream;

public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建FileInputStream，并指定文件路径
        FileInputStream fis=new FileInputStream("E:\\aaa.txt");
        //2 读取文件
//        fis.read();
        //2.1 单个字节读取
//        int data=0;
//        while ((data=fis.read())!=-1){//如果达到文件的尾部，则返回-1。
//            System.out.print((char)data);//返回值为int类型，所以强制类型转换一下
//        }
        //2.2 一次读取多个字节
        //用循环来读取文件内容
        byte[] buf=new byte[3];//3:缓冲区大小，即一下最多可以读取的数量
        int count=0;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
//        abc
//        def
//        g

//        分开读取，一次3个直至读完
//        byte[] buf=new byte[3];
//        int count1=fis.read(buf);
//        System.out.println(new String(buf));//String():java.lang下的
//        System.out.println(count1);//count1:实际读取的字节个数
//
//        int count2=fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count2);
//
//        int count3=fis.read(buf);
        //gef,读取了一个g。gef：可以认为覆盖赋值，由于count2数组没有清空，读的一个g只覆盖了第一个
        System.out.println(new String(buf));
//        //解决：
//        //buf：目标数组的值  0：从length=0开始读取  count：到count（本文=3）的时候停止读取
//        System.out.println(new String(buf,0,count3));//g
//        System.out.println(count3);
        //3 关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}

FileOutputStream的使用-代码实现：

package JavaTest;

import java.io.FileOutputStream;

/**
 * FileOutputStream的使用
 * 文件字节输出流
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建文件字节输出流对象
        //加过true后，再写入内容就不会覆盖原有内容了，而是接着原有内容写
        FileOutputStream fos=new FileOutputStream("E:\\aaa.txt",true);

        //2 写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');//输出abc，写入成功，但是覆盖了原有内容
        String string="HA";
        //加过true：helloworldhelloworldHA
        fos.write(string.getBytes());//输出helloworld，写入成功，但是覆盖了原有内容

        //3 关闭
        fos.close();
        System.out.println("执行完毕");//
    }
}

案例：复制aaa.txt,并改名为bbb.txt

package JavaTest;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建流
        //1.1 文件字节输出流
        FileInputStream fis=new FileInputStream("E:\\aaa.txt");//这个文件是存在的
        //2.2 文件字节输出流
        FileOutputStream fos=new FileOutputStream("E:\\bbb.txt");//这个文件是不存在的
        //2 一边读，一边写
        byte[] buf=new byte[1024];
        int count=0;
        while ((count=fis.read(buf))!=-1){//只要不等于-1,就说明没有读取完
            fos.write(buf,0,count);
        }
        //3 关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

字节缓冲流

1. 缓冲流：BufferedInputStream/BufferedOutputStream
   1. 提高IO效率，减少访问磁盘的次数；
   2. 数据存储在缓存区中，flush是将缓存区中的内容写入文件中，也可以直接close。

BufferedInputStream的使用-代码实现：

package JavaTest;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 * 自带缓冲区
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建BufferedInputStream
        FileInputStream fis=new FileInputStream("E:\\aaa.txt");//从硬盘中读取数据
        //目的：为了增强FileInputStream的功能
        BufferedInputStream bis=new BufferedInputStream(fis);//内置有缓存区
        //2 读取
        int data=0;
        //在调用read之前，已经有一部分的数据已经存入bis的缓存区（默认大小：8k）了，下次再读取的时候
        //缓存区里面已经有了，就不用再去硬盘中读取了
//        while ((data=bis.read())!=-1){
//            System.out.print((char)data);
//        }
        //自己创建一个缓存区
        byte[] buf=new byte[1024];
        int count=0;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3 关闭
        bis.close();
    }
}

BufferedOutputStream的使用-代码实现：

package JavaTest;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建字节输出缓存流
        FileOutputStream fos=new FileOutputStream("E:\\aaabuffer.txt");
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //2 写入文件
        for (int i=0;i<10;i++){
            bos.write("hello\r\n".getBytes());//先写入缓存区,\r\n:换行，默认大小；8k
            bos.flush();//写一次，刷新一次到硬盘
        }
        //3 关闭（内部调用flush方法）
        bos.close();//不用flush的话，在循环外关闭，内容一次性写入文件
    }
}

对象流

1. 对象流：ObjectOutputStream/ObjectInputStream
   1. 增强缓冲区功能
   2. 增强了读写8种基本数据类型和字符串功能
   3. 增强了读写对象的功能：
      1. readObject()：从流中读取一个对象
      2. writeObject(Object obj)：向流中写入一个对象
   4. 使用流传输对象的过程称为序列化、反序列化。（从内存中的对象写入文件中的过程称之为序列化，反之为反序列化）

序列化-代码实现：

package JavaTest;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStream实现对象的序列化：写入操作
 * 要求：
 * 1. 序列化的类，必须要是实现Serializable接口（标记性接口，里面没有什么方法）。
 * 2. 序列化类中对象属性，也要求实现Serializable接口。
 * 3. serialVersionUID，序列化版本号ID，保证序列化的类和反序列化的类是同一个类。
 * 4. 使用transient(瞬间的、瞬时的)修饰属性，这个属性就不能序列化了（不能保存了）。
 * 5. 静态属性不能被序列化的。
 * 6. 序列化多个对象，可以借助集合来实现
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建对象流,使用对象流之前必须要有一个节点流/底层流
        FileOutputStream fos=new FileOutputStream("E:\\aaastu.bin");//节点流/底层流
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //2 序列话（写入操作）
        Demo2 zhangsan=new Demo2("张三",20);
        //Demo2 lisi=new Demo2("李四",22);序列化多个对象：一个一个序列化
        //ArraysList<Demo2> list=new ArraysList<>();序列化多个对象：创建一个数组/集合来存储需要序列化的对象
        oos.writeObject(zhangsan);
        //oos.writeObject(lisi);
        //oos.writeObject(list);序列化一个数组/集合
        //3 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

反序列化-代码实现：

EOFException：点此进入

这个异常不是必须声明的，也就是说它虽然是异常，但其实是正常运行结束的标志。
EOF表示读到了文件尾 （ String str = dis.readUTF(); ，客户端已经断开，后面已经没有内容可以读了），发送结束自然连接也就断开了。

package JavaTest;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * 使用ObjectInputStream实现对象的反序列化：读取重构对象
 *
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建对象流,使用对象流之前必须要有一个节点流/底层流
        FileInputStream fis=new FileInputStream("E:\\aaastu.bin");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //2 读取文件（反序列化）
        Demo2 s=(Demo2)ois.readObject();
//        Demo2 s2=(Demo2)ois.readObject();//EOFException:详细看上文连接，要想不报错，就再序列化一个
	   //ArrayList<Demo2> list=(ArrayList<Demo2>)ois.readObject();
        //3 关闭
        ois.close();
        System.out.println("反序列化完毕");
        System.out.println(s.toString());
//        反序列化完毕
//        Demo2{name='张三', age=20}
    }
}

序列化、反序列化都用到的Dome2类：

package JavaTest;


import java.io.Serializable;

/***
 * Student类
 */
public class Demo2 implements Serializable {
   // private static final long serialVersionUID = 100L;序列号的ID改为100了，就不能反序列化了，与序列化时默认生成的ID不同，系统认定为不是同一个类。解决：1.把100改成和默认生成的ID相同的。2.在ID=100的基础上再序列化一遍，之后再反序列化。
    private String name;
    // private transient int age;
    private int age;
    //public static String country="中国"；静态属性：也是不能被序列化的，不能被存到硬盘中的

    public Demo2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Demo2{" +
                "name='" + name + '\'' +  ", age=" + age + '}';
    }
}

四、编码方式

字符编码

1. ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
2. UTF-8 针对Unicode码表的可变长度字符编码
3. GB2312 简体中文
4. GBK 简体中文、扩充
5. BIG5 台湾 繁体中文
6. 当编码方式和解码方式不一致时，会出现乱码。

五、字符流

小案例：使用字节流读取汉字

package JavaTest;

import java.io.FileInputStream;

public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建FileInputStream对象
        FileInputStream fis=new FileInputStream("E:\\aaa.txt");//内容：哈喽哈喽
        //2 使用字节流读取
        int data=0;
        while ((data=fis.read())!=-1){
            //文本内容，UTF-8形式存储，12个字节4个汉字，而它在读取的时候是一个字节一个字节的读取的，是把汉字拆开读取的，
            // 把一个字节换成一个字符，汉字是一个字符三个字节，拆开后肯定不能转换成汉字，所以乱码
            System.out.print((char) data);//哈喽哈喽
        }
        //3 关闭
        fis.close();
    }
}

字符流的父类（抽象类）

文件字符流

1. FileReader：
   public int read(char[] c)：从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1。
2. FileWriter：
   public void write(String str)：一次写多个字符，将b数组中所有字符，写入输出流。

使用FileReader读取文件-代码实现：

package JavaTest;

import java.io.FileReader;

/**
 * 使用FileReader读取文件
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建FileReader 文件字符输入流
        FileReader fr=new FileReader("E:\\aaa.txt");
        //2 读取
        //2.1 单个读取
//        int data=0;
//        while ((data=fr.read())!=-1){//读取一个字符：一次读三个字节，一共读四次
//            System.out.print((char) data);//哈喽哈喽
//        }
        //2.2 创建一个缓存区读取,中英文都可以读取
//        char[] buf=new char[1024];//哈喽哈喽
        char[] buf=new char[2];
//        哈喽
//        哈喽
        int count=0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3 关闭
        fr.close();
    }
}

使用FileWriter写入文件-代码实现：

package JavaTest;

import java.io.FileWriter;

/**
 * 使用FileWriter写入文件
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建FileWriter对象
        FileWriter fw=new FileWriter("E:\\aaafilewriter.txt");
        //2 写入
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界上最好的语言\n");
            fw.flush();
        }
        //3 关闭
        System.out.println("执行完毕");
    }
}

字符流：只能复制文本文件，不能复制图片或二进制文件（即可运行的文件）（复制过来的打不开）。
字节流：可以复制任意文件。
案例：使用FileReader和FileWriter复制文本文件。

package JavaTest;

import java.io.FileReader;
import java.io.FileWriter;
/**
 * 复制文件
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建FileWriter、FileReader对象
        FileReader fr=new FileReader("E:\\aaafilewriter.txt");
        FileWriter fw=new FileWriter("E:\\aaafilewriter2.txt");
        //2 写入
        int data=0;
        while ((data=fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        //3 关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

字符缓冲流

1. 缓冲流：BufferedReader/BufferedWriter
   1. 高效读写。
   2. 支持输入换行符。
   3. 可一次写一行、读一行。

BufferedReader读取文件-代码实现：

package JavaTest;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建缓冲流
        FileReader fr=new FileReader("E:\\aaafilewriter.txt");
        BufferedReader br=new BufferedReader(fr);
        //2 读取
        //2.1 第一种方式：创建缓存区
//        char[] buf=new char[1024];
//        int count=0;
//        while ((count=br.read())!=-1){
//            System.out.print((char) count);
//        }
        //2.2 第二种方式，一行一行的读取
        String line=null;
        while ((line=br.readLine())!=null){//不等于空，说明没有读取完
            System.out.println(line);
        }
        //3 关闭
        br.close();
    }
}

BufferedWriter的使用-代码实现：

package JavaTest;

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * BufferedWriter的使用
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建BufferedWriter对象
        FileWriter  fw=new FileWriter("E:\\aaabuffer.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        //2 写入
        for (int i = 0; i <10 ; i++) {
            bw.write("BufferedWriter的使用");
            bw.newLine();//写入一个换行符。windows：\r\n,Linxu：\n
            bw.flush();
        }
        //3 关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

打印流

1. PrintWrite:
   1. 封装了print()/println()方法，支持写入后换行。
   2. 支持数据原样打印。

PrintWriter的使用-代码实现：

package JavaTest;

import java.io.PrintWriter;

/**
 * PrintWriter的使用
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建打印流
        PrintWriter pw=new PrintWriter("E:\\aaaprint.txt");
        //2 打印
        pw.println(97);
        pw.println('a');
        pw.println(true);
        pw.println(3.1415926);
        //3 关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

转换流

1. 桥转换流：InputStreamReader/OutputStreamWriter
   1. 可将字节流转换为字符流。
   2. 可设置字符的编码方式。

使用InputStreamReader读取文件-代码实现：

package JavaTest;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * 使用InputStreamReader读取文件，可以指定使用的编码
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建InputStreamReader对象
        FileInputStream fis=new FileInputStream("E:\\aaafilewriter.txt");
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");//文件编码ANSI对应gbk编码
        //2 读取文件
        int data=0;
        while ((data=isr.read())!=-1){
            System.out.print((char) data);
        }
        //3 关闭
        isr.close();
    }
}

使用OutputStreamWriter写入文件-代码实现：

package JavaTest;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * 使用OutputStreamWriter写入文件，可以指定使用的编码
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建OutputStreamWriter
        FileOutputStream fos=new FileOutputStream("E:\\aaainfo.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
        //2 写入
        for (int i = 0; i < 10; i++) {
            osw.write("使用OutputStreamWriter写入文件");
            osw.flush();
        }
        //3 关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

六、File类

1. 概念：代表物理盘符中的一个文件或者文件夹。
2. 方法：
   
   文件操作-代码实现：

package JavaTest;

import java.io.File;
import java.util.Date;

/**
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作
 */
public class Demo {
    public static void main(String[] args) throws Exception{
//        separator();
        fileOpe();
    }
    //1 分隔符
    public static void separator(){
        System.out.println("路径分隔符"+File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //2 文件操作
    public static void fileOpe() throws Exception{
        //创建文件
        File file=new File("E:\\aaafile.txt");//创建了文件对象，不写盘符，则创建到项目路径下
//        System.out.println(file.toString());打印文件路径
        if (!file.exists()){//文件存在返回true，文件不存在时，创建文件
            boolean b=file.createNewFile();//创建文件，抛出异常、接收异常
            System.out.println("创建结果："+b);//true,再次运行：false
        }

        //删除文件
        //1.直接删除
//        System.out.println("删除结果："+file.delete());//删除结果：true
        //2.使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);//休眠5s

        //获取文件信息
        System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
        System.out.println("获取路径："+file.getPath());
        System.out.println("获取文件名称："+file.getName());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("获取文件的最后修改时间："+new Date(file.lastModified()).toLocaleString());

        //判断
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());
//        获取文件的绝对路径：E:\aaafile.txt
//        获取路径：E:\aaafile.txt
//        获取文件名称：aaafile.txt
//        获取父目录：E:\
//        获取文件长度：11
//        获取文件的最后修改时间：2022-11-14 18:04:37
//        是否可写：true
//        是否是文件：true
//        是否隐藏：false
    }
}

文件夹操作-代码实现：

package JavaTest;

import java.io.File;
import java.util.Date;

/**
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        directoryOpe();
    }
    //3 文件夹操作
    public static void directoryOpe() throws Exception{
        //创建文件夹
        File dir=new File("E:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
//            dir.mkdir();//只能创建单级目录
            System.out.println("创建结果："+dir.mkdirs());//创建多级目录
        }

        //删除文件夹
        //1.直接删除（只能删除空目录）
//        System.out.println("删除结果："+dir.delete());
        //2.使用jvm删除
//        dir.deleteOnExit();//只删除实例化时输入路径的最后一级文件夹
//        Thread.sleep(5000);

        //获取文件夹信息
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径："+dir.getPath());
        System.out.println("获取文件夹名称："+dir.getName());
        System.out.println("获取父目录："+dir.getParent());
        System.out.println("获取创建时间："+new Date(dir.lastModified()).toLocaleString());

        //判断
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否是隐藏："+dir.isHidden());

        //遍历文件夹
        File dir2=new File("E:\\aaa\\bbb\\ccc");
        File[] files=dir2.listFiles();//返回file数组
        System.out.println("----------------");
        for (File file:files){
            System.out.println(file);//输出文件绝对路径
        }
        String[] strings=dir2.list();//返回字符串数组
        System.out.println("================");
        for (String string:strings){
            System.out.println(string);//返回文件名
        }
    }
}

FileFilter接口（文件过滤器接口）

1. public interface FileFilter
   1. boolean accept(File pathname)
2. 当调用File类中的listFiles()方法时，支持传入FileFilter接口 接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles()的返回值中。

FileFilter接口的使用-代码实现：

package JavaTest;

import java.io.File;
import java.io.FileFilter;

public class Demo {
    public static void main(String[] args) throws Exception{
        directoryOpe();
    }
    public static void directoryOpe() throws Exception{
        //创建文件夹
        File dir=new File("E:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
            System.out.println("创建结果："+dir.mkdirs());//创建多级目录
        }
        //对文件夹内容进行过滤
        File dir2=new File("E:\\aaa\\bbb\\ccc");
        System.out.println("---------FileFilter接口的使用---------");
        File[] files1=dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".bin")){//endsWith:后缀
                    return true;//true:满足要求返回
                }return false;
            }
        });
        for (File file:files1){
            System.out.println(file.getName());
        }
    }
}
输出：
E:\aaa\bbb\ccc
---------FileFilter接口的使用---------
aaastu.bin

案例：递归遍历文件夹和递归删除文件夹

package JavaTest;

import java.io.File;

/**
 * 案例一：递归遍历文件夹
 * 案例二：递归删除文件夹
 */
public class Demo {
    public static void main(String[] args){
//        listDir(new File("E:\\aaa"));
        deleteDir(new File("E:\\aaa"));
    }
//    案例一：递归遍历文件夹
    public static void listDir(File dir){
        File[] files=dir.listFiles();//得到这个文件夹里面的所有文件
        System.out.println(dir.getAbsolutePath());
        if (files!=null&&files.length>0){
            for (File file:files){//for (数据类型 用来接收遍历后的变量名：目标数组)
                if (file.isDirectory()){
                    listDir(file);//递归：file是文件夹，则从头开始继续判断是否为空。。直至不是文件夹
                }
                else {
                    System.out.println(file.getAbsolutePath());//File不是文件夹，则输出内含文件的绝对地址
                }
//                E:\aaa
//                E:\aaa\bbb
//                E:\aaa\bbb\ccc
//                E:\aaa\bbb\ccc\aaa.txt
//                E:\aaa\bbb\ccc\aaabuffer.txt
//                E:\aaa\bbb\ccc\aaafile.txt
//                E:\aaa\bbb\ccc\aaafilewriter.txt
//                E:\aaa\bbb2
//                E:\aaa\bbb2\aaafilewriter2.txt
//                E:\aaa\bbb2\aaainfo.txt
//                E:\aaa\bbb2\aaaprint.txt
//                E:\aaa\bbb2\aaastu.bin
//                E:\aaa\bbb2\bbb.txt
            }
        }
    }
//    案例二：递归删除文件夹
    public static void deleteDir(File dir){
        File[] files=dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file:files){
                if (file.isDirectory()){
                    deleteDir(file);//递归
                }
                else {
                    //删除文件
                    System.out.println(file.getAbsolutePath()+"删除："+file.delete());
                }
            }
        }
        //删除文件夹
        System.out.println(dir.getAbsolutePath()+"删除："+dir.delete());
        System.out.println("删除完毕");
//        E:\aaa\bbb\ccc删除：true
//        删除完毕
//        E:\aaa\bbb删除：true
//        删除完毕
//        E:\aaa\bbb2删除：true
//        删除完毕
//        E:\aaa删除：true
//        删除完毕
    }
}

补充：Properties集合

1. Properties：属性集合。继承HashTable
2. 特点：
   1. 存储属性名和属性值。
   2. 属性名和属性值都是字符串类型。
   3. 没有泛型。
   4. 和流有关。

Properties集合的使用-代码实现

package JavaTest;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

/**
 * Properties集合的使用
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        //1 创建集合
        Properties properties=new Properties();
        //2 添加元素
        properties.setProperty("name","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3 遍历
        //3.1 keySet
        //3.2 entrySet
        //3.3 stringPropertyNames()
        Set<String> pronames=properties.stringPropertyNames();
        for (String string:pronames){
            //{age=20, name=zhangsan}
            //age---20
            //name---zhangsan
            System.out.println(string+"---"+properties.getProperty(string));
        }
        //4 和流有关的方法
        //------------list方法-------------
//        PrintWriter pw=new PrintWriter("E:\\print.txt");
//        properties.list(pw);
//        pw.close();
        //------------store方法-保存--------
//        FileOutputStream fos=new FileOutputStream("E:\\aaastore.properties");//该文件不允许出现中文
//        properties.store(fos,"注释");
//        fos.close();
        //------------load方法-加载---------
        Properties properties1=new Properties();
        FileInputStream fis=new FileInputStream("E:\\\\aaastore.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
        //{age=20, name=zhangsan}
        //age---20
        //name---zhangsan
        //{age=20, name=zhangsan}
    }
}

总结

1. 流的概念：
   1. 内存与存储设备之间传输数据的通道。
2. 流的分类：
   1. 按流向：输入流、输出流；按处理单位：字节流、字符流；按功能：节点流、过滤流；
3. 序列化、反序列化：
   1. 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口。
4. File对象：
   1. 代表物理盘符中的一个文件或者文件夹。