一、File类的使用

1. 基本介绍

1）File类的一个对象，代表一个文件或一个文件目录
2）File类声明在java.io包下
3）File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
4）后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的”终点”

2. 创建File类的实例

1）File(String filePath)
2）File(String parentPath,String childPath)
以parent为父路径，child为子路径创建File对象
3）File(File parentFile,String childPath)
根据一个父File对象和子文件路径创建File对象
相对路径：相较于某个路径下，指明的路径
绝对路径：包含盘符在内的文件或文件目录的路径
注：File不会判断文件或目录是否存在，只是加载至内存，输出对应的文件路径

  1. // 构造器1
  2. File file1 = new File("hello.txt");   // 相对于当前module
  3. File file2 =  new File("D:\\workspace_idea1\\JavaSenior\\day08\\he.txt");
  5. System.out.println(file1);    // hello.txt
  6. System.out.println(file2);    // D:\workspace_idea1\JavaSenior\day08\he.txt
  8. // 构造器2：
  9. File file3 = new File("D:\\workspace_idea1","JavaSenior");
  10. System.out.println(file3);    //D:\workspace_idea1\JavaSenior
  12. // 构造器3：
  13. File file4 = new File(file3,"hi.txt");    
  14. System.out.println(file4);    // D:\workspace_idea1\JavaSenior\hi.txt

3. 常用方法一：获取功能

1）public String getAbsolutePath()：获取绝对路径
2）public String getPath() ：获取路径
3）public String getName() ：获取名称
4）public String getParent()：获取上层文件目录路径。若无，返回null（相对路径返回null）
5）public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
6）public long lastModified() ：获取最后一次的修改时间，毫秒值

  1. File file1 = new File("hello.txt");
  2. File file2 = new File("E:\\Java\\JavaSenior\\day08\\hi.txt");
  4. System.out.println(file1.getAbsolutePath());    // E:\Java\JavaSenior\day08\hello.txt
  5. System.out.println(file1.getPath());            // hello.txt
  6. System.out.println(file1.getName());            // hello.txt
  7. System.out.println(file1.getParent());          // null
  8. System.out.println(file1.length());             // 10
  9. System.out.println(new Date(file1.lastModified())); // 2019-02-23
  11. System.out.println();
  13. System.out.println(file2.getAbsolutePath());// E:\Java\JavaSenior\day08\hi.txt
  14. System.out.println(file2.getPath());        // E:\Java\JavaSenior\day08\hi.txt
  15. System.out.println(file2.getName());        // hi.txt
  16. System.out.println(file2.getParent());      // E:\Java\JavaSenior\day08
  17. System.out.println(file2.length());         // 0
  18. System.out.println(file2.lastModified());   // 1550911504880

如下的两个方法适用于文件目录：
7）public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
8）public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组

  1. File file = new File("E:\\test");
  2. String[] list = file.list();
  3. for(String s : list){
  4.     System.out.println(s);     // test1    test2.txt
  5. }
  7. File[] files = file.listFiles();
  8. for(File f : files){
  9.     System.out.println(f);      // E:\test\test1    E:\test\test2.txt
  10. }

9）public boolean renameTo(File dest)：把文件重命名为指定的文件路径
比如：file1.renameTo(file2)为例。要想保证返回true，需要file1在硬盘中是存在的，且file2不能在硬盘中存在

  1. File file1 = new File("hello.txt");
  2. File file2 = new File("D:\\io\\hi.txt");
  4. boolean renameTo = file2.renameTo(file1);
  5. System.out.println(renameTo);

4. 常用方法二：判断功能

public boolean isDirectory()：判断是否是文件目录
public boolean isFile() ：判断是否是文件
public boolean exists() ：判断是否存在
public boolean canRead() ：判断是否可读
public boolean canWrite() ：判断是否可写
public boolean isHidden() ：判断是否隐藏

  1. File file1 = new File("hello.txt");
  2. file1 = new File("hello1.txt");
  4. System.out.println(file1.isDirectory());
  5. System.out.println(file1.isFile());
  6. System.out.println(file1.exists());
  7. System.out.println(file1.canRead());
  8. System.out.println(file1.canWrite());
  9. System.out.println(file1.isHidden());
  11. System.out.println();
  13. File file2 = new File("d:\\io");
  14. file2 = new File("d:\\io1");
  15. System.out.println(file2.isDirectory());
  16. System.out.println(file2.isFile());
  17. System.out.println(file2.exists());
  18. System.out.println(file2.canRead());
  19. System.out.println(file2.canWrite());
  20. System.out.println(file2.isHidden());

5. 常用方法二：创建与删除

5.1 创建文件

public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false

  1. File file1 = new File("hi.txt");
  2. if(!file1.exists()){
  3.     // 文件的创建
  4.     file1.createNewFile();
  5.     System.out.println("创建成功");
  6. }else{    // 文件存在
  7.     file1.delete();
  8.     System.out.println("删除成功");
  9. }

5.2 创建文件目录

public boolean mkdir()：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建
public boolean mkdirs()：创建文件目录。如果此文件目录存在，就不创建了。如果上层文件目录不存在，一并创建
注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目路径下。

  1. // 文件目录的创建
  2. File file1 = new File("d:\\io\\io1\\io3");
  3. boolean mkdir = file1.mkdir();
  4. if(mkdir){
  5.     System.out.println("创建成功1");
  6. }
  8. File file2 = new File("d:\\io\\io1\\io4");
  9. boolean mkdir1 = file2.mkdirs();
  10. if(mkdir1){
  11.     System.out.println("创建成功2");
  12. }

5.3 删除磁盘中的文件或文件目录

public boolean delete()：删除文件或者文件夹
删除注意事项：Java中的删除不走回收站

  1. // 要想删除成功，io4文件目录下不能有子目录或文件
  2. File file3 = new File("D:\\io\\io1\\io4");
  3. file3 = new File("D:\\io\\io1");
  4. System.out.println(file3.delete());   //false

6. File类的使用

  1. File dir1 = new File("D:/IOTest/dir1");
  2. if (!dir1.exists()) { // 如果D:/IOTest/dir1不存在，就创建为目录
  3.     dir1.mkdir();
  4. }
  5. // 创建以dir1为父目录,名为"dir2"的File对象
  6. File dir2 = new File(dir1, "dir2");
  7. if (!dir2.exists()) { // 如果还不存在，就创建为目录
  8.     dir2.mkdirs();
  9. }
  11. File dir4 = new File(dir1, "dir3/dir4");
  12. if (!dir4.exists()) {
  13.     dir4.mkdirs();
  14. }
  16. // 创建以dir2为父目录,名为"test.txt"的File对象
  17. File file = new File(dir2, "test.txt");
  18. if (!file.exists()) { //如果还不存在，就创建为文件
  19.     file.createNewFile();
  20. }

图片5.png

7. 练习题

  1. public class FileDemo {
  3.     @Test
  4.     public void test1() throws IOException {
  5.         File file = new File("D:\\io\\io1\\hello.txt");
  6.         // 创建一个与file同目录下的另外一个文件，文件名为：haha.txt
  7.         File destFile = new File(file.getParent(), "haha.txt");
  8.         boolean newFile = destFile.createNewFile();
  9.         if(newFile){
  10.             System.out.println("创建成功！");
  11.         }
  12.     }
  13. }
  1. /**
  2.  * 课后练习2：判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
  3.  */
  4. public class FindJPGFileTest {
  6.     @Test
  7.     public void test1(){
  8.         File srcFile = new File("d:\\code");
  10.         String[] fileNames = srcFile.list();
  11.         for(String fileName : fileNames){
  12.             if(fileName.endsWith(".jpg")){
  13.                 System.out.println(fileName);
  14.             }
  15.         }
  16.     }
  17.     @Test
  18.     public void test2(){
  19.         File srcFile = new File("d:\\code");
  21.         File[] listFiles = srcFile.listFiles();
  22.         for(File file : listFiles){
  23.             if(file.getName().endsWith(".jpg")){
  24.                 System.out.println(file.getAbsolutePath());
  25.             }
  26.         }
  27.     }
  28.     /*
  29.      * File类提供了两个文件过滤器方法
  30.      * public String[] list(FilenameFilter filter)
  31.      * public File[] listFiles(FileFilter filter)
  32.      */
  33.     @Test
  34.     public void test3(){
  35.         File srcFile = new File("d:\\code");
  37.         File[] subFiles = srcFile.listFiles(new FilenameFilter() {
  39.             @Override
  40.             public boolean accept(File dir, String name) {
  41.                 return name.endsWith(".jpg");
  42.             }
  43.         });
  45.         for(File file : subFiles){
  46.             System.out.println(file.getAbsolutePath());
  47.         }
  48.     }    
  49. }
  1. /**
  2.  * 课后练习3. 遍历指定目录所有文件名称，包括子文件目录中的文件
  3.        拓展1：并计算指定目录占用空间的大小
  4.        拓展2：删除指定文件目录及其下的所有文件
  5.  */
  6. public class ListFilesTest {
  8.     public static void main(String[] args) {
  9.         // 递归：文件目录
  10.         /** 打印出指定目录所有文件名称，包括子文件目录中的文件 */
  12.         // 1.创建目录对象
  13.         File dir = new File("E:\\teach\\01_javaSE\\_尚硅谷Java编程语言\\3_软件");
  15.         // 2.打印目录的子文件
  16.         printSubFile(dir);
  17.     }
  19.     public static void printSubFile(File dir) {
  20.         // 打印目录的子文件
  21.         File[] subfiles = dir.listFiles();
  23.         for (File f : subfiles) {
  24.             if (f.isDirectory()) {// 文件目录
  25.                 printSubFile(f);
  26.             } else {// 文件
  27.                 System.out.println(f.getAbsolutePath());
  28.             }
  29.         }
  30.     }
  32.     // 方式二：循环实现
  33.     // 列出file目录的下级内容，仅列出一级的话
  34.     // 使用File类的String[] list()比较简单
  35.     public void listSubFiles(File file) {
  36.         if (file.isDirectory()) {
  37.             String[] all = file.list();
  38.             for (String s : all) {
  39.                 System.out.println(s);
  40.             }
  41.         } else {
  42.             System.out.println(file + "是文件！");
  43.         }
  44.     }
  46.     // 列出file目录的下级，如果它的下级还是目录，接着列出下级的下级，依次类推
  47.     // 建议使用File类的File[] listFiles()
  48.     public void listAllSubFiles(File file) {
  49.         if (file.isFile()) {
  50.             System.out.println(file);
  51.         } else {
  52.             File[] all = file.listFiles();
  53.             // 如果all[i]是文件，直接打印
  54.             // 如果all[i]是目录，接着再获取它的下一级
  55.             for (File f : all) {
  56.                 listAllSubFiles(f);// 递归调用：自己调用自己就叫递归
  57.             }
  58.         }
  59.     }
  61.     // 拓展1：求指定目录所在空间的大小
  62.     // 求任意一个目录的总大小
  63.     public long getDirectorySize(File file) {
  64.         // file是文件，那么直接返回file.length()
  65.         // file是目录，把它的下一级的所有大小加起来就是它的总大小
  66.         long size = 0;
  67.         if (file.isFile()) {
  68.             size += file.length();
  69.         } else {
  70.             File[] all = file.listFiles();// 获取file的下一级
  71.             // 累加all[i]的大小
  72.             for (File f : all) {
  73.                 size += getDirectorySize(f);// f的大小;
  74.             }
  75.         }
  76.         return size;
  77.     }
  79.     // 拓展2：删除指定的目录
  80.     public void deleteDirectory(File file) {
  81.         // 如果file是文件，直接delete
  82.         // 如果file是目录，先把它的下一级干掉，然后删除自己
  83.         if (file.isDirectory()) {
  84.             File[] all = file.listFiles();
  85.             // 循环删除的是file的下一级
  86.             for (File f : all) {// f代表file的每一个下级
  87.                 deleteDirectory(f);
  88.             }
  89.         }
  90.         // 删除自己
  91.         file.delete();
  92.     }
  93. }

二、IO流原理及流的分类

1. Java IO原理

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

2. 流的分类

1）按操作数据单位不同分为：字节流(8 bit)（图片、视频等非文本），字符流(16 bit)（文本）
2）按数据流的流向不同分为：输入流，输出流
3）按流的角色的不同分为：节点流，处理流
节点流：直接从数据源或目的地读写数据
处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能
图片2.png

3. IO流体系

图片1.png
图片3.png

三、文件流的使用

文件流：属于节点流
FileInputStream
FileOutputStream
FileReader
FileWriter

1、FileReader、FileWriter访问文本文件

1.1 FileReader读取数据

  1. FileReader fr = null;
  2. try {
  3.     // 1.实例化File类的对象，指明要操作的文件
  4.     File file = new File("hello.txt");//相较于当前Module
  5.     // 2.提供具体的流
  6.     fr = new FileReader(file);
  8.     // 3.数据的读入
  9.     // read()：从输入流中读取数据的下一个字节。
  10.     // 返回0到255范围内的int字节值。如果达到文件末尾，返回-1
  11.     int data;
  12.     while((data = fr.read()) != -1){
  13.           System.out.print((char)data);
  14.     }
  15. } catch (IOException e) {
  16.     e.printStackTrace();
  17. } finally {
  18.     // 4.流的关闭操作
  19.     if(fr != null){
  20.          try {
  21.              fr.close();
  22.          } catch (IOException e) {
  23.               e.printStackTrace();
  24.          }
  25.      }
  26. }
  27. 说明点：
  28.     1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
  29.     2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
  30.     3. 读入的文件一定要存在，否则就会报FileNotFoundException。

对read()操作升级：使用read的重载方法

  1. FileReader fr = null;
  2. try {
  3.     // 1.File类的实例化
  4.     File file = new File("hello.txt");
  6.     // 2.FileReader流的实例化
  7.     fr = new FileReader(file);
  9.     // 3.读入的操作
  10.     // read(char[] cbuf):从此输入流中将最多b.length个字节的数据读入一个byte数组中。
  11.     // 如果达到文件末尾，返回-1
  12.     char[] cbuf = new char[5];
  13.     int len;
  14.     while((len = fr.read(cbuf)) != -1){
  15.         // 方式一：
  16.         // 错误的写法
  17. //      for(int i = 0;i < cbuf.length;i++){
  18. //           System.out.print(cbuf[i]);        //输出：helloworld123ld
  19. //      }
  20.         // 正确的写法
  21. //      for(int i = 0;i < len;i++){
  22. //          System.out.print(cbuf[i]);         //输出：helloworld123
  23. //      }
  24.         // 方式二：
  25.         // 错误的写法,对应着方式一的错误的写法
  26. //      String str = new String(cbuf);
  27. //      System.out.print(str);
  28.         // 正确的写法
  29.         String str = new String(cbuf,0,len);
  30.         System.out.print(str);
  31.     }
  32. } catch (IOException e) {
  33.     e.printStackTrace();
  34. } finally {
  35.     if(fr != null){
  36.         // 4.资源的关闭
  37.         try {
  38.             fr.close();
  39.         } catch (IOException e) {
  40.             e.printStackTrace();
  41.         }
  42.     }
  43. }

1.2 FileWriter写入数据

  1. FileWriter fw = null;
  2. try {
  3.     //1.提供File类的对象，指明写出到的文件
  4.     File file = new File("hello1.txt");
  6.     //2.提供FileWriter的对象，用于数据的写出
  7.     fw = new FileWriter(file,false);
  9.     //3.写出的操作
  10.     fw.write("I have a dream!\n");
  11.     fw.write("you need to have a dream!");
  12. } catch (IOException e) {
  13.     e.printStackTrace();
  14. } finally {
  15.     //4.流资源的关闭
  16.     if(fw != null){
  17.         try {
  18.             fw.close();
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23. }
  24. 说明：
  25. 1. 输出操作，对应的File可以不存在的。并不会报异常
  26. 2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
  27. 3.File对应的硬盘中的文件如果存在：
  28.   如果流使用的构造器是：FileWriter(file,false) / FileWriter(file)：对原有文件的覆盖
  29.   如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是在原有文件基础上追加内容

1.3 文本文件的复制

  1. FileReader fr = null;
  2. FileWriter fw = null;
  3. try {
  4.     // 1.创建File类的对象，指明读入和写出的文件
  5.     File srcFile = new File("hello.txt");
  6.     File destFile = new File("hello2.txt");
  8.     // 不能使用字符流来处理图片等字节数据
  9. //  File srcFile = new File("爱情与友情.jpg");
  10. //  File destFile = new File("爱情与友情1.jpg");
  12.     // 2.创建输入流和输出流的对象
  13.     fr = new FileReader(srcFile);
  14.     fw = new FileWriter(destFile);
  16.     // 3.数据的读入和写出操作
  17.     char[] cbuf = new char[5];
  18.     int len;        // 记录每次读入到cbuf数组中的字符的个数
  19.     while((len = fr.read(cbuf)) != -1){
  20.         // 每次写出len个字符
  21.         fw.write(cbuf,0,len);
  22.     }
  23. } catch (IOException e) {
  24.     e.printStackTrace();
  25. } finally {
  26.     // 4.关闭流资源
  27.     try {
  28.         if(fw != null)
  29.             fw.close();
  30.     } catch (IOException e) {
  31.         e.printStackTrace();
  32.     }
  33.     try {
  34.         if(fr != null)
  35.             fr.close();
  36.     } catch (IOException e) {
  37.         e.printStackTrace();
  38.     }
  39. }

2、FileInputStream、FileOutputStream访问非文本文件

  1. FileInputStream fis = null;
  2. FileOutputStream fos = null;
  3. try {
  4.     // 1. 造文件
  5.     File srcFile = new File("爱情与友情.jpg");
  6.     File destFile = new File("爱情与友情2.jpg");
  8.     // 2.造流
  9.     fis = new FileInputStream(srcFile);
  10.     fos = new FileOutputStream(destFile);
  12.     // 3.复制的过程
  13.     byte[] buffer = new byte[5];
  14.     int len;
  15.     while((len = fis.read(buffer)) != -1){
  16.        fos.write(buffer,0,len);
  17.     }
  18. } catch (IOException e) {
  19.     e.printStackTrace();
  20. } finally {
  21.    // 4.关闭资源
  22.    fos.close();
  23.    fis.close();
  24. }

结论：

  • 对于文本文件(.txt、.java、.c、.cpp)，使用字符流处理
  • 对于非文本文件(.jpg、.mp3、.mp4、.avi、.doc、.ppt、…)，使用字节流处理

  • 可以采用字节流处理文本文件单纯的复制操作。如果处理文本文件的读取操作，会出现乱码

    四、缓冲流的使用

    1）缓冲流：处理流的一种
    BufferedInputStream
    BufferedOutputStream
    BufferedReader
    BufferedWriter
    2）作用：提供流的读取、写入的速度
    提高读写速度的原因：内部提供了一个缓冲区
    3）处理流，就是“套接”在已有的流（节点流/处理流）的基础上。不能直接作用在文件上

    1、实现非文本文件的复制

    1. BufferedInputStream bis = null;
    2. BufferedOutputStream bos = null;
    3. try {
    4. // 1.造文件
    5. File srcFile = new File("爱情与友情.jpg");
    6. File destFile = new File("爱情与友情3.jpg");
    8. // 2.造流
    9. // 2.1 造节点流
    10. FileInputStream fis = new FileInputStream((srcFile));
    11. FileOutputStream fos = new FileOutputStream(destFile);
    12. // 2.2 造缓冲流
    13. bis = new BufferedInputStream(fis);
    14. bos = new BufferedOutputStream(fos);
    16. // 3.复制的细节：读取、写入
    17. byte[] buffer = new byte[10];       // 创建一个临时存放数据的数组
    18. int len;
    19. while((len = bis.read(buffer)) != -1){
    20.    bos.write(buffer,0,len);         // write的同时会自动刷新缓冲区
    21. //      bos.flush();  //刷新缓冲区
    22. }
    23. } catch (IOException e) {
    24. e.printStackTrace();
    25. } finally {
    26. // 4.资源关闭
    27. // 要求：先关闭外层的流，再关闭内层的流
    28. if(bos != null){
    29.    try {
    30.        bos.close();
    31.    } catch (IOException e) {
    32.        e.printStackTrace();
    33.    }
    34. }
    35. if(bis != null){
    36.    try {
    37.        bis.close();
    38.    } catch (IOException e) {
    39.        e.printStackTrace();
    40.    }
    41. }
    42. // 说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
    43. //  fos.close();
    44. //  fis.close();
    45. }

    2、实现文本文件的复制

    1. BufferedReader br = null;
    2. BufferedWriter bw = null;
    3. try {
    4. // 创建文件和相应的流
    5. br = new BufferedReader(new FileReader(new File("dbcp.txt")));
    6. bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
    8. // 读写操作
    9. // 方式一：使用char[]数组
    10. //  char[] cbuf = new char[1024];
    11. //  int len;
    12. //  while((len = br.read(cbuf)) != -1){
    13. //        bw.write(cbuf,0,len);
    14. //        //bw.flush();
    15. //  }
    17. // 方式二：使用String
    18. String data;
    19. while((data = br.readLine()) != null){
    20.    // 方法一：
    21.    // bw.write(data + "\n");     // data中不包含换行符
    22.    // 方法二：
    23.    bw.write(data);             // data中不包含换行符
    24.    bw.newLine();               // 提供换行的操作
    25. }
    26. } catch (IOException e) {
    27. e.printStackTrace();
    28. } finally {
    29. // 关闭资源
    30. bw.close();
    31. br.close();
    32. }

    3、练习题：图片的加解密

    1. FileInputStream fis = null;
    2. FileOutputStream fos = null;
    3. try {
    4. fis = new FileInputStream("爱情与友情.jpg");
    5. fos = new FileOutputStream("爱情与友情secret1.jpg");
    7. byte[] buffer = new byte[20];
    8. int len;
    9. while ((len = fis.read(buffer)) != -1) {
    10.    //字节数组进行修改
    11.    //错误的
    12.    //for(byte b : buffer){
    13.    //  b = (byte) (b ^ 5);
    14.    //}
    15.    //正确的
    16.    for (int i = 0; i < len; i++) {
    17.        buffer[i] = (byte) (buffer[i] ^ 5);
    18.    }
    19.    fos.write(buffer, 0, len);
    20. }
    21. } catch (IOException e) {
    22. e.printStackTrace();
    23. } finally {
    24. // 4.关流
    25. fos.close();
    26. fis.close();
    27. }
    1. FileInputStream fis = null;
    2. FileOutputStream fos = null;
    3. try {
    4. fis = new FileInputStream("爱情与友情secret.jpg");
    5. fos = new FileOutputStream("爱情与友情4.jpg");
    7. byte[] buffer = new byte[20];
    8. int len;
    9. while ((len = fis.read(buffer)) != -1) {
    10.    // 字节数组进行修改
    11.    // 错误的
    12.    // for(byte b : buffer){
    13.    //    b = (byte) (b ^ 5);
    14.    // }
    15.    // 正确的
    16.    for (int i = 0; i < len; i++) {
    17.        buffer[i] = (byte) (buffer[i] ^ 5);  // 两次异或操作，回到原数据
    18.    }
    19.    fos.write(buffer, 0, len);
    20. }
    21. } catch (IOException e) {
    22. e.printStackTrace();
    23. } finally {
    24. if (fos != null) {
    25.    try {
    26.        fos.close();
    27.    } catch (IOException e) {
    28.        e.printStackTrace();
    29.    }
    30. }
    31. if (fis != null) {
    32.    try {
    33.        fis.close();
    34.    } catch (IOException e) {
    35.        e.printStackTrace();
    36.    }
    37. }
    38. }

    4、练习题：获取文本上字符出现的次数，把数据写入文件

    1. FileReader fr = null;
    2. BufferedWriter bw = null;
    3. try {
    4. // 1.创建Map集合
    5. Map<Character, Integer> map = new HashMap<Character, Integer>();
    7. // 2.遍历每一个字符,每一个字符出现的次数放到map中
    8. fr = new FileReader("dbcp.txt");
    9. int c = 0;
    10. while ((c = fr.read()) != -1) {
    11.    //int 还原 char
    12.    char ch = (char) c;
    13.    // 判断char是否在map中第一次出现
    14.    if (map.get(ch) == null) {
    15.        map.put(ch, 1);
    16.    } else {
    17.        map.put(ch, map.get(ch) + 1);
    18.    }
    19. }
    20. // 3.把map中数据存在文件count.txt
    21. // 3.1 创建Writer
    22. bw = new BufferedWriter(new FileWriter("wordcount.txt"));
    23. // 3.2 遍历map,再写入数据
    24. Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
    25. for (Map.Entry<Character, Integer> entry : entrySet) {
    26.    switch (entry.getKey()) {
    27.        case ' ':
    28.            bw.write("空格=" + entry.getValue());
    29.            break;
    30.        case '\t':
    31.            bw.write("tab键=" + entry.getValue());
    32.            break;
    33.        case '\r':
    34.            bw.write("回车=" + entry.getValue());
    35.            break;
    36.        case '\n':
    37.            bw.write("换行=" + entry.getValue());
    38.            break;
    39.        default:
    40.            bw.write(entry.getKey() + "=" + entry.getValue());
    41.            break;
    42.    }
    43.    bw.newLine();
    44. }
    45. } catch (IOException e) {
    46. e.printStackTrace();
    47. } finally {
    48. // 4.关流
    49. fr.close();
    50. bw.close();
    51. }

    五、转换流的使用

    1）转换流：属于字符流、处理流
    InputStreamReader：将一个字节的输入流转换为字符的输入流
    OutputStreamWriter：将一个字符的输出流转换为字节的输出流
    2）作用：提供字节流与字符流之间的转换。很多时候我们使用转换流来处理文件乱码问题。实现编码和
    解码的功能
    3）解码：字节、字节数组 —-> 字符数组、字符串
    编码：字符数组、字符串 —-> 字节、字节数组
    图片4.png
    4）字符集
    ASCII：美国标准信息交换码。用一个字节的7位可以表示
    ISO8859-1：拉丁码表。欧洲码表。用一个字节的8位表示
    GB2312：中国的中文编码表。最多两个字节编码所有字符
    GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
    Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示
    UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
    5）InputStreamReader的使用，实现字节的输入流到字符的输入流的转换 ```java FileInputStream fis = new FileInputStream(“dbcp.txt”);

// InputStreamReader isr = new InputStreamReader(fis); // 使用系统默认的字符集 // 参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集 InputStreamReader isr = new InputStreamReader(fis,”UTF-8”);

char[] cbuf = new char[20]; int len; while((len = isr.read(cbuf)) != -1){ String str = new String(cbuf,0,len); System.out.print(str); } isr.close();

  1. 6）综合使用InputStreamReader和OutputStreamWriter
  2. ```java
  3. // 1.造文件、造流
  4. File file1 = new File("dbcp.txt");
  5. File file2 = new File("dbcp_gbk.txt");
  7. FileInputStream fis = new FileInputStream(file1);
  8. FileOutputStream fos = new FileOutputStream(file2);
  10. InputStreamReader isr = new InputStreamReader(fis,"utf-8");
  11. OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
  13. // 2.读写过程
  14. char[] cbuf = new char[20];
  15. int len;
  16. while((len = isr.read(cbuf)) != -1){
  17.     osw.write(cbuf,0,len);
  18. }
  19. // 3.关闭资源
  20. isr.close();
  21. osw.close();

六、标准输入、输出流（了解）

1）System.in：标准的输入流，默认从键盘输入（字节流）
System.out：标准的输出流，默认从控制台输出
2）System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流
3）练习：
从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。
方法一：使用Scanner实现，调用next()返回一个字符串
方法二：使用System.in实现。System.in —-> 转换流 —-> BufferedReader的readLine()

  1. BufferedReader br = null;
  2. try {
  3.     InputStreamReader isr = new InputStreamReader(System.in);
  4.     br = new BufferedReader(isr);
  6.     while (true) {
  7.         System.out.println("请输入字符串：");
  8.         String data = br.readLine();
  9.         if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
  10.             System.out.println("程序结束");
  11.             break;
  12.         }
  13.         String upperCase = data.toUpperCase();
  14.         System.out.println(upperCase);
  15.     }
  16. } catch (IOException e) {
  17.     e.printStackTrace();
  18. } finally {
  19.    br.close();       
  20. }

七、打印流（了解）

1）实现将基本数据类型的数据格式转化为字符串输出
2）打印流：PrintStream和PrintWriter

  • 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
  • PrintStream和PrintWriter的输出不会抛出IOException异常
  • PrintStream和PrintWriter有自动flush功能
  • PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
  • System.out返回的是PrintStream的实例
    1. PrintStream ps = null;
    2. try {
    3. FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
    4. // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
    5. ps = new PrintStream(fos, true);
    6. if (ps != null) {          // 把标准输出流(控制台输出)改成文件
    7.    System.setOut(ps);
    8. }
    9. for (int i = 0; i <= 255; i++) {        // 输出ASCII字符
    10.    System.out.print((char) i);
    11.    if (i % 50 == 0) {                  // 每50个数据一行
    12.        System.out.println();           // 换行
    13.    }
    14. }
    15. } catch (FileNotFoundException e) {
    16. e.printStackTrace();
    17. } finally {
    18. ps.close();
    19. }

    八、数据流（了解）

    1）DataInputStream 和 DataOutputStream
    2）作用：用于读取或写出基本数据类型的变量或字符串
    3）将内存中的字符串、基本数据类型的变量写出到文件中
    1. // 1.造文件、造流
    2. DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
    3. // 2.写入过程
    4. dos.writeUTF("刘建辰");
    5. dos.flush();        //刷新操作，将内存中的数据写入文件
    6. dos.writeInt(23);
    7. dos.flush();
    8. dos.writeBoolean(true);
    9. dos.flush();
    10. // 3.关流
    11. dos.close();
    4）将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中
    5）注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！ ```java // 1.造文件、造流 DataInputStream dis = new DataInputStream(new FileInputStream(“data.txt”)); // 2.读取过程 String name = dis.readUTF(); int age = dis.readInt(); boolean isMale = dis.readBoolean();

System.out.println(“name = “ + name); System.out.println(“age = “ + age); System.out.println(“isMale = “ + isMale); // 3.关流 dis.close();

  1. <a name="sV2mV"></a>
  2. # 九、对象流
  3. <a name="Yotcf"></a>
  4. ## 1. 基本概念
  6.    - ObjectInputStream和OjbectOutputSteam
  7.    - 用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来
  8.    - 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
  9.    - 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
  10.    - ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
  11. <a name="XFbNw"></a>
  12. ## 2. 对象的序列化
  13. 1）对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象<br />2）序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原<br />3）如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常Serializable、Externalizable<br />4）凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：private static final long serialVersionUID;serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID可能发生变化。故建议，显式声明。<br />5）简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)<br />6）序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去，使用ObjectOutputStream实现ObjectOutputStream oos = null;
  14. ```java
  15. ObjectOutputStream oos = null;
  17. try {
  18.     //1.造文件、造流
  19.     oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
  20.     //2.写入过程
  21.     oos.writeObject(new String("我爱北京天安门"));
  22.     oos.flush();     //刷新操作
  24.     oos.writeObject(new Person("王铭",23));
  25.     oos.flush();
  27.     oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
  28.     oos.flush();
  29.     //3.关流
  30.     oos.close();  
  31. }

7）反序列化：将磁盘文件中的对象还原为内存中的一个java对象，使用ObjectInputStream来实现

  1. ObjectInputStream ois = null;
  2. try {
  3.     ois = new ObjectInputStream(new FileInputStream("object.dat"));
  5.     Object obj = ois.readObject();
  6.     String str = (String) obj;
  8.     Person p = (Person) ois.readObject();
  9.     Person p1 = (Person) ois.readObject();
  11.     System.out.println(str);
  12.     System.out.println(p);
  13.     System.out.println(p1);
  14. } catch (IOException e) {
  15.     e.printStackTrace();
  16. } catch (ClassNotFoundException e) {
  17.     e.printStackTrace();
  18. } finally {
  19.     ois.close();   
  20. }

3. 自定义类实现序列化

Person需要满足如下的要求，方可序列化
1）需要实现接口：Serializable
2）当前类提供一个全局常量：serialVersionUID
3）除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化）

  1. @ToString
  2. @Data
  3. @AllArgsConstructor
  4. @NoArgsConstructor
  5. public class Person implements Serializable{
  7.     public static final long serialVersionUID = 475463534532L;
  9.     private String name;
  10.     private int age;
  11.     private int id;
  12.     private Account acct;
  13. }
  16. @ToString
  17. @Data
  18. @AllArgsConstructor
  19. @NoArgsConstructor
  20. class Account implements Serializable{
  22.     public static final long serialVersionUID = 4754534532L;
  24.     private double balance;
  25. }

十、随机存取文件流（RandomAccessFile 类）

1、RandomAccessFile声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。
2、RandomAccessFile类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件。支持只访问文件的部分内容；可以向已存在的文件后追加内容
3、RandomAccessFile对象包含一个记录指针，用以标示当前读写处的位置。RandomAccessFile类对象可以自由移动记录指针：

  • long getFilePointer()：获取文件记录指针的当前位置
  • void seek(long pos)：将文件记录指针定位到pos位置

4、构造器

  • public RandomAccessFile(File file, String mode)
  • public RandomAccessFile(String name, String mode) l

5、创建RandomAccessFile类实例需要指定一个mode参数，该参数指定RandomAccessFile的访问模式：

  • r：以只读方式打开
  • rw：打开以便读取和写入
  • rwd：打开以便读取和写入；同步文件内容的更新
  • rws：打开以便读取和写入；同步文件内容和元数据的更新

6、如果模式为只读r。则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常
7、如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建，并会对原有文件内容进行覆盖（默认情况下，从头覆盖）

  1. RandomAccessFile raf1 = null;
  2. RandomAccessFile raf2 = null;
  3. try {
  4.     //1.造文件、造流
  5.     raf1 = new RandomAccessFile(new File("爱情与友情.jpg"),"r");
  6.     raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");
  7.     //2.读取与写入过程
  8.     byte[] buffer = new byte[1024];
  9.     int len;
  10.     while((len = raf1.read(buffer)) != -1){
  11.         raf2.write(buffer,0,len);
  12.     }
  13. } catch (IOException e) {
  14.     e.printStackTrace();
  15. } finally {
  16.     //3.关流
  17.     raf1.close();
  18.     raf2.close();
  19. }

8、使用RandomAccessFile实现数据的插入效果

  1. RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
  3. raf1.seek(3);// 将指针调到角标为3的位置
  4. // 保存指针3后面的所有数据到StringBuilder中
  5. StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
  6. byte[] buffer = new byte[20];
  7. int len;
  8. while((len = raf1.read(buffer)) != -1){
  9.     builder.append(new String(buffer,0,len)) ;
  10. }
  11. // 调回指针，写入“xyz”
  12. raf1.seek(3);
  13. raf1.write("xyz".getBytes());
  15. //将StringBuilder中的数据写入到文件中
  16. raf1.write(builder.toString().getBytes());
  18. raf1.close();

补充：使用第三方jar包实现数据读写

  1. import org.apache.commons.io.FileUtils;
  2. import java.io.File;
  3. import java.io.IOException;
  5. File srcFile = new File("day10\\爱情与友情.jpg");
  6. File destFile = new File("day10\\爱情与友情2.jpg");
  8. try {
  9.     FileUtils.copyFile(srcFile,destFile);
  10. } catch (IOException e) {
  11.     e.printStackTrace();
  12. }