一、文件与文件流基础

文件与文件流概念

• 文件：保存数据的地方

• 文件流：文件在程序中是以流的形式来操作的
  

  • 流：数据在数据源（文件）和程序（内存）之间经历的路径
  • 输入流：数据从数据源（文件）到程序（内存）的路径
  • 输出流：数据从程序（内存）到数据源（文件）的路径

二、文件操作

创建文件的三种方式

// 1. new File(String pathname) - 根据路径构建File对象
// 2. new File(File parent, String child) - 根据父目录文件+子路径构建
// 3. new File(String parent, String child) - 根据父目录+子路径构建

方法一：直接指定路径

@Test
public void create01() {
    String filePath = "d:\\news1.txt";
    File file = new File(filePath);
    try {
        file.createNewFile();  // 创建新文件
        System.out.println("文件创建成功");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

方法二：使用父目录File对象

@Test
public void create02() {
    File parentFile = new File("d:\\");
    String fileName = "news2.txt";
    File file = new File(parentFile, fileName);
    try {
        file.createNewFile();
        System.out.println("创建成功~");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

方法三：使用父目录路径

@Test
public void create03() {
    String parentPath = "d:\\";
    String fileName = "news4.txt";
    File file = new File(parentPath, fileName);
    try {
        file.createNewFile();
        System.out.println("创建成功~");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

重要说明：这里的File对象在Java程序中只是一个对象，只有执行了createNewFile()方法，才会真正在磁盘创建该文件。

获取文件信息

File file = new File("d:\\test.txt");

System.out.println("文件名字=" + file.getName());
System.out.println("文件绝对路径=" + file.getAbsolutePath());
System.out.println("文件父级目录=" + file.getParent());
System.out.println("文件大小(字节)=" + file.length());
System.out.println("文件是否存在=" + file.exists());    // true
System.out.println("是不是一个文件=" + file.isFile());    // true
System.out.println("是不是一个目录=" + file.isDirectory()); // false

目录操作及删除

• mkdir()：创建一级目录
• mkdirs()：创建多级目录
• delete()：删除空目录或文件

三、IO流原理与分类

IO流基础

1. I/O是Input/Output的缩写，用于处理数据传输如读/写文件，网络通讯等
2. Java程序中，对于数据的输入/输出操作以"流(stream)"的方式进行
3. java.io包下提供了各种"流"类和接口，用以获取不同种类的数据
4. 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中
5. 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中

节点流与处理流

1. 节点流：可以从一个特定的数据源读写数据，如FileReader、FileWriter
2. 处理流（包装流）：是"连接"在已存在的流（节点流或处理流）之上，为程序提供更强大的读写功能，如BufferedReader、BufferedWriter

处理流例子：BufferReader

BufferedReader类中，有属性Reader,即可以封装一个节点流，该节点流可以是任意的.只要是Reader的子类。
即向上转型。操作对象可以有许多种了，不局限在一种数据源上【修饰器模式】

区别与联系

1. 节点流是底层流/低级流，直接跟数据源相接
2. **处理流（包装流）**包装节点流，既可消除不同节点流的实现差异，也可提供更方便的方法来完成输入输出
3. 处理流对节点流进行包装，使用了修饰器设计模式，不直接与数据源相连

处理流的优势

1. 性能提高：主要以增加缓冲的方式来提高输入输出的效率
2. 操作便捷：提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便

IO流分类

• 按操作数据单位：字节流（8bit），字符流（按字符）
• 按数据流的流向：输入流，输出流
• **
  按流的角色**：节点流，处理流/包装流

抽象基类        字节流        字符流
输入流         InputStream   Reader
输出流         OutputStream  Writer

四、字节流

InputStream字节输入流

InputStream抽象类是所有字节输入流的超类

常用子类：

1. FileInputStream：文件输入流
2. BufferedInputStream：缓冲字节输入流
3. ObjectInputStream：对象字节输入流
   

读取单个字节

@Test
public void readFile01() {
    String filePath = "e:\\hello.txt";
    int readData = 0;
    FileInputStream fileInputStream = null;
    
    try {
        // 创建FileInputStream对象，用于读取文件
        fileInputStream = new FileInputStream(filePath);
        // 从该输入流读取一个字节的数据，如果没有输入可用，此方法将阻塞
        // 如果返回-1，表示读取完毕
        while ((readData = fileInputStream.read()) != -1) {
            System.out.print((char) readData);  // 转成char显示
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 关闭文件流，释放资源
        try {
            if (fileInputStream != null) {
                fileInputStream.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

读取多个字节

@Test
public void readFile02() {
    String filePath = "e:\\hello.txt";
    // 字节数组
    byte[] buf = new byte[8];  // 一次读取8个字节
    int readLen = 0;
    FileInputStream fileInputStream = null;
    
    try {
        // 创建FileInputStream对象，用于读取文件
        fileInputStream = new FileInputStream(filePath);
        // 从该输入流读取最多buf.length字节的数据到字节数组
        // 如果返回-1，表示读取完毕
        // 如果读取正常，返回实际读取的字节数
        while ((readLen = fileInputStream.read(buf)) != -1) {
            System.out.print(new String(buf, 0, readLen));  // 显示
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 关闭文件流，释放资源
        try {
            if (fileInputStream != null) {
                fileInputStream.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

OutputStream字节输出流

OutputStream抽象类是所有字节输出流的超类

重要区别：

1. new FileOutputStream(filePath)：写入内容会覆盖原来的内容
2. new FileOutputStream(filePath, true)：写入内容是追加到文件后面

五、字符流

FileReader字符输入流

FileReader是字符流，按照字符来操作IO

相关方法：

1. new FileReader(File/String)
2. read()：每次读取单个字符，返回该字符，如果到文件末尾返回-1
3. read(char[])：批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1

相关API：

1. new String(char[])：将char[]转换成String
2. new String(char[], off, len)：将char[]的指定部分转换成String

FileWriter字符输出流

常用方法：

1. new FileWriter(File/String)：覆盖模式，流的指针在首端
2. new FileWriter(File/String, true)：追加模式，流的指针在尾端
3. write(int)：写入单个字符
4. write(char[])：写入指定数组
5. write(char[], off, len)：写入指定数组的指定部分
6. write(String)：写入整个字符串
7. write(String, off, len)：写入字符串的指定部分

相关API：String.toCharArray()：将String转换成char[]

重要注意：FileWriter使用后，必须关闭(close)或刷新(flush)，否则写入不到指定的文件！

六、处理流

BufferedReader和BufferedWriter

1. BufferedReader和BufferedWriter属于字符流，按照字符来读取数据
2. 关闭时，只需要关闭外层流即可
3. 因为Reader和Writer是按字符读取，因此不能操作二进制文件（字节文件），比如图片、音乐，会造成读取数据错误

// 读取文件示例
String filePath = "e:\\a.java";
// 创建BufferedReader
BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
String line;  // 按行读取，效率高

// 说明：
// 1. bufferedReader.readLine()是按行读取文件
// 2. 当返回null时，表示文件读取完毕
while ((line = bufferedReader.readLine()) != null) {
    System.out.println(line);
}

// 关闭流，只需要关闭BufferedReader，底层会自动关闭节点流
bufferedReader.close();

实现文件拷贝

// 1. 创建缓冲流对象，套接在指定的节点流基础上
BufferedReader br = new BufferedReader(new FileReader("d:\\a.java"));
BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\copya.java"));

// 2. 边读边写
String line;
while ((line = br.readLine()) != null) {
    bw.write(line);
    bw.newLine();  // 插入一个和系统相关的换行
}

// 3. 关闭
bw.close();
br.close();

BufferedInputStream和BufferedOutputStream

1. 可以完成二进制拷贝，也可以操作文本文件
2. BufferedInputStream是字节流，在创建时会创建一个内部缓冲区数组
   
   3.BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

七、对象流

ObjectInputStream和ObjectOutputStream

1. ObjectOutputStream提供序列化功能
2. ObjectInputStream提供反序列化功能

序列化和反序列化

1. 序列化：在保存数据时，保存数据的值和数据类型
2. 反序列化：在恢复数据时，恢复数据的值和数据类型
3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，必须实现以下接口之一：
   • Serializable（标记接口，没有方法）
   • Externalizable（有方法需要实现，一般使用上面的Serializable接口）

序列化示例

// 1. 创建流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src\\data.dat"));

// 2. 写入对象（序列化）
oos.writeInt(100);           // 将整型值100写入流中（Integer实现了Serializable）
oos.writeBoolean(true);      // Boolean实现了Serializable
oos.writeChar('a');          // Character实现了Serializable
oos.writeDouble(9.5);        // Double实现了Serializable
oos.writeUTF("张三丰");      // String实现了Serializable，写入整个字符串
oos.writeObject(new Dog("小黄", 10));  // 序列化对象
oos.writeObject(new Dog("小花", 3));   // 序列化对象
oos.writeObject(new Dog("小白", 2));   // 序列化对象

// 3. 关闭
oos.close();
System.out.println("以序列化的方式保存成功");

反序列化示例

顺序要一致

// 1. 创建流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\data.dat"));

// 2. 读取，注意顺序要与写入时一致
System.out.println(ois.readInt());
System.out.println(ois.readBoolean());
System.out.println(ois.readChar());
System.out.println(ois.readDouble());
System.out.println(ois.readUTF());
System.out.println(ois.readObject());
System.out.println(ois.readObject());
System.out.println(ois.readObject());

// 3. 关闭
ois.close();
System.out.println("以反序列化的方式读取(恢复)成功");

注意事项和细节说明

1. 读写顺序要一致
2. 要求序列化或反序列化对象，需要实现Serializable
3. 序列化的类中建议添加SerialVersionUID，提高版本的兼容性
4. 序列化对象时，默认将所有属性都进行序列化，但除了static或transient修饰的成员
5. 序列化对象时，要求里面属性的类型也需要实现序列化接口
6. 序列化具备可继承性，如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

八、标准输入输出流

	编译类型	运行类型	默认设备
System.in	InputStream	BufferedInputStream	键盘
System.out	PrintStream	PrintStream	显示器

• 传统方法System.out.println("")是使用out对象将数据输出到显示器
• 传统方法Scanner是从标准输入键盘接收数据

九、转换流

1. InputStreamReader：Reader的子类，可以将InputStream（字节流）包装成Reader（字符流）
2. OutputStreamWriter：Writer的子类，实现将OutputStream（字节流）包装成Writer（字符流）
3. 处理纯文本数据时，使用字符流效率更高，并可有效解决中文问题，建议将字节流转换成字符流
4. 可以在使用时指定编码格式（如utf-8, gbk, gb2312, ISO8859-1等）

十、打印流

PrintStream和PrintWriter

打印流只有输出流，没有输入流

// PrintStream示例
PrintStream out = System.out;
out.print("john");
// 可以使用write方法，写入到标准输出即显示器
// out.write("john".getBytes());
out.close();

// 重定向输出设备到文件
System.setOut(new PrintStream("e:\\t1.txt"));
System.out.println("韩顺平教育");  // 输出到文件

// PrintWriter示例
// 说明：autoFlush-boolean变量；如果为true，则println、printf或format方法将刷新输出缓冲区
PrintWriter pw = new PrintWriter(new FileWriter("e:\\t3.txt"));
// 如果写的是System.out就是打印(输出)到默认设备显示器
// PrintWriter pw = new PrintWriter(System.out);
pw.println("hi 韩顺平教育");  // 打印(输出)到文件
pw.write("hi 架构师");       // 打印(输出)到文件
pw.close();  // close是刷新(flush)+关闭，才会把内容写进文件

十一、Properties类

概述

1. 父类是Hashtable，底层实现为哈希表
2. 专门用于读写配置文件的集合类
3. 配置文件格式：键=值（每行一对，不需要空格，值不需要引号，默认类型是String）

Properties常用方法

• load：加载配置文件的键值对到Properties对象
• list：将数据显示到指定设备
• getProperty(key)：根据键获取值
• setProperty(key, value)：设置键值对到Properties对象
• store：将Properties中的键值对存储到配置文件（在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码）

传统方法读取配置文件

public class Properties01 {
    public static void main(String[] args) throws IOException {
        // 读取mysql.properties文件，并得到ip、user和pwd
        BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties"));
        String line = "";
        
        while ((line = br.readLine()) != null) {  // 循环读取
            String[] split = line.split("=");
            // 如果我们要求指定的ip值
            if ("ip".equals(split[0])) {
                System.out.println(split[0] + "值是：" + split[1]);
            }
        }
        br.close();
    }
}

使用Properties类操作配置文件

// 1. 创建Properties对象
Properties pro = new Properties();

// 2. 读取配置文件（将文件数据->内存pro）
pro.load(new FileReader("src\\mysql.properties"));

// 3. 遍历
// 全部显示
pro.list(System.out);

// 根据键获取值
String name = pro.getProperty("name");
String password = pro.getProperty("pwd");
System.out.println(name + "\t" + password);

// 4. 修改和写入配置文件
// 1) 创建Properties集合对象
Properties pro = new Properties();

// 2) 向Properties中添加键值对信息
// 该文件没有这个key，则创建。有则修改。（Hashtable特性）
pro.setProperty("charset", "utf-8");
pro.setProperty("port", "3306");
pro.setProperty("name", "天津");

// 3) 存储到文件中（pro -> 文件）
pro.store(new FileOutputStream("src\\mysql2.properties"), null);  // null处可以改为写入注释
// 注释在文件首行生成，格式：#内容

注意：使用store方法保存中文时，会存储为unicode码，可以使用在线工具如http://tool.chinaz.com/tools/unicode.aspx进行unicode码查询。