一、文件

1.1 什么是文件

文件是保存数据的地方，最常见比如 word 文档,，txt 文件，excel文件，mp4文件等。它既可以保存一张图片、也可以保存视频、声音……

1.2 文件流

文件在程序中是以流的形式来操作的
IO 流 - 图1
流：数据在数据源（文件）和程序（内存）之间经历的路径
输入流：数据从数据源（文件）到程序（内存）的路径
输出流：数据从程序（内存）到数据源（文件）的路径

二、常用的文件操作

2.1 创建文件对象相关构造器和方法

相关方法
new File(String pathname) //根据路径构建一个 File对象
new File(File parent, String child) //根据父目录文件 + 子路径构建
new File(String parent, String child) //根据父目录 + 子路径构建

createNewFile() 创建新文件

应用案例演示

  1. package com.hspedu.file;
  3. import org.junit.jupiter.api.Test;
  5. import java.io.File;
  6. import java.io.IOException;
  8. /**
  9.  * @author HarborGao
  10.  * @version 1.0
  11.  */
  12. public class FileCreate {
  13.     public static void main(String[] args) {
  15.     }
  16.     //方式一
  17.     @Test
  18.     public void create01() {
  19.         String filePath = "E:\\news1.txt";
  20.         File file = new File(filePath);
  22.         try {
  23.             file.createNewFile();
  24.             System.out.println("文件创建成功");
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29.     //方式二
  30.     @Test
  31.     public void create02() {
  32.         File parentFilePath = new File("e:\\");
  33.         String fileName = "news2.txt";
  34.         File file = new File(parentFilePath, fileName);
  36.         try {
  37.             file.createNewFile();
  38.             System.out.println("文件创建成功");
  39.         } catch (IOException e) {
  40.             e.printStackTrace();
  41.         }
  42.     }
  43.     //方式三
  44.     @Test
  45.     public void create03() {
  46.         String parentPath = "E:/";
  47.         String filePath = "news3.txt";
  48.         File file = new File(parentPath,filePath);
  50.         try {
  51.             file.createNewFile();
  52.             System.out.println("文件创建成功");
  53.         } catch (IOException e) {
  54.             e.printStackTrace();
  55.         }
  56.     }
  57. }

2.2 获取文件的相关信息

getName 获取文件名
getAbsolutePath 获取文件绝对路径
getParent 获取父级目录
length 文件大小（字节）
exists 文件是否存在
isFile 是否是一个文件
isDirectory 是否是一个目录

案例演示

  1. package com.hspedu.file;
  3. import org.junit.jupiter.api.Test;
  5. import java.io.File;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  */
  11. public class FileInformation {
  12.     public static void main(String[] args) {
  14.     }
  15.     @Test
  16.     public void info() {
  17.         File file = new File("e:\\news1.txt");
  18.         System.out.println("文件名=" + file.getName());
  19.         System.out.println("文件绝对路径=" + file.getAbsolutePath());
  20.         System.out.println("文件父级目录=" + file.getParent());
  21.         System.out.println("是否是一个文件=" + file.isFile());
  22.         System.out.println("是否是一个目录=" + file.isDirectory());
  23.         System.out.println("文件是否存在=" + file.exists());
  24.         System.out.println("文件大小(字节)=" + file.length());
  25.     }
  26. }

2.3 目录的操作和文件删除

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

案例演示

  1. package com.hspedu.file;
  3. import org.junit.jupiter.api.Test;
  5. import java.io.File;
  6. import java.io.IOException;
  8. /**
  9.  * @author HarborGao
  10.  * @version 1.0
  11.  */
  12. public class Directory {
  13.     public static void main(String[] args) {
  15.     }
  17.     @Test
  18.     public void m1() {
  19.         String filePath = "e:\\news1.txt";
  20.         File file = new File(filePath);
  21.         if (file.exists()) {
  22.             if (file.delete()) {
  23.                 System.out.println(filePath + "删除成功");
  24.             } else {
  25.                 System.out.println(filePath + "删除失败");
  26.             }
  27.         } else {
  28.             System.out.println("该文件不存在...");
  29.         }
  30.     }
  31.     @Test
  32.     public void m2() {
  33.         String filePath = "e:\\demo02";
  34.         File file = new File(filePath);
  35.         if (file.exists()) {
  36.             if (file.delete()) {
  37.                 System.out.println(filePath + "删除成功");
  38.             } else {
  39.                 System.out.println(filePath + "删除失败");
  40.             }
  41.         } else {
  42.             System.out.println("该目录不存在...");
  43.         }
  44.     }
  45.     @Test
  46.     public void m3() {
  47.         String directoryPath = "e:\\demo\\a\\b\\c";
  48.         File file = new File(directoryPath);
  49.         if (file.exists()) {
  50.             System.out.println("该目录已存在");
  51.         } else {
  52.             if (file.mkdirs()) {
  53.                 System.out.println(directoryPath + "目录创建成功");
  54.             } else {
  55.                 System.out.println(directoryPath + "目录创建失败");
  56.             }
  57.         }
  58.     }
  59. }

三、IO 流原理及流的分类

3.1 Java IO 流原理

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

3.2 流的分类

按操作数据单位不同分为：字节流（8 bit）二进制文件，字符流（按字符）文本文件
按数据流的流向不同分为：输入流、输出流
按流的角色的不同分为：节点流，处理流/包装流

（抽象基类） 字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Writer
  1. Java的 IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的
  2. 由这4个类派生出来的子类名称都是以其父类名作为子类名后缀

四、IO 流体系图 - 常用的类

4.1 IO 流体系图

image.png

4.2 文件 VS 流

文件是存储在磁盘等媒介上的
而 流 是用来传输文件的

可以将文件看成商品，磁盘看成物流中心，流看成快递员，内存看成买家
image.png

4.3 FileInputStream 介绍

FileInputStream：文件字节输入流 用于读取磁盘上的文件到内存，按字节读取

应用案例：使用 FileInputStream 读取 hello.txt文件，并将文件内容显示到控制台

  1. package com.hspedu.file;
  3. import org.junit.jupiter.api.Test;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileNotFoundException;
  8. import java.io.IOException;
  10. /**
  11.  * @author HarborGao
  12.  * @version 1.0
  13.  * 演示 FileInputStream 的使用(字节输入流 文件 -> 程序)
  14.  */
  15. public class FileInputStream_ {
  16.     public static void main(String[] args) {
  18.     }
  20.     /**
  21.      * 演示读取文件
  22.      * 单个字节读取，效率比较低
  23.      * -> 使用 read(byte[] b)
  24.      */
  25.     @Test
  26.     public void readFile01() {
  27.         String filePath = "e:\\hello.txt";
  28.         int readDate = 0;
  29.         FileInputStream fileInputStream = null;
  30.         try {
  31.             //创建 FileInputStream 对象，用于读取 文件
  32.             fileInputStream = new FileInputStream(filePath);
  33.             //从该输入流读取一个字节的数据。如果没有输入可用，此方法将阻止。
  34.             //如果返回-1，表示读取完毕
  35.             while ((readDate = fileInputStream.read()) != -1) {
  36.                 System.out.print((char) readDate);  //转成char显示
  37.             }
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         } finally {
  41.             //关闭文件流，释放资源
  42.             try {
  43.                 fileInputStream.close();
  44.             } catch (IOException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         }
  48.     }
  49.     /**
  50.      * 演示读取文件
  51.      * -> 使用 read(byte[] b) 读取文件，提高效率
  52.      */
  53.     @Test
  54.     public void readFile02() {
  55.         String filePath = "e:\\hello.txt";
  56.         //字节数组
  57.         byte[] buf = new byte[8];  //一次读取8个字节
  58.         int readLen = 0;
  59.         FileInputStream fileInputStream = null;
  60.         try {
  61.             //创建 FileInputStream 对象，用于读取 文件
  62.             fileInputStream = new FileInputStream(filePath);
  63.             //从该输入流最多读取8个字节的数据到字节数组。此方法将阻塞，直到某些输入可用
  64.             //如果返回-1，表示读取完毕
  65.             //如果读取正常，返回实际读取的字节数
  66.             while ((readLen = fileInputStream.read(buf)) != -1) {
  67.                 System.out.print(new String(buf,0,readLen));  //转成char显示
  68.             }
  69.         } catch (IOException e) {
  70.             e.printStackTrace();
  71.         } finally {
  72.             //关闭文件流，释放资源
  73.             try {
  74.                 fileInputStream.close();
  75.             } catch (IOException e) {
  76.                 e.printStackTrace();
  77.             }
  78.         }
  79.     }
  80. }

4.4 FileOutputStream 介绍

FileInputStream：文件字节输出流 用于将程序（内存）中的数据写入到磁盘上的文件中，按字节写入

应用案例：使用 FileOutputStream 在 a.txt 文件中写入 “hello,world”，如果文件不存在，会创建文件

  1. package com.hspedu.outputstream_;
  3. import org.junit.jupiter.api.Test;
  5. import java.io.FileNotFoundException;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  8. import java.nio.charset.StandardCharsets;
  10. /**
  11.  * @author HarborGao
  12.  * @version 1.0
  13.  */
  14. public class FileOutputStream_ {
  15.     public static void main(String[] args) {
  17.     }
  19.     /**
  20.      * 演示 FileOutputStream 将数据写入文件中
  21.      * 如果该文件不存在，则创建该文件
  22.      * 说明:
  23.      * 1. new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容
  24.      * 2. new FileOutputStream(filePath,true) 创建方式，当写入内容时，是在文件末尾追加内容
  25.      */
  26.     @Test
  27.     public void writeFile() {
  28.         //创建FileOutputStream对象
  29.         String filePath = "e:\\a.txt";
  30.         FileOutputStream fileOutputStream = null;
  32.         try {
  33.             fileOutputStream = new FileOutputStream(filePath);
  34.             //写入一个字节
  35.             //fileOutputStream.write('a');
  37.             //写入字符串
  38.             String str = "hello,world!";
  39.             //getBytes() 可以把字符串转成字节数组
  40.             //fileOutputStream.write(str.getBytes());
  42.             //写入字符串，从指定索引写入指定长度的字节
  43.             fileOutputStream.write(str.getBytes(),2,6);
  45.         } catch (IOException e) {
  46.             e.printStackTrace();
  47.         } finally {
  48.             try {
  49.                 fileOutputStream.close();
  50.             } catch (IOException e) {
  51.                 e.printStackTrace();
  52.             }
  53.         }
  54.     }
  56. }

4.5 编程练习：拷贝

按照前面学习的内容，完成图片/音乐的拷贝。

  1. package com.hspedu.outputstream_;
  3. import org.junit.jupiter.api.Test;
  5. import java.io.*;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  */
  11. public class FileCopy {
  12.     public static void main(String[] args) {
  14.     }
  16.     @Test
  17.     public void copy() {
  18.         String filePath = "e:\\546.jpg";
  19.         String newFilePath = "d:\\tom.jpg";
  20.         FileInputStream fileInputStream = null;
  21.         FileOutputStream fileOutputStream = null;
  22.         byte[] bc = new byte[1024];
  23.         int readLen = 0;
  24.         try {
  25.             fileInputStream = new FileInputStream(filePath);
  26.             fileOutputStream = new FileOutputStream(newFilePath);
  27.             while ((readLen = fileInputStream.read(bc)) != -1) {
  28.                 fileOutputStream.write(bc,0,readLen);
  29.             }
  30.             System.out.println("拷贝成功~");
  31.         } catch (IOException e) {
  32.             e.printStackTrace();
  33.         } finally {
  34.             try {
  35.                 if (fileInputStream != null) {
  36.                     fileInputStream.close();
  37.                 }
  38.                 if (fileOutputStream != null) {
  39.                     fileOutputStream.close();
  40.                 }
  41.             } catch (IOException e) {
  42.                 e.printStackTrace();
  43.             }
  44.         }
  45.     }
  46. }

4.6 FileReader 介绍

FileReader：文件字符输入流 用于读取磁盘上的文件到内存，按字符读取
image.png
FileReader 相关方法：

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

FileReader 相关API：

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

应用案例：使用 FileReader 从 story.txt 读取内容，并显示

  1. package com.hspedu.reader_;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  */
  11. public class FileReader_ {
  12.     public static void main(String[] args) {
  13.         String filePath = "e:\\story.txt";
  14.         FileReader fileReader = null;
  15.         int Date = 0;
  16.         char[] chars = new char[10];
  17.         int readLen = 0;
  18.         try {
  19.             fileReader = new FileReader(filePath);
  21.             //单个字符读取
  22. //            while ((Date = fileReader.read()) != -1) {
  23. //                System.out.print((char) Date);
  24. //            }
  26.             //多个字符读取
  27.             while ((readLen = fileReader.read(chars)) != -1) {
  28.                 System.out.print(new String(chars,0,readLen));
  29.             }
  31.         } catch (IOException e) {
  32.             e.printStackTrace();
  33.         } finally {
  34.             try {
  35.                 if (fileReader != null) {
  36.                     fileReader.close();
  37.                 }
  38.             } catch (IOException e) {
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.     }
  43. }

4.7 FileWriter 介绍

FileWriter：文件字符输出流 用于将程序（内存）中的数据写入到磁盘上的文件中，按字符写入
image.png
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)：写入字符串的指定部分

FileWriter 相关API：
String类： toCharArray：将String转换成char[]

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

应用案例：使用 FileWriter 将”风雨过后，定见彩虹”写入到 note.txt 文件中，注意细节。

  1. package com.hspedu.writer_;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  6. /**
  7.  * @author HarborGao
  8.  * @version 1.0
  9.  */
  10. public class FileWriter_ {
  11.     public static void main(String[] args) {
  12.         String filePath = "e:\\note.txt";
  13.         FileWriter fileWriter = null;
  14.         String content = "风雨过后，定见彩虹";
  16.         try {
  17.             //fileWriter = new FileWriter(filePath);
  18.             fileWriter = new FileWriter(filePath,true);
  19. //            write(int)：写入单个字符
  20.             fileWriter.write('H');
  21. //            write(char[])：写入指定字符数组
  22.             fileWriter.write(content.toCharArray());
  23. //            write(char[], off, len)：写入指定数组的指定部分
  24.             fileWriter.write(content.toCharArray(),2,5);
  25. //            write(String)：写入整个字符串
  26.             fileWriter.write(content);
  27. //            write(string, off, len)：写入字符串的指定部分
  28.             fileWriter.write(content,2,5);
  30.         } catch (IOException e) {
  31.             e.printStackTrace();
  32.         } finally {
  33.             try {
  34.                 if (fileWriter != null) {
  35.                     //fileWriter.flush();
  37.                     //.close() 关闭文件流，等价于 flush + 关闭
  38.                     fileWriter.close();
  39.                 }
  40.             } catch (IOException e) {
  41.                 e.printStackTrace();
  42.             }
  43.         }
  44.     }
  45. }

五、节点流和处理流

5.1 基本介绍

  1. 节点流可以从一个特定的数据源读取数据，如 FileReader、FileWriter

IO 流 - 图6

  1. 处理流（也叫包装流）是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活，如 BufferedReader、BufferWriter

IO 流 - 图7

5.2 节点流和处理流一览图

image.png

5.3 节点流和处理流的区别和联系

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

模拟修饰器设计模式

  1. package com.hspedu;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  * 模拟Reader
  7.  */
  8. public abstract class Reader_ {
  9.     public void readFile() {}
  10.     public void readString() {}
  11. }
  1. package com.hspedu;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  * 模拟Reader的子类 FileReader  节点流
  7.  */
  8. public class FileReader_ extends Reader_{
  9.     public void readFile() {
  10.         System.out.println("对文件进行读取...");
  11.     }
  12. }
  1. package com.hspedu;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  * 模拟Reader的子类 StringReader  节点流
  7.  */
  8. public class StringReader_ extends Reader_{
  9.     public void readString() {
  10.         System.out.println("读取字符串...");
  11.     }
  12. }
  1. package com.hspedu;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  * 模拟 BufferedReader 处理流（包装流）  修饰器设计模式
  7.  */
  8. public class BufferedReader_ extends Reader_{
  9.     private Reader_ reader_;  //属性，Reader_类
  11.     public BufferedReader_(Reader_ reader_) {
  12.         this.reader_ = reader_;
  13.     }
  15.     public void readFile() {  //读取一次
  16.         reader_.readFile();
  17.     }
  19.     //让方法更加灵活: 多次读取文件，或者加缓冲 char[]...
  20.     public void readFiles(int num) {
  21.         for (int i = 0; i < num; i++) {
  22.             reader_.readFile();
  23.         }
  24.     }
  25.     //扩展: 批量处理字符串数据
  26.     public void readStrings(int num) {
  27.         for (int i = 0; i < num; i++) {
  28.             reader_.readString();
  29.         }
  30.     }
  31. }
  1. package com.hspedu;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class Test_ {
  8.     public static void main(String[] args) {
  9.         BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
  10.         bufferedReader_.readFiles(10);
  12.         BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
  13.         bufferedReader_1.readStrings(5);
  14.     }
  15. }

5.4 处理流的功能主要体现

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

5.5 处理流 - BufferedReader 和 BufferedWriter

  1. BufferedReader 和 BufferedWriter 数据字符流，是按照字符来读取和写入数据的
    注意：处理字节流文件（图片、音频等二进制文件）可能会造成数据损失
  2. 关闭时，只需要关闭外层流(处理流)即可，内层的节点流或者处理流会随着外层的关闭而关闭

应用案例1：使用BufferredReader 读取文本文件，并显示在控制台

  1. package com.hspedu.reader_;
  3. import java.io.BufferedReader;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileReader;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  * 演示 BufferedReader 使用
  11.  */
  12. public class BufferedReader_ {
  13.     public static void main(String[] args) throws Exception {
  14.         String filePath = "e:\\story.txt";
  16.         //创建BufferedReader
  17.         BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
  18.         //读取
  19.         String line;
  20.         //说明:
  21.         //1. readLine() 方法是按行读取,效率高
  22.         //2. 当返回 null 时，表示文件读取完毕
  23.         while ((line = bufferedReader.readLine()) != null) {
  24.             System.out.println(line);
  25.         }
  27.         //关闭流,这里注意,只需要关闭 bufferedReader,因为底层会自动关闭节点流FileReader
  28.         bufferedReader.close();
  29.     }
  30. }

应用案例2：使用 BufferedWriter 将”hello，世界！”，写入到文件中

  1. package com.hspedu.reader_;
  3. import java.io.BufferedWriter;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  * 演示 BufferedWriter 使用
  11.  */
  12. public class BufferedWriter_ {
  13.     public static void main(String[] args) throws IOException {
  14.         String filePath = "e:\\ok.txt";
  15.         //创建 BufferedWriter 对象
  16.         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
  17.         bufferedWriter.write("hello,世界！");
  18.         bufferedWriter.newLine();//插入一个和系统相关的换行
  19.         bufferedWriter.write("hello2,世界！");
  20.         bufferedWriter.newLine();
  21.         bufferedWriter.write("hello3,世界！");
  22.         bufferedWriter.newLine();
  24.         //说明: 关闭外层流 bufferedReader 即可,因为底层会自动关闭节点流FileWriter
  25.         bufferedWriter.close();
  26.     }
  27. }

应用案例3：使用 BufferedReader 和 BufferedWriter 完成文本文件拷贝，注意文件编码

  1. package com.hspedu.writer_;
  3. import java.io.*;
  5. /**
  6.  * @author HarborGao
  7.  * @version 1.0
  8.  */
  9. public class BufferedCopy_ {
  10.     public static void main(String[] args) {
  12.         String srcFilePath = "e:\\story.txt";
  13.         String destFilePath = "e:\\demo\\storyCopy.txt";
  14.         BufferedReader br = null;
  15.         BufferedWriter bw = null;
  16.         String line;
  17.         try {
  18.             br = new BufferedReader(new FileReader(srcFilePath));
  19.             bw = new BufferedWriter(new FileWriter(destFilePath));
  21.             //读取并写入
  22.             //说明: readLine() 是读取一行内容，但是没有带换行
  23.             while ((line = br.readLine()) != null) {
  24.                 //每读取一行，就写入
  25.                 bw.write(line);
  26.                 bw.newLine();
  27.             }
  28.             System.out.println("拷贝完毕！");
  30.         } catch (IOException e) {
  31.             e.printStackTrace();
  32.         } finally {
  33.             try {
  34.                 if (br != null) {
  35.                     br.close();
  36.                 }
  37.                 if (bw != null) {
  38.                     bw.close();
  39.                 }
  40.             } catch (IOException e) {
  41.                 e.printStackTrace();
  42.             }
  43.         }
  44.     }
  45. }

5.6 处理流 - BufferedInputStream 和 BufferedOutputStream

  1. BufferedInputStream 是字节流，在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。
  2. BufferedInputStream 是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统。

image.png
image.png

应用案例：编程完成图片/音乐 的拷贝(要求使用 Buffered…流)

  1. package com.hspedu.outputstream_;
  3. import java.io.*;
  5. /**
  6.  * @author HarborGao
  7.  * @version 1.0
  8.  * 演示 BufferedInputStream 和 BufferedOutputStream 使用
  9.  * 可以实现 二进制文件的拷贝
  10.  * 思考: 字节流可以操作二进制文件，可以操作文本文件吗？   可以。文本文件底层也是二进制文件，编码不同而已，读取时注意
  11.  */
  12. public class BufferedIOStreamCopy_ {
  13.     public static void main(String[] args) {
  14.         String srcFilePath = "e:\\546.jpg";
  15.         String destFilePath = "e:\\123.jpg";
  16.         BufferedInputStream bis = null;
  17.         BufferedOutputStream bos = null;
  19.         try {
  20.             bis = new BufferedInputStream(new FileInputStream(srcFilePath));
  21.             bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
  22.             //循环的读取文件并写入到新文件
  23.             byte[] buff = new byte[1024];
  24.             int readLen;
  25.             while ((readLen = bis.read(buff)) != -1) {
  26.                 bos.write(buff,0,readLen);
  27.             }
  28.             System.out.println("文件拷贝成功");
  29.         } catch (IOException e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.             try {
  33.                 if (bis != null) {
  34.                     bis.close();
  35.                 }
  36.                 if (bos != null) {
  37.                     bos.close();
  38.                 }
  39.             } catch (IOException e) {
  40.                 e.printStackTrace();
  41.             }
  42.         }
  43.     }
  44. }

5.7 对象流 - ObjectInputStream 和 ObjectOutputStream

看一个需求：

  1. 将 int num = 100 这个 int 数据保存到文件中，注意不是 100 数字，而是 int 100，并且，能够从文件中直接恢复 int 100
  2. 将 Dog dog = new Dog(“小黄”, 3)这个dog对象 保存到文件中，并且能够从文件恢复
  3. 上面的要求，就是 能够将 基本数据类型 或者 对象 进行序列化 和 反序列化操作

序列化和反序列化：

  1. 序列化就是在保存数据时，保存数据的值和数据类型
  2. 反序列化就是在恢复数据时，恢复数据的值和数据类型
  3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
    1. Serializable //这是一个标记接口，没有方法，一般情况下推荐使用
    2. Externalizable //需实现其方法

ObjectInputStream 和 ObjectOutputStream 基本介绍
image.png image.png
功能：提供了对基本类型或对象类型的序列化和反序列化的方法
ObjectOutputStream： 提供序列化功能
ObjectInputStream： 提供反序列化功能
image.png image.png

应用案例1：使用 ObjectOutputStream 序列化 基本数据类型和一个 Dog对象(name,age)，并保存到
data.dat 文件中

  1. package com.hspedu.outputstream_;
  3. import java.io.FileOutputStream;
  4. import java.io.ObjectOutputStream;
  6. /**
  7.  * @author HarborGao
  8.  * @version 1.0
  9.  * 演示 ObjectOutputStream 使用,完成数据的序列化
  10.  */
  11. public class ObjectOutputStream_ {
  12.     public static void main(String[] args) throws Exception{
  13.         //序列化后，保存的文件格式，不是存文本，而是指定的数据保存格式 .dat
  14.         String filePath = "e:\\data.dat";
  15.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
  17.         //序列化数据到 e:\data.dat
  18.          oos.writeInt(100);  //自动装箱
  19.          oos.writeBoolean(true);
  20.          oos.writeChar('a');
  21.          oos.writeDouble(9.5);
  22.          oos.writeUTF("韩顺平教育");
  23.          //保存一个 Dog对象
  24.         Dog dog = new Dog("大黄", 5);
  25.         oos.writeObject(dog);
  27.         oos.close();
  28.         System.out.println("数据保存完毕(序列化形式)");
  30.     }
  31. }
  1. package com.hspedu.outputstream_;
  3. import java.io.Serializable;
  5. /**
  6.  * @author HarborGao
  7.  * @version 1.0
  8.  */
  10. //如果想让类是可序列化的，必须实现 Serializable 或 Externalizable 接口
  11. public class Dog implements Serializable {
  12.     private String name;
  13.     private int age;
  15.     public Dog(String name, int age) {
  16.         this.name = name;
  17.         this.age = age;
  18.     }
  20.     @Override
  21.     public String toString() {
  22.         return "Dog{" +
  23.                 "name='" + name + '\'' +
  24.                 ", age=" + age +
  25.                 '}';
  26.     }
  28.     public String getName() {
  29.         return name;
  30.     }
  32.     public void setName(String name) {
  33.         this.name = name;
  34.     }
  36.     public int getAge() {
  37.         return age;
  38.     }
  40.     public void setAge(int age) {
  41.         this.age = age;
  42.     }
  43. }

应用案例2：使用 ObjectInputStream 读取 data.dat 并反序列化恢复数据

  1. package com.hspedu.inputstream_;
  3. import com.hspedu.outputstream_.Dog;  //引入Dog类
  5. import java.io.FileInputStream;
  6. import java.io.ObjectInputStream;
  8. /**
  9.  * @author HarborGao
  10.  * @version 1.0
  11.  */
  12. public class ObjectInputStream_ {
  13.     public static void main(String[] args) throws Exception {
  14.         //指定反序列化的文件
  15.         String filePath = "e:\\data.dat";
  17.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
  19.         //读取
  20.         //解读：
  21.         //1. 读取(反序列化)的顺序需要和保存数据(序列化)的顺序一致
  22.         //2. 否则会出现异常
  24.         System.out.println(ois.readInt());
  25.         System.out.println(ois.readBoolean());
  26.         System.out.println(ois.readChar());
  27.         System.out.println(ois.readDouble());
  28.         System.out.println(ois.readUTF());
  29.         Object dog = ois.readObject();
  30.         System.out.println("运行类型=" + dog.getClass());
  31.         System.out.println("dog信息=" + dog);
  33.         //细节说明:
  34.         //1. 如果我们希望调用 Dog方法，需要向下转型
  35.         //2. 并且需要将 Dog类的定义，拷贝到可以引用的位置
  36.         Dog dog2 = (Dog)dog;
  37.         System.out.println(dog2.getName());
  40.         //关闭流,关闭外层即可
  41.         ois.close();
  43.     }
  44. }

5.8 对象处理流的注意事项和细节说明

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

5.9 标准输入输出流


 名称 编译类型 默认设备 运行类型
System.in 标准输入 InputStream 键盘 BufferedInputStream
System.out 标准输出 PrintStream 显示器 PrintStream

5.10 转换流 - InputStreamReader 和 OutputStreamWriter

  1. package com.hspedu.transformation_;
  3. import java.io.BufferedReader;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  */
  11. public class CodeQuestion_ {
  12.     public static void main(String[] args) throws IOException {
  13.         //读取 e:\\a.txt 文件到程序
  14.         //思路：
  15.         //1. 创建字符输入流 BufferedReader [处理流]
  16.         //2. 使用 BufferedReader 对象读取 a.txt
  17.         //3. 默认情况下，读取文件是按照 utf-8 编码
  18.         String filePath = "e:\\a.txt";  //假设源文件是 gbk编码的，含有中文
  19.         BufferedReader br = new BufferedReader(new FileReader(filePath));
  20.         String s = br.readLine();
  21.         System.out.println("读取的内容:" + s);  //会发现出现乱码
  23.         br.close();
  24.     }
  25. }

InputStreamReader 和 OutputStreamWriter 介绍

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

应用案例1：编程将 字节流 FileInputStream 包装成(转换成)字符流 InputStreamReader 对文件进行读取
按照 utf-8/gbk 格式，进而再包装成 BufferedReader

  1. package com.hspedu.transformation_;
  3. import java.io.BufferedReader;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  8. /**
  9.  * @author HarborGao
  10.  * @version 1.0
  11.  * 演示使用 InputStreamReader 转换流解决中文乱码问题
  12.  * 将字节流 FileInputStream 转换成 字符流 InputStreamReader，指定编码 utf-8 / gbk
  13.  */
  14. public class InputStreamReader_ {
  15.     public static void main(String[] args) throws IOException {
  16.         String filePath = "e:\\a.txt";
  17.         //解读：
  18.         //1. 将FileInputStream 转成 InputStreamReader
  19.         //2. 制定了编码 "gbk"
  20.         InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
  21.         //3. 把 InputStreamReader  传入 BufferedReader
  22.         BufferedReader br = new BufferedReader(isr);
  24.         //将 2 和 3 合并成一步
  25.         BufferedReader br2 = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
  27.         //4. 读取
  28.         System.out.println( br.readLine());
  29.         //5. 关闭外层
  30.         br.close();
  31.     }
  32. }

应用案例2：编程将 字节流 FileOutputStream 包装成(转换成)字符流 OutputStreamWriter 对文件进行写入
按照 utf-8/gbk 格式

  1. package com.hspedu.transformation_;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.OutputStreamWriter;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  * 演示 OutputStreamWriter 使用
  11.  * 将 字节流FileOutputStream 转换成 字符流OutputStreamWriter
  12.  * 指定处理的编码 gnk/utf-8/utf8
  13.  */
  14. public class OutputStreamWriter_ {
  15.     public static void main(String[] args) throws IOException {
  16.         String filePath = "E:\\b.txt";
  17.         String charSet = "utf8";
  18.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
  19.         osw.write("hi,世界");
  21.         osw.close();
  22.         System.out.println("保存成功");
  23.     }
  24. }

六、打印流 - PrintStream 和 PrintWriter

6.1 PrintStream 字节打印输出流

  1. package com.hspedu.printstream_;
  3. import java.io.IOException;
  4. import java.io.PrintStream;
  6. /**
  7.  * @author HarborGao
  8.  * @version 1.0
  9.  * 演示 PrintStream 字节打印输出流 使用
  10.  */
  11. public class PrintStream_ {
  12.     public static void main(String[] args) throws IOException {
  13.         PrintStream out = System.out;
  14.         //在默认情况下, PrintStream 打印的位置是标准输出 即显示器
  15.         /*
  16.             public void print(String s) {
  17.                 if (s == null) {
  18.                     s = "null";
  19.                 }
  20.                 write(s);
  21.             }
  22.          */
  23.         out.println("hello,java");
  24.         //因为 print 底层使用的是 write()，所以我们也可以直接调用其完成打印输出
  25.         out.write("java,你好".getBytes());
  27.         out.close();
  29.         //我们可以修改打印流输出的位置/设备
  30.         System.setOut(new PrintStream("e:\\f1.txt"));
  31.         System.out.println("hello,韩顺平教育~");
  32.     }
  33. }

6.2 PrintWriter 字符打印输出流

  1. package com.hspedu.printwriter_;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  5. import java.io.PrintWriter;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  */
  11. public class PrintWriter_ {
  12.     public static void main(String[] args) throws IOException {
  13.         //PrintWriter printWriter = new PrintWriter(System.out);
  14.         PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
  15.         printWriter.print("hi,北京~");
  16.         printWriter.close();
  17.     }
  18. }

七、Properties 类

7.1 看一个需求

有如下一个配置文件 mysql.properties
ip=192.168.0.13
user=root
pwd=12345
请 编程读取 ip、user、pwd 的值

传统方法：

  1. package com.hspedu.properties_;
  3. import java.io.BufferedReader;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  7. /**
  8.  * @author HarborGao
  9.  * @version 1.0
  10.  */
  11. public class Properties01 {
  12.     public static void main(String[] args) throws IOException {
  13.         BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties"));
  14.         String s;
  15.         while ((s = br.readLine()) != null) {
  16.             String[] split = s.split("=");
  17.             System.out.println(split[0] + "的值是 " + split[1]);
  18.         }
  19.         br.close();
  20.     }
  21. }

问题：

  1. 读取数据麻烦，需要自己定义读取方法
  2. 数据修改比较麻烦

7.2 基本介绍

  1. Properties 类 是专门用于读写配置文件的集合类 ，其父类是Hashtable
    配置文件的格式：
    键=值
    键=值

  2. 注意：键值对不需要有空格，值不需要用引号包起来，默认类型是String

7.3 Properties 类的常见方法

方法 功能
load 加载配置文件的键值对到 Properties 对象
list 将数据显示到指定设备
getProperty(key) 根据键获取值
setProperty(key, value) 设置键值对到 Properties 对象
store 将 Properties 中的键值对储存到配置文件。在IDEA中，保存信息到配置文件，如果含有中文，会储存为 Unicode码

7.4 应用案例

  1. 使用 Properties 类完成对 mysql.properties 的读取
  2. 使用 Properties 类添加 key-value 到新文件 mysql2.properties 中
  3. 使用 Properties 类完成对 mysql.properties 的读取，并修改某个 key-value ```java package com.hspedu.properties_;

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

/**

  • @author HarborGao
  • @version 1.0 */ public class Properties02 { public static void main(String[] args) throws IOException {
    1.  //1. 使用 Properties 类完成对 mysql.properties 的读取
    2.  Properties properties = new Properties();
    3.  //加载指定配置文件
    4.  properties.load(new FileReader("src\\mysql.properties"));
    5.  //把key-value 显示到控制台
    6.  properties.list(System.out);
    7.  //根据 key 获取对应的 value
    8.  String ip = properties.getProperty("ip");
    9.  System.out.println("ip是 " + ip);
    } } java package com.hspedu.properties_;

import java.io.FileOutputStream; import java.io.IOException; import java.util.Properties;

/**

  • @author HarborGao

  • @version 1.0 */ public class Properties03 { public static void main(String[] args) throws IOException {

    1.  //使用 Properties 类添加 key-value 到新文件 mysql2.properties 中
    2.  Properties properties = new Properties();
    3.  //创建
    4.  properties.setProperty("ip","192.168.100.100");
    5.  properties.setProperty("user","汤姆");
    6.  properties.setProperty("pwd","666666");
    7.  properties.setProperty("charset","utf8");
    9.  //修改 k-v
    10.  properties.setProperty("charset","gbk");
    12.  //将 k-v 存储到文件中
    13.  properties.store(new FileOutputStream("src\\mysql2.properties"),null);
    14.  System.out.println("保存配置文件成功");

    } } ```

八、本章作业

  1. 编程题
    1. 在判断e盘下是否有文件夹mytemp，如果没有就创建mytemp
    2. 在e:\mytemp目录下，创建文件hello.txt
    3. 如果hello.txt已经存在，提示该文件已经存在，就不要再重复创建了
    4. 并且在hello.txt文件中，写入hello,world~ ```java package com.hspedu.homework.homework01;

import java.io.File; import java.io.FileOutputStream; import java.io.IOException;

/**

  • @author HarborGao

  • @version 1.0 */ public class Homework01 { public static void main(String[] args) throws IOException {

    1.  String filePath = "e:\\mytemp";
    2.  File file = new File(filePath);
    3.  if (file.exists()) {
    4.      System.out.println("目录已经存在");
    5.  } else {
    6.      if (file.mkdir()) {
    7.          System.out.println("目录创建成功");
    8.      } else {
    9.          System.out.println("目录创建失败");
    10.      }
    11.  }
    13.  File file1 = new File(file, "hello.txt");
    14.  if (file1.exists()) {
    15.      System.out.println("该文件已存在");
    16.  } else {
    17.      if (file1.createNewFile()) {
    18.          System.out.println("文件创建成功");
    19.      } else {
    20.          System.out.println("文件创建失败");
    21.      }
    22.  }
    24.  FileOutputStream fos = new FileOutputStream(file1);
    25.  fos.write("hello,world~".getBytes());
    27.  fos.close();

    } } ```

  1. 编程题

要求:使用BufferedReader读取一 个文本文件，为每行加上行号，再连同内容一并输出到屏幕上。

//如果把文件的编码改成了gbk，出现中文乱码，大家思考如何解决
//1.默认是按照utf-8处理开始没有乱码
//2.提示:使用我们的转换流，将FileInputStream -> InputStreamReader[可以指定编码] -> BufferedReader ..

  1. package com.hspedu.homework_.homework02_;
  3. import java.io.*;
  5. /**
  6.  * @author HarborGao
  7.  * @version 1.0
  8.  */
  9. public class Homework02 {
  10.     public static void main(String[] args) throws IOException {
  11.         BufferedReader reader = new BufferedReader(new InputStreamReader(
  12.                 new FileInputStream("e:\\code.txt"), "gbk"));
  13.         //BufferedReader reader = new BufferedReader(new FileReader("e:\\code.txt"));
  14.         int i = 0;
  15.         String s;
  16.         while ((s = reader.readLine()) != null) {
  17.             System.out.println(++i + " " + s);
  18.         }
  20.         reader.close();
  21.     }
  22. }
  1. 编程题
    1. 要编写一个dog.properties

name=tom
age=5
color=red

  1. 编写Dog类(name,age,color)创建一个dog对象，读取dog.properties 用相应的内容完成属性初始化，并输出
  2. 将创建的Dog对象,序列化到文件dog.dat文件 ```java package com.hspedu.homework.homework03;

import java.io.*; import java.util.Properties;

/**

  • @author HarborGao

  • @version 1.0 */ public class Homework03 { public static void main(String[] args) throws IOException {

    1.  //编写一个dog.properties
    2.  String filePath = "src\\dog.properties";
    3.  Properties properties = new Properties();
    4.  properties.setProperty("name","tom");
    5.  properties.setProperty("age","5");
    6.  properties.setProperty("color","red");
    7.  properties.store(new FileOutputStream(filePath),"Class Dog");
    9.  //编写Dog类(name,age,color)创建一个dog对象，读取dog.properties 用相应的内容完成属性初始化，并输出
    10.  Properties properties1 = new Properties();
    11.  properties1.load(new FileInputStream(filePath));
    12.  String age = properties1.getProperty("age");
    13.  Dog dog = new Dog(properties1.getProperty("name"),Integer.parseInt(age),properties1.getProperty("color"));
    14.  System.out.println(dog);
    16.  //将创建的Dog对象,序列化到文件dog.dat文件
    17.  ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("e:\\dog.dat"));
    18.  objectOutputStream.writeObject(dog);
    20.  objectOutputStream.close();

    } }

  1. ```java
  2. package com.hspedu.homework_.homework03_;
  4. import java.io.Serializable;
  6. /**
  7.  * @author HarborGao
  8.  * @version 1.0
  9.  */
  10. public class Dog implements Serializable {
  11.     private String name;
  12.     private int age;
  13.     private String color;
  15.     public Dog(String name, int age, String color) {
  16.         this.name = name;
  17.         this.age = age;
  18.         this.color = color;
  19.     }
  21.     public String getName() {return name;} public void setName(String name) {this.name = name;}
  22.     public int getAge() {return age;} public void setAge(int age) {this.age = age;}
  23.     public String getColor() {return color;} public void setColor(String color) {this.color = color;}
  25.     @Override
  26.     public String toString() {
  27.         return "Dog{" +
  28.                 "name='" + name + '\'' +
  29.                 ", age=" + age +
  30.                 ", color='" + color + '\'' +
  31.                 '}';
  32.     }
  33. }

学习参考（致谢）：

  1. B站 @程序员鱼皮 Java学习一条龙
  2. B站 @韩顺平 零基础30天学会Java