JavaSE进阶IO流

1、IO

1.1、什么是IO

I: Input

O: Output

通过IO可以完成硬盘文件的读和写。

输入与输出都是相对于内存而言的，即从内存中出去叫做写，读入内存叫做读。

1.2、IO流的分类

有多种分类方式：

	一种方式是按照流的方向进行分类：

		以内存作为参照物，往内存中去，叫做输入（Input），或者叫做读（Read）。

		往内存中出来，叫做输出（Output），或者叫做写（Write）。

	另一种方式是按照读取数据的方式不同进行分类：

		有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次8个二进制位。这种流是万能的，什么类型的文件度能够读取，包括：文本文件、图片、声音文件、视频文件等等。

		假设文件file1.txt，采用字节流的方式读取：

			file1.txt中的内容有：a中国bc张三fe

			第一次读：一个字节，正好读到 'a'

			第二次读：一个字节，正好读到 '中' 字符的一半

			第三次读：一个字节，正好读到 '中' 字符的另外一半

		有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取包括：图片、声音、视频等文件，只能读取纯文本文件，连word文件都无法读取。

			假设文件file1.txt，才有字节流的方式读取：

			file1.txt中的内容有：a中国bc张三fe

			第一次读：'a' 字符（'a'字符在Windows系统中占用1个字节）

			第二次读：'中' 字符（'中'字符在Windows系统中占用2个字节）

综上所述，流的分类：

输入流、输出流、字节流、字符流。

java中所有的流都是在：java.io.* 下，java中主要研究：怎么new流对象，调用刘对象的那个方法是读，那个方法是写。

1.3、IO四大家族

四大家族的首领：

    java.io.InputStream   字节输入流
    java.io.OutputSteam   字节输出流

    java.io.Reader  字符输入流
    java.io.Writer  字符输出流

四大家族的首领都是“抽象类”(abstract class)

所有的流都实现了：
	java.io.Closeable接口，都是可关闭的，都有close()方法。流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费（占用）很多资源。养成好习惯，用完流一定要关闭。
	
所有的输出流都实现了：
	java.io.Flushable接口，都是可刷新的，都有flush()方法，养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下，这个刷新表示将“通道/管道”中剩余未输出的数据强行输出完（清空管道），刷新的作用就是清空管道。
	注意：如果不使用flush()可能会导致丢失数据。

注意：在Java中只要“类名”以Stream结尾的都是字节流，以“Reader”或“Writer”结尾的都是字符流。

1.4、需要掌握的16个流

文件专属：
java.io.FileInputStream （掌握）
java.io.FileOutputStream（掌握）
java.io.FileReader
java.io.FileWriter

转换专属（将字节流转换成字符流）：
java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流专属：
java.io.BufferReader
java.io.BufferWriter
java.io.BufferInputStream
java.io.BufferOutputStream

数据流专属：
java.io.DataInputStream
java.io.DataOutputStream

标准输出流
java.io.PrintWriter
java.io.PrintStream（掌握）

对象专属流：
java.io.ObjectInputStream（掌握）
java.io.ObjectOutputStream（掌握）

2、FileInputStream

2.1、使用read()方法读取

package javase.i0;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
java.io.FileInputStream:
    1、文件字节输入流，是万能的，任何类型的文件都可以采用这个流来读取。
    2、字节的方式，完成输入的操作，即完成读的操作（硬盘-->内存）
    
分析以下程序的缺点：
    一次读取一个字节byte，这样内存和硬盘交互的太频繁，基本上时间/资源都耗费在交互上面。能不能一次读取多个字节？可以。
 */
public class FileInputStreamTest01 {
    public static void main(String[] args) {
        // 创建文件字节流对象
        // 以下都是采用的绝对路径的方式
        // 文件路径：F:\Java_Project\bigDate\lesson\javase-io\src\file\1.txt，在Java中\表示转义，idea工具会自动将\变成\\
        // 当然下面的\\以可以写成/
        FileInputStream fileInputStream = null;
        try {
            // 文件1.txt中的内容为：abc
            fileInputStream = new FileInputStream("F:\\Java_Project\\bigDate\\lesson\\javase-io\\src\\file\\1.txt");
            /*
            // 开始往fileInputStream流中读取数据，读取文件的指针一开始并不是指向文件内容的第一个字符，而是在第一个字符之前。
            // 调用一次read()方法，读取文件的指针向后移动移动一位。
            // 这一的read()方法返回字符本身的ASCII值。
            int readData = fileInputStream.read();
            System.out.println(readData);  // 97

            // 逐一读取下一位
            readData = fileInputStream.read();
            System.out.println(readData);  // 98

            readData = fileInputStream.read();
            System.out.println(readData);  // 99

            // 当读取文件的指针已经移动到文件的末尾而读取不到数据时，read()方法返回-1
            readData = fileInputStream.read();
            System.out.println(readData);  // -1
            */
            
            // 下面使用while循环来进行读取
            int filePointer = 0;
            while ((filePointer = fileInputStream.read()) != -1){  // 循环中的表达式只能是true或者false
                System.out.println(filePointer);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 在finally语句中执行流的关闭，确保一定能够关闭。
            if (fileInputStream != null) {  // 避免空指针异常
                // 关闭流的前提是：流不为空！流是null的时候没必要关闭！
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.2、使用byte[]

// 2.txt 文件内容为：abcdef
fis = new FileInputStream("F:\\Java_Project\\bigDate\\lesson\\javase-io\\src\\file\\2.txt");
byte[] bytes = new byte[4]; // 准备一个4字节的byte数组，一次最多读取4个字节。
// 这个方法的返回值是：读取到的字节数量（不是字节本身）。
int readCount = fis.read(bytes); // 第一次读到4个字节
System.out.println(readCount); // 4
// 将字节数组全部转换为字符串
// System.out.println(new String(bytes)); // abcd
// 上面的这行代码有不足之处，不应该全部都转换，应该是读取了多少个字节，才转换多少个字节。
System.out.println(new String(bytes, 0, readCount));

// 第二次读取到两个字节
readCount = fis.read(bytes);
System.out.println(readCount); // 2
// 将字节数组全部转换成字符串
// 这里为什么会输出efcd？
// 原因是：第一次从文件中读取到abcd放入了byte数组中，但是第二次读取的时候只从文件中读取出了ef，这时的ef会覆盖byte数组中
// 原本已经存在的abcd中的ab，而cd没有被覆盖
// System.out.println(new String(bytes));  // efcd
// 不应该全部转换，应该是读取了多少个字节，转换多少个。
System.out.println(new String(bytes, 0, readCount));  // ef

// 如果1个字节都没有读取到，则返回-1
readCount = fis.read(bytes);
System.out.println(readCount); // -1

2.3、最终版

package javase.i0;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
FileInputStream的最终版本，需要掌握

3.txt文件内容：
public class HelloWorld{
    public static void main(String[] args){
        System.out.println("hello world!");
    }
}
 */
public class FileInputStreamTest03 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            // idea的当前目录是“当前的工程目录”。
            fis = new FileInputStream("javase-io/src/file/3.txt");
            // 准备byte数组
            byte[] bytes = new byte[4];

            int readCount = 0;
            // 使用while循环进行遍历
            while ((readCount = fis.read(bytes)) != -1){
                System.out.print(new String(bytes, 0 , readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

2.4、补充

package javase.i0;

import java.lang.String;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
FileInputStream类中的其他常用方法：
     int available() ：返回流当中剩余的没有读到的字节数量
     long skip(long n) ： 跳过几个字节不读
 */
public class FileInputStreamTest04 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            // 2.txt : abcdef
            fis = new FileInputStream("javase-io/src/file/2.txt");
            /*
            System.out.println("总字节数量 : " + fis.available()); // 6
            // 读1个字节
            int readByte = fis.read();
            // 还剩下可以读取的字节数量为：5
            System.out.println("还剩下多少个字节没有读取： " + fis.available());  // 5
            // 这个available()方法有什么用？
            byte[] bytes = new byte[fis.available()]; // 注意：这种方法不适合太大的文件，因为byte数组不能太大。
            // 不需要循环了，直接一次性全部读取
            int read = fis.read(bytes); // 6
            System.out.println(new String(bytes));  // abcdef
             */

            // skip()方法跳过几个字节不读取，这个方法也可能以后会用到！
            fis.skip(3); // 跳过前三个字节开始读取
            System.out.println(fis.read()); // 100(d)

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3、FileOutputStream

3.1、写入文件基础操作

package javase.i0.FileOutPutStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fio = null;
        try {
            // myfile.txt文件不存在的时候会自动新建。
            // 这种方式谨慎使用，这种方式会先将原来文件中的内容清空，然后重新写入。
            // fio = new FileOutputStream("javase-io/src/file/myfile.txt");

            // 以追加的方式在文件末尾写入，不会清空原有文件内容。
            fio = new FileOutputStream("javase-io/src/file/myfile.txt", true);

            // 创建byte数组
            byte[] bytes = {97, 98, 99, 100};  // abcd
            // 将byte数组全部写出！
            fio.write(bytes); // abcd
            // 将byte数组的一部分写出
            fio.write(bytes, 0, 2);  // ab

            String str = "我是一个中国人，我非常的骄傲！";
            // 将字符串转换成byte数组
            byte[] strBytes = str.getBytes();
            fio.write(strBytes);

            // 写完之后一定要“刷新”
            fio.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            if (fio != null) {
                try {
                    fio.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.2、文件复制

package javase.i0;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
使用FileInputStream + FileOutputStream完成文件的拷贝。拷贝的过程应该是一边读、一边写。
使用以上的字节流拷贝文件的时候，文件的类型随意，没有限制。什么样的文件都能够进行拷贝。
 */
public class FileCopy01 {
    public static void main(String[] args) {
        // 创建文件字节输入流对象
        FileInputStream fis = null;
        // 创建文件字节输出流对象
        FileOutputStream fos = null;
        try {
            // 创建文件输入流对象
            fis = new FileInputStream("C:\\Users\\friendship\\ez_php.mp4");
            // 创建文件输出流对象
            fos = new FileOutputStream("C:\\Users\\friendship\\Desktop\\FileCopyTest01.mp4");
            // 创建byte数组，一次读取：1MB
            byte[] bytes = new byte[1024 * 1024];
            int readCount = 0;
            while ((readCount = fis.read(bytes)) != -1){
                fos.write(bytes, 0 , readCount);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 这里最好分开进行关闭，以避免一个流关闭出现问题而影响另外一个流的关闭。
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4、FileReader

package javase.i0;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*
FileReader : 读取纯文本文件。
 */
public class FileReaderTest01 {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            // 创建文件字符输入流对象
            reader = new FileReader("javase-io/src/file/2.txt");
            // 使用char数组保留读取的结果
            char[] chars = new char[4];  // 一次读取4个字符
            int readCount = 0;
            while ((readCount = reader.read(chars)) != -1){
                System.out.print(new String(chars, 0 ,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5、FileWriter

package javase.i0;

import java.io.FileWriter;
import java.io.IOException;

/*
FileWriter:
    文件字符输出流，只能输出普通文本。
 */
public class FileWriterTest01 {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            // 创建文件字符输出流对象
            // 使用这种方式创建写入文件：
            //      1.如果指定的文件不存在，则自动新建文件并写入相关的数据。
            //      2.如果文件已经存在，则会先将原来文件的内容清空再写入相应的数据。
            //      3.这种方法应该谨慎使用。
            // fw = new FileWriter("javase-io/src/file/fw_test.txt");

            // 以追加的形式写入文件信息：
            //      1.如果文件不存在则创建文件。
            //      2.如果文件已经存在则在文件的末尾添加信息。
            fw = new FileWriter("javase-io/src/file/fw_test.txt",true);

            // 创建数据
            char[] chars = {'我','是','中','国','人'};
            // 使用char数组提供数据
            fw.write(chars);
            // 写入一个换行符
            fw.write("\n");
            // 直接写入字符串
            fw.write("我爱我的祖国！");
            //刷新
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5.1、文本文件的复制

package javase.i0;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

// 使用FileReader和FileWriter对文件进行copy，这两个类只能对普通的文本文件进行编辑。
// 能使用记事本打开编辑的都是普通的“文本文件”。
public class FileCopy02RW {
    public static void main(String[] args) {
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            fileReader = new FileReader("javase-io/src/file/myfile.txt");
            fileWriter = new FileWriter("javase-io/src/file/myfile_copy02.txt");
            char[] chars = new char[4]; // 每次读取4个字符
            int readCount = 0;
            while ((readCount = fileReader.read(chars))!= -1){
                fileWriter.write(chars, 0, readCount);
            }
            // 刷新
            fileWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6、缓冲字符流

6.1、BufferedReader

package javase.i0;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*
BufferedReader:
    带有缓冲的字符输入流，使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组，自带缓冲。
 */
public class BufferedReaderTest01 {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            FileReader reader = new FileReader("javase-io/src/javase/i0/FileCopy01.java");
            // 当一个流的构造方法中需要一个另一个流的时候，这个被传进来的流叫做“节点流”。
            // 外部负责包装的这个流，叫做：包装流或处理流。
            // 像当前这个程序来说：FileReader就是一个节点流，BufferedReader就是一个包装流。
            br = new BufferedReader(reader);

            /*
            // 读一行
            String Line = br.readLine();
            System.out.println(Line);

            // 读取第二行
            Line = br.readLine();
            System.out.println(Line);
             */

            // 使用循环来进行读取，br.readLine()方法读取的内容不包含“换行符”。
            String str = null;
            while ((str = br.readLine())!=null){
                System.out.println(str);  //
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            // 对于包装流来说，只需要关闭最外层流，里面的节点流会自动关闭（参考源代码）。
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6.2、流的转换

package javase.i0;

import java.io.*;

/*
InputStreamReader:字节流->字符流
 */

public class BufferedReaderTest02 {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            // 字节流
            FileInputStream in = new FileInputStream("javase-io/src/javase/i0/FileCopy01.java");

            // 通过转换流转换（InputStreamReader将字节流转换为字符流）
            // in是节点流，reader是包装流
            InputStreamReader reader = new InputStreamReader(in);

            // 这个构造方法只能传递一个字符流，不能传递字节流
            // 在这里reader是节点流，br是包装流
            br = new BufferedReader(reader);

            String line = null;
            while ((line = br.readLine())!=null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

7、数据流（了解）

7.1、DataOutputStream

package javase.i0;

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
java.io.DataOutputStream : 数据专属流
这个流可以将数据连同数据类型一并写入文件。注意：这个文件不是普通的文本文件（记事本无法打开）。
 */
public class DataOutputStreamTest01 {
    public static void main(String[] args) {
        // 创建数据专属的字节输出流
        DataOutputStream dataOutputStream = null;
        try {
            // 创建数据专属的字节输出流
            dataOutputStream = new DataOutputStream(new FileOutputStream("javase-io/src/file/data"));
            // 数据
            byte b = 100;
            short s = 200;
            int i = 300;
            long l = 500L;
            float f = 3.0F;
            double d = 3.14;
            boolean sex = false;
            char c = 'a';
            // 写数据
            // 把数据已经数据的类型一并写入到文件当中。
            dataOutputStream.writeByte(b);
            dataOutputStream.writeShort(s);
            dataOutputStream.writeInt(i);
            dataOutputStream.writeLong(l);
            dataOutputStream.writeFloat(f);
            dataOutputStream.writeDouble(d);
            dataOutputStream.writeBoolean(sex);
            dataOutputStream.writeChar(c);
            // 刷新
            dataOutputStream.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dataOutputStream != null) {
                try {
                    dataOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

7.2、DataInputStream

package javase.i0;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/*
    DataInputStream:数据字节输入流
    DataOutputStream写的文件，只能使用 DataInputStream来读取，并且读的时候还需要知道写入数据的顺序。
    读和写的顺序一致时，才可以正常取出数据。
 */
public class DataInputStreamTest01 {
    public static void main(String[] args) {
        DataInputStream dataInputStream = null;
        try {
            dataInputStream = new DataInputStream(new FileInputStream("javase-io/src/file/data"));
            // 开始读取数据
            byte b = dataInputStream.readByte();
            short s = dataInputStream.readShort();
            long l = dataInputStream.readLong();
            int i = dataInputStream.readInt();
            float v = dataInputStream.readFloat();
            double v1 = dataInputStream.readDouble();
            boolean b1 = dataInputStream.readBoolean();
            char c = dataInputStream.readChar();

            // 打印数据
            System.out.println(b);
            System.out.println(s);
            System.out.println(l);
            System.out.println(i + 1000);  // int类型支持数值的四则运算 1300
            System.out.println(v);
            System.out.println(v1);
            System.out.println(b1);
            System.out.println(c);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dataInputStream != null) {
                try {
                    dataInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

8、标准输出流

8.1、PrintStream

package javase.i0;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

/*
java.io.PrintStream:标准的字节输出流，默认输出到控制台。
默认的标准数据流不用显示的手动close();
 */
public class PrintStreamTest01 {
    public static void main(String[] args) {
        // 联合起来写
        System.out.println("hello world"); // hello world

        // 分开写
        PrintStream printStream = System.out;
        printStream.println("我爱Java！");  // 我爱Java！

        try {
            // 设置标准输出流的输出方向，这里设置为输出到“指定的文件中”。通常日志就是使用这种原理。see LoggerUtil.java
            System.setOut(new PrintStream(new FileOutputStream("javase-io/src/file/javaPrintLog.txt", true)));
            System.out.println("printStream-filename");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        // 测试LoggerUtil日志类
        LoggerUtil.log("用户“我爱你Java”登录成功登录系统！");
    }
}

LoggerUtil.java

package javase.i0;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

public class LoggerUtil {
    public static void log(String msg){
        try {
            // 设置标准流的输出方向
            System.setOut(new PrintStream(new FileOutputStream("javase-io/src/file/selfDefineLog.txt", true)));
            // 获取标准数据流对象
            PrintStream printStream = System.out;
            // 获取系统当前时间
            Date date = new Date();
            // 格式化时间格式 yyyy-MM-dd HH:mm:ss SSS
            //              yyyy-MM-dd HH:mm:ss
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");


            // 将日志信息输入到相应的文件中
            printStream.println(sdf.format(date) + " : " + msg);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

9、File类

package javase.i0.File;

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

/*
File:
    1、File类和流四大家族没有关系，所有File不能完成文件的读和写。
    2、File对象代表什么？
        文件和目录路径名的抽象表示形式。
        C:\Drivers 这是一个File对象
        C:\ftlog.log 这也是File对象
        一个File对象有可能对应的是目录，也有可能是文件，File只是一个路径名的抽象表示形式。
    3、需要掌握File类中的常用方法（这个程序中出现的每个方法都要练）。
        String getName()  获取文件名
        boolean isDirectory()   是否是一个目录
        boolean isFile()  是否是一个文件
        long lastModified()  获取文件最后修改的总毫秒数
        File[] listFiles() 获取当前目录下所有的子文件
        ……
 */
public class FileTest01 {
    public static void main(String[] args) {
        // 创建一个File对象
        File f1 = new File("D:\\file");

        // 判断指定的File对象是否存在，即这里表示的是D:\有没有file这个文件或者目录
        System.out.println(f1.exists());

        // 如果D:\file不存在，则以文件的形式创建出来
        /*
        if (!f1.exists()){
            try {
                f1.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        */

        // 如果D:\file不存在，则以目录的形式创建出来
        /*
        if (!f1.exists()){
            f1.mkdir();
        }
        */

        // 创建多重目录 - mkdirs()
        /*
        File f2 = new File("D:\\a\\b\\cc");
        if (!f2.exists()){
            System.out.println(f2.mkdirs());
        }
        */
        /*
        File f3 = new File("D:\\赛题征集\\ez_web\\exp.py");
        // 获取文件的父路径（方法一）
        String parentPath = f3.getParent();
        System.out.println(parentPath); // D:\赛题征集\ez_web\
        // 方法二
        File parentFile = f3.getParentFile();
        System.out.println("获取绝对路径: " + parentFile.getAbsolutePath()); // D:\赛题征集\ez_web\ 即父文件的绝对路径。

        // 获取文件的绝对路径
        File f4 = new File("javase-io/src/file/2.txt");
        System.out.println(f4.getAbsolutePath());  // F:\Java_Project\bigDate\lesson\javase-io\src\file\2.txt
        */

        // 获取文件最后一次修改的时间
        File f5 = new File("D:\\赛题征集\\ez_web\\Writeup.md");
        long l = f5.lastModified(); // 这个毫秒数是从1970年到现在的总的毫秒数
        // 将总毫秒数转换成日期
        Date date = new Date(l);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss SSS");
        System.out.println(sdf.format(date)); // 2021-10-11 17-06-15 361

        // 获取文件大小
        System.out.println(f5.length()); // 2339 字节

        // 获取当前目录下所有的子文件
        File f6 = new File("D:\\赛题征集\\ez_web");
        File[] files = f6.listFiles();
        assert files != null;
        for (File file : files) {
            // 只获取文件名
            System.out.println(file.getName());
        }
    }
}

9.1、目录拷贝

package javase.i0.File;

import java.io.*;

// 目录的拷贝
public class DirCopy {
    public static void main(String[] args) {
        // 拷贝源
        File srcFile = new File("C:\\Users\\friendship\\Desktop\\common");
        // 拷贝目标
        File destFile = new File("D:\\");
        // 调用方法进行拷贝
        copyDir(srcFile, destFile);
    }

    /**
     * Java实现目录的拷贝
     * @param srcFile 拷贝源
     * @param destFile 拷贝目标地址
     */
    private static void copyDir(File srcFile, File destFile) {

        if (srcFile.isFile()){
            // srcFile如果是一个文件，递归结束
            // srcFile是文件的时候进行拷贝，一边读、一边写
            FileInputStream fileInputStream = null;
            FileOutputStream fileOutputStream = null;
            try {
                // 读取目标文件
                fileInputStream = new FileInputStream(srcFile);
                // 写入对应的文件中
                String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() :
                        destFile.getAbsolutePath() + "\\") + srcFile.getAbsolutePath().substring(3);
                fileOutputStream = new FileOutputStream(path);

                // 一边读取、一边写入。每次copy 1MB
                byte[] bytes = new byte[1024 * 1024];
                int readCount = 0;
                while ((readCount = fileInputStream.read(bytes)) != -1){
                    fileOutputStream.write(bytes, 0 , readCount);
                }
                // 刷新
                fileOutputStream.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fileInputStream != null) {
                    try {
                        fileInputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fileOutputStream != null) {
                    try {
                        fileOutputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            // 如果是文件，写入完成之后直接结束。
            return;
        }

        // 获取所有的子目录
        File[] files = srcFile.listFiles();
        if (files != null){
            for (File file : files) {
                // 获取所有文件的（包括目录和文件）绝对路径
                // System.out.println(file.getAbsolutePath());
                if (file.isDirectory()){
                    // 新建对应的目录
                    String srcDir = file.getAbsolutePath().substring(3);
                    String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() :
                            destFile.getAbsolutePath() + "\\") + srcDir;
                    File newFile = new File(destDir);
                    if (!newFile.exists()){
                        newFile.mkdirs();
                    }
                }
                // 递归调用
                copyDir(file, destFile);
            }
        }
    }
}

10、对象流

10.1、序列化与反序列化

序列化：Serialize

在进行对象的序列化时，如果一个类的某个属性被transient关键字所修饰时，表示这个关键字不参与序列化。

反序列化：Deserialize

10.2、序列化

Student.java

package javase.Bean;

import java.io.Serializable;

public class Student implements Serializable {

    // Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。
    // 这里没有手动写出来，Java虚拟机会默认提供这个反序列化版本号。
    private int no;
    private String name;

    public Student() {
    }

    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

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

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

ObjectOutputStreamTest01.java

package javase.i0.Serialize;

import javase.Bean.Student;

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

/*
1、java.io.NotSerializableException：
    Student对象不支持序列化

2、参与序列化和反序列化的对象，必须实现Serializable接口。

3、注意：通过源代码发现，Serializable接口只是一个标志接口：
    public interface Serializable {}
    这个接口当中什么代码都没有，那么有什么用呢？
        起到标识、标志的作用，Java虚拟机看到这个类实现这个接口后，可能会对这个类进行特殊待遇。
        Serializable这个标志接口是给Java虚拟机参考的，Java虚拟机看到这个接口之后，会为该类自动生成一个序列化版本号。

4、序列化版本号有什么用？

 */
public class ObjectOutputStreamTest01 {
    public static void main(String[] args) throws Exception {
        // 创建Java对象
        Student s = new Student(1, "zhangsan");
        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("javase-io/src/file/students"));
        // 序列化对象
        oos.writeObject(s);
        // 刷新
        oos.flush();
        // 关闭
        oos.close();
    }
}

10.3、反序列化

package javase.i0.Serialize;

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

/*
反序列化对象
 */
public class ObjectInputStreamTest01 {
    public static void main(String[] args) throws Exception {
        // 创建反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("javase-io/src/file/students"));
        // 这里的使用readObject()读取文件中的内容，开始反序列化。
        Object students = ois.readObject();
        // 反序列化回来的是一个学生对象。所有会默认调用Students类中的toString()方法。
        System.out.println(students);
        // 关闭
        ois.close();
    }
}

10.4、补充

package javase.i0.Serialize;

import javase.Bean.User;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

/*
一次序列化多个对象呢？
    可以，将对象放到集合当中，序列化集合。
提示：参与序列化的ArrayList集合以及集合中的元素User都需要实现java.io.Serializable接口。
 */
public class ObjectOutputStreamTest02  {
    public static void main(String[] args) throws Exception {
        List<User> userList = new ArrayList<>();
        userList.add(new User(1, "zhangsan"));
        userList.add(new User(2, "lisi"));
        userList.add(new User(3, "wangliu"));

        // 开始序列化一个List集合
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("javase-io/src/file/userList"));

        // 写入List集合中的对象
        oos.writeObject(userList);

        // 刷新
        oos.flush();

        // 关闭
        oos.close();
    }
}

package javase.i0.Serialize;

import javase.Bean.User;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;

/*
反序列化集合。
 */
public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("javase-io/src/file/userList"));
        Object obj = ois.readObject();
        // System.out.println(obj instanceof List);  // true
        List<User> userList = (List<User>) obj;
        for (User user : userList) {
            // 输出：
            /*
                User{no=1, username='zhangsan'}
                User{no=2, username='lisi'}
                User{no=3, username='wangliu'}
             */
            System.out.println(user);  // 输出引用的时候会自动调用引用的toString()方法。

        }
        //关闭
        ois.close();
    }
}

transient关键字；

public class User implements Serializable {
    private int no;
    // username使用transient关键字修饰，表示在序列化User类的时候，username不参加序列化。
    private transient String username;

    public User(){}

    public User(int no, String username) {
        this.no = no;
        this.username = username;
    }
}

10.5、序列化版本号

Student.java

package javase.Bean;

import java.io.Serializable;

public class Student implements Serializable {
    // Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。
    // 这里没有手动写出来，Java虚拟机会默认提供这个反序列化版本号。
    // 建议将序列化版本号手动的写出来，不建议自动生成。
    // private static final long serialVersionUID = 1L; // java虚拟机识别一个类的时候先通过类名，如果不能区分；在通过序列化版本号。
    private static final long serialVersionUID = 5506495958222352416L; // idea自动生成。
    private int no;
    private String name;
    // 过了很久，Student这个类源代码改动了，源代码改动之后，需要重新编译，编译之后生成了全新的直接码文件。
    // 并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变。
    // private int age;

    public Student() {
    }

    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

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

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

ObjectOutputStreamTest01.java

package javase.i0.Serialize;

import javase.Bean.Student;

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

/*
1、java.io.NotSerializableException：
    Student对象不支持序列化

2、参与序列化和反序列化的对象，必须实现Serializable接口。

3、注意：通过源代码发现，Serializable接口只是一个标志接口：
    public interface Serializable {}
    这个接口当中什么代码都没有，那么有什么用呢？
        起到标识、标志的作用，Java虚拟机看到这个类实现这个接口后，可能会对这个类进行特殊待遇。
        Serializable这个标志接口是给Java虚拟机参考的，Java虚拟机看到这个接口之后，会为该类自动生成一个序列化版本号。

4、序列化版本号有什么用？
    javase.Bean.Student;
    local class incompatible:
        stream classdesc serialVersionUID = 478455862847212921（十年前）
        local class serialVersionUID = 5506495958222352416（十年后）

    Java语言中是采用什么机制来区分类的？
        第一：首先通过类名进行对比，如果类名不一样，肯定不是同一个类。
        第二：如果类名一样，再怎么进行区分？靠的就是序列化版本号进行区分。

        张三编写了一个类：com.zh0u.bean.Student implements Serializable
        李四编写了一个类：com.zh0u.bean.Student implements Serializable
        不同的人编写了同一个类，但“这两个类确实不是同一个类”。这个时候序列化版本号就起上作用了，对于Java虚拟机来说，它是可以区分开
        这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们序列化版本号不一样。所以区分开了。（这是自动生成序列化版本的好处）

        请思考：
            这种自动生成序列化版本号有什么缺陷？
                这种自动生成序列化版本号缺点是：一旦代码确定之后，不能进行后续的修改，因为只要修改，必然后重新编译，此时会生成全新的
                的序列化版本号，这个时候Java虚拟机会自认为这是一个全新的类。（这样就不好了！）


    重点结论：
        凡是一个实现了Serializable接口，建议给该类提供一个补丁不变的序列化版本号。这样，以后这个类即使代码被修改了，但是版本号不变，
        Java虚拟机认为是同一个类。
 */
public class ObjectOutputStreamTest01 {
    public static void main(String[] args) throws Exception {
        // 创建Java对象
        Student s = new Student(1, "zhangsan");
        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("javase-io/src/file/students"));
        // 序列化对象
        oos.writeObject(s);
        // 刷新
        oos.flush();
        // 关闭
        oos.close();
    }
}

ObjectInputStreamTest01.java

package javase.i0.Serialize;

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

/*
反序列化对象
 */
public class ObjectInputStreamTest01 {
    public static void main(String[] args) throws Exception {
        // 创建反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("javase-io/src/file/students"));
        // 这里的使用readObject()读取文件中的内容，开始反序列化。
        Object students = ois.readObject();
        // 反序列化回来的是一个学生对象。所有会默认调用Students类中的toString()方法。
        System.out.println(students);
        // 关闭
        ois.close();
    }
}

idea自动生成serilizable版本号，

10.6、IO与Properties

userInfo.properties

# 建议key和value之间使用=进行连接
# 不建议使用“:”好的方式进行区分，如：username:zh0u_admin不建议使用

username=zh0u_admin
password=_zh0u_123

package javase.i0;

import java.io.FileReader;
import java.util.Properties;

/*
IO+Properties的联合使用：
    非常好的一个设计理念：
        以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取。
        将来只需要修改这个文件的内容，Java代码不需要改动，不需要重新
        编译，服务器也不需要重启。就可以动态的拿到信息。

    类似于以上机制的这种文件被称为配置文件。
    并且当配置文件中的内容格式是：
        key1=value1  # 这里的key和value之间最好不要有空格。
        key2=value2
    的时候，我们把这种配置文件叫做“属性属性配置文件”。
    Java规范中有要求：属性配置文件建议以.properties结尾，但这不是必须的。
    这种以.properties结尾的文件在Java中被称为：属性配置文件。
    其中Properties对象是专门存放属性配置文件内容的一个类。在属性配置文件中，#表示注释。
    如果属性配置文件中的key部分出现重复时，这个时候的value会自动覆盖。
 */
public class IoPropertiesTest01 {
    public static void main(String[] args) throws Exception{
        // Properties是一个Map集合，key和value都是String类型。
        // 将javase-io/src/file/userInfo文件中的数据加载到Properties对象当中。
        // 新建一个输入流对象
        FileReader fileReader = new FileReader("javase-io/src/file/userInfo.properties");
        // 新建一个Map集合
        Properties properties = new Properties();
        // 调用Properties对象的load方法将文件中的数据加载到Map集合中。
        properties.load(fileReader); // 文件中的数据顺着管道加载到Map集合中，其中等号左边做key，右边做value。
        // 通过key来获取value
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");
        System.out.println(username + " : " + password);
    }
}

10.6、IO与Properties

userInfo.properties

# 建议key和value之间使用=进行连接
# 不建议使用“:”好的方式进行区分，如：username:zh0u_admin不建议使用

username=zh0u_admin
password=_zh0u_123

package javase.i0;

import java.io.FileReader;
import java.util.Properties;

/*
IO+Properties的联合使用：
    非常好的一个设计理念：
        以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取。
        将来只需要修改这个文件的内容，Java代码不需要改动，不需要重新
        编译，服务器也不需要重启。就可以动态的拿到信息。

    类似于以上机制的这种文件被称为配置文件。
    并且当配置文件中的内容格式是：
        key1=value1  # 这里的key和value之间最好不要有空格。
        key2=value2
    的时候，我们把这种配置文件叫做“属性属性配置文件”。
    Java规范中有要求：属性配置文件建议以.properties结尾，但这不是必须的。
    这种以.properties结尾的文件在Java中被称为：属性配置文件。
    其中Properties对象是专门存放属性配置文件内容的一个类。在属性配置文件中，#表示注释。
    如果属性配置文件中的key部分出现重复时，这个时候的value会自动覆盖。
 */
public class IoPropertiesTest01 {
    public static void main(String[] args) throws Exception{
        // Properties是一个Map集合，key和value都是String类型。
        // 将javase-io/src/file/userInfo文件中的数据加载到Properties对象当中。
        // 新建一个输入流对象
        FileReader fileReader = new FileReader("javase-io/src/file/userInfo.properties");
        // 新建一个Map集合
        Properties properties = new Properties();
        // 调用Properties对象的load方法将文件中的数据加载到Map集合中。
        properties.load(fileReader); // 文件中的数据顺着管道加载到Map集合中，其中等号左边做key，右边做value。
        // 通过key来获取value
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");
        System.out.println(username + " : " + password);
    }
}