关于java:JavaSE第20篇Java之IO流上篇

27次阅读

共计 16684 个字符，预计需要花费 42 分钟才能阅读完成。

外围概述：如何获取和遍历本地文件及目录信息？如何应用读写本地文件？本篇咱们将学习 File 类来获取本地文件信息，学习递归来遍历文件及目录，学习 Java 中的 IO 流来实现对本地文件的读写。

第一章：File 类

1.1- 概述（理解）

java.io.File 类是文件和目录路径名的形象示意，次要用于文件和目录的创立、查找和删除等操作。File 类将文件，文件夹和门路封装成了对象，提供大量的办法来操作这些对象。

1.2-File 类的动态成员（理解）

动态成员

  • static String pathSeparator 与零碎无关的门路分隔符。

    • Window 操作系统，分隔符是分号。
    • Linux 操作系统，分隔符是冒号。

  • static String separator 与零碎无关的默认名称分隔符。

    • Window 操作系统，名称宰割符号为。
    • Linux 操作系统，名称分隔符号为 /。

示例

public class Test01 {public static void main(String[] args) {System.out.println(File.pathSeparator);  // 输入后果：";"
        System.out.println(File.separator);     //  输入后果："/"
        // 留神：不同的操作系统获取的分隔符是不一样的
    }
}

1.3-File 类的构造方法（重要）

构造方法

  1. public File(String pathname)：通过将给定的路径名字符串转换为形象路径名来创立新的 File 实例。
  2. public File(String parent, String child)：从父路径名字符串和子路径名字符串创立新的 File 实例。
  3. public File(File parent, String child)：从父形象路径名和子路径名字符串创立新的 File 实例。

示例

public class Test02 {public static void main(String[] args) {
        // 创立 File 对象 - 形式 1
        File file1 = new File("D:\\JavaCode\\BasicCode\\a");
        System.out.println(file1);  // 输入后果：D:\JavaCode\BasicCode\a
        // 创立 File 对象 - 形式 2
        File file2 = new File("D:\\JavaCode\\BasicCode\\a","1.txt");
        System.out.println(file2);  // 输入后果：D:\JavaCode\BasicCode\a\1.txt
        // 创立 File 对象 - 形式 3
        File file3 = new File(file1,"1.txt");
        System.out.println(file3);  // 输入后果：D:\JavaCode\BasicCode\a\1.txt
    }

留神

  1. 一个 File 对象代表硬盘中理论存在的一个文件或者目录。
  2. 无论该门路下是否存在文件或者目录，都不影响 File 对象的创立。

1.4-File 对象获取性能相干办法（重要）

办法

  1. public String getAbsolutePath()：返回此 File 的绝对路径名字符串。
  2. public String getPath()：将此 File 转换为路径名字符串。
  3. public String getName()：返回由此 File 示意的文件或目录的名称。
  4. public long length()：返回由此 File 示意的文件的长度。

示例

public class Test03 {public static void main(String[] args) {// 1. `public String getAbsolutePath() `：返回此 File 的绝对路径名字符串。show1();
    // 2. `public String getPath()`：将此 File 转换为路径名字符串。show2();
    // 3. `public String getName() `：返回由此 File 示意的文件或目录的名称。show3();
    // 4. `public long length() `：返回由此 File 示意的文件的长度(文件的大小)
    show4();}

  private static void show4() {
    // 不存在的文件夹或不存在的文件或存在的文件夹返回的都是 0
    File file1 = new File("D:\\JavaCode\\BasicCode\\a");
    System.out.println(file1.length()); //     输入后果：0
    File file3 = new File("D:\\JavaCode\\BasicCode\\aa");
    System.out.println(file3.length()); //  输入后果：0
    File file2 = new File("D:\\JavaCode\\BasicCode\\a\\logo01.png");
    System.out.println(file2.length()); //  输入后果：11610 字节
  }

  private static void show3() {File file1 = new File("D:\\JavaCode\\BasicCode\\a");
    System.out.println(file1.getName()); //      输入后果：a
    File file2 = new File("1.txt");    //        输入后果：1.txt
    System.out.println(file2.getName());
  }

  private static void show2() {
    // 文件门路是什么就返回什么
    File file1 = new File("D:\\JavaCode\\BasicCode\\1.txt");
    System.out.println(file1.getPath()); // 输入后果：D:\JavaCode\BasicCode\1.txt
    File file2 = new File("1.txt");    // 输入后果：1.txt
    System.out.println(file2.getPath());
  }

  private static void show1() {File file1 = new File("D:\\JavaCode\\BasicCode\\1.txt");
    System.out.println(file1.getAbsoluteFile()); // 输入后果：D:\JavaCode\BasicCode\1.txt
    File file2 = new File("1.txt");          // 输入后果：D:\JavaCode\BasicCode\1.txt
    System.out.println(file2.getAbsoluteFile());
  }
}

1.5- 绝对路径和相对路径（理解）

概念

  • 绝对路径：从盘符开始的门路，这是一个残缺的门路。
  • 相对路径：绝对于我的项目目录的门路，这是一个便捷的门路，开发中常常应用。

示例

public static void main(String[] args) {
    // D 盘下的 bbb.java 文件
    File f = new File("D:\\bbb.java");
    System.out.println(f.getAbsolutePath());

    // 我的项目下的 bbb.java 文件
    File f2 = new File("bbb.java");
    System.out.println(f2.getAbsolutePath());
}

1.6-File 对象的判断性能相干办法（重要）

办法

  • public boolean exists()：此 File 示意的文件或目录是否理论存在。
  • public boolean isDirectory()：此 File 示意的是否为目录。
  • public boolean isFile()：此 File 示意的是否为文件。

示例

public class Test04 {public static void main(String[] args) {File file = new File("G:\\typora");   // 实在存在的目录
        // - `public boolean exists()`：此 File 示意的文件或目录是否理论存在。System.out.println(file.exists());      // 输入后果：true
        // - `public boolean isDirectory()`：此 File 示意的是否为目录。System.out.println(file.isDirectory()); // 输入后果：true
        // - `public boolean isFile()`：此 File 示意的是否为文件。System.out.println(file.isFile());      // 输入后果：false
    }
}

1.7-File 对象的创立删除性能的办法（重要）

办法

  1. public boolean createNewFile()：当且仅当具备该名称的文件尚不存在时，创立一个新的空文件。
  2. public boolean delete()：删除由此 File 示意的文件或目录。
  3. public boolean mkdir()：创立由此 File 示意的目录。
  4. public boolean mkdirs()：创立由此 File 示意的目录，包含任何必须但不存在的父目录。

示例

  public static void main(String[] args) throws IOException {// 1. `public boolean createNewFile()`：当且仅当具备该名称的文件尚不存在时，创立一个新的空文件。File file1 = new File("a"); // 曾经存在的文件
    System.out.println(file1.createNewFile()); // false
    File file2 = new File("b"); // 不存在的文件
    System.out.println(file2.createNewFile()); // true
    // 2. `public boolean delete() `：删除由此 File 示意的文件或目录。File file3 = new File("c"); // 存在的文件
    System.out.println(file3.delete()); // true
    File file4 = new File("b"); // 不存在的文件
    System.out.println(file4.delete()); // true
    // 3. `public boolean mkdir()`：创立由此 File 示意的目录。File file5 = new File("e"); // 不存在的文件目录
    System.out.println(file5.mkdir()); // true
    File file6 = new File("e//g/f"); // 多级文件目录
    System.out.println(file6.mkdir()); // false
    // 4. `public boolean mkdirs() `：创立由此 File 示意的目录，包含任何必须但不存在的父目录。System.out.println(file6.mkdirs()); // true

  }

1.8-File 对象的目录遍历相干办法（重要）

办法

  • public File[] listFiles()返回一个 File 数组，示意该 File 目录中的所有的子文件或目录、
  • public File[] listFiles(FileFilter filter)返回一个 File 数组，示意该 File 目录中的所有的子文件或目录，filter 是文件过滤器，能够过滤不须要的文件。

示例

public class Test06 {public static void main(String[] args) {File file = new File("F:\\JavaCode\\BaseCode");
        File[]files = file.listFiles();
        for (File item : files) {System.out.println(item);
        }
        /*
            输入后果：F:\JavaCode\BaseCode\.idea
                F:\JavaCode\BaseCode\a.txt
                F:\JavaCode\BaseCode\Chapter01
                F:\JavaCode\BaseCode\d
                F:\JavaCode\BaseCode\e
                F:\JavaCode\BaseCode\out
        */
    }
}

FileFilter 接口

java.io.FileFilter 是一个接口，是 File 的过滤器。该接口的对象能够传递给 File 类的 listFiles(FileFilter)办法作为参数，接口中只有一个办法。

办法：boolean accept(File pathname)：测试 pathname 是否应该蕴含在以后 File 目录中，合乎则返回 true。如果办法返回 true，示意须要此门路，否则此门路将被疏忽。

示例代码：过滤出该目录中所有的 .java 文件

接口作为参数，须要传递子类对象，重写其中办法。咱们抉择匿名外部类形式，比较简单。

public static void main(String[] args){File dir = new File("d:\\demo");
    File[] files = dir.listFiles(new FileFilter() {
        @Override
        public boolean accept(File pathname) {
            // 判断如果获取到的是目录，间接放行
            if(pathname.isDirectory())
            return true;
            // 获取门路中的文件名，判断是否 java 结尾，是就返回 true
            return pathname.getName().toLowerCase().endsWith("java");
          }
    });
    for(File file : files){System.out.println(file);
    }
}

第二章：递归

2.1- 递归概述（理解）

什么是递归

递归，函数（办法）本身调用本身的编程技巧。

递归的分类：

  • 间接递归 称为办法本身调用本人。
  • 间接递归 能够 A 办法调用 B 办法，B 办法调用 C 办法，C 办法调用 A 办法。

递归注意事项

  1. 递归肯定要有条件限定，保障递归可能停止下来，否则会产生栈内存溢出。
  2. 在递归中尽管有限定条件，然而递归次数不能太多。否则也会产生栈内存溢出。
  3. 构造方法, 禁止递归

2.2- 递归练习 1（练习）

需要

需要：计算数字 1 ~ n 的和

剖析

num 的累和 = num + (num-1)的累和，所以能够把累和的操作定义成一个办法，递归调用。

代码

  // 计算数字 1 ~ n 的和
  public static void main(String[] args) {int sum = getSum(3);
    System.out.println(sum);
  }

  private static int getSum(int n) {
    // 判断递归完结条件
    if(n==1) {return 1;}
    // 递归工作
    return n + getSum(n-1);
  }

图解

2.3- 递归练习 2（练习）

需要

阶乘所有小于及等于该数的正整数的积。n 的阶乘：n! = n (n‐1) … 3 2 * 1

剖析

这与累和相似, 只不过换成了乘法运算

  • 推理得出：n! = n * (n‐1)!

代码

public static void main(String[] args) {int result = factorial(3);
    System.out.println(result);
  }

  private static int factorial(int n) {if(n==1) {return 1;}
    return n * factorial(n-1);
  }

2.4- 递归练习 3（练习）

需要

打印多级目录及文件

代码

  public static void main(String[] args) {File file = new File("D:\\JavaCode\\BasicCode\\dir");
    readFile(file);
  }
  // 定义读取目录文件的办法
  private static void readFile(File file) {
   // 获取子文件和子目录
    File[]files = file.listFiles();
    // 循环遍历子文件和子目录
    for (File f : files) {if(f.isDirectory()){readFile(f);
      }else {System.out.println(f);
      }
    }
  }

2.5- 递归练习 4（练习）

需要

给一个指定的目录，递归实现过滤出该目录中所有的以及嵌套目中 .java 文件

代码实现形式 1 

  public static void main(String[] args) {File file = new File("D:\\JavaCode\\BasicCode");
    readFile(file);
  }
  // 定义读取目录文件的办法
  private static void readFile(File file) {
    // 获取子文件和子目录
    File[]files = file.listFiles();
    // 循环遍历子文件和子目录
    for (File f : files) {if(f.isDirectory()){readFile(f);
      }else {if(f.getName().toLowerCase().endsWith(".java")){System.out.println(f);
        }
      }
    }
  }

代码事项形式 2 - 文件过滤器

剖析：

  1. FileFilter 接口作为参数，须要传递子类对象，重写其中办法。咱们抉择匿名外部类形式，比较简单。

  2. accept 办法，参数为 File，示意以后 File 下所有的子文件和子目录。保留住则返回 true，过滤掉则返回 false。保留规定：

    1. 要么是.java 文件。
    2. 要么是目录，用于持续遍历。
  3. 通过过滤器的作用，listFiles(FileFilter) 返回的数组元素中，子文件对象都是符合条件的，能够间接打

    印。

代码：

  public static void main(String[] args) {File file = new File("D:\\JavaCode\\BasicCode");
    readFile(file);
  }
  // 定义读取目录文件的办法
  private static void readFile(File file) {
    // 获取子文件和子目录
    File[]files = file.listFiles(new FileFilter() {
      @Override
      public boolean accept(File pathname) {
        // 符合条件的 File
        return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
      }
    });
    // 循环遍历子文件和子目录
    for (File f : files) {if(f.isFile()){System.out.println(f);
      }else {readFile(f);
      }
    }
  }

第三章：意识 IO 流

3.1- 什么是 IO（理解）

生存中，你必定经验过这样的场景。当你编辑一个文本文件，遗记了 ctrl+s，可能文件就白白编辑了。当你电脑上插入一个 U 盘，能够把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设施上的呢？键盘、内存、硬盘、外接设备等等。

咱们把这种数据的传输，能够看做是一种数据的流动，依照流动的方向，以内存为基准，分为 输出 input 和 输入 output，即流向内存是输出流，流出内存的输入流。

Java 中 I / O 操作次要是指应用 java.io 包下的内容，进行输出、输入操作。输出也叫做读取数据，输入也叫做作写出数据。

3.2-IO 的分类（理解）

依据数据的流向分为：输出流和输入流。

  • 输出流：把数据从 其余设施 上读取到 内存 中的流。
  • 输入流：把数据从 内存 中写出到 其余设施 上的流。

依据数据的类型分为：字节流和字符流。

  • 字节流：以字节为单位，读写数据的流。
  • 字符流：以字符为单位，读写数据的流。

3.3-IO 的顶级父类（理解）

第四章：字节流

4.1- 所有皆为字节流（理解）

所有文件数据 (文本、图片、视频等) 在存储时，都是以二进制数字的模式保留，都是一个一个的字节，那么传输时一 样如此。所以，字节流能够传输任意文件数据。在操作流的时候，咱们要时刻明确，无论应用什么样的流对象，底层传输的始终为二进制数据。

提醒：8 个二进制位为 1 个字节，0000-0000 是 1 个字节。

4.2- 字节输入流 OutputStream（重要）

概述

java.io.OutputStream 抽象类是示意字节输入流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输入流的根本共性功能办法。

办法

  • public void close()：敞开此输入流并开释与此流相关联的任何系统资源。
  • public void write(byte[] b)：将 b.length 字节从指定的字节数组写入此输入流。
  • public void write(byte[] b, int off, int len)：从指定的字节数组写入 len 字节，从偏移量 off 开始输入到此输入流。
  • public abstract void write(int b)：将指定的字节输入流。

注意事项

close 办法，当实现流的操作时，必须调用此办法，开释系统资源。

4.3-FileOutputStream 类（重要）

概述

OutputStream有很多子类，咱们从最简略的一个子类开始。

java.io.FileOutputStream 类是文件输入流，用于将数据写出到文件。

构造方法

  • public FileOutputStream(File file)：创立文件输入流以写入由指定的 File 对象示意的文件。
  • public FileOutputStream(String name)：创立文件输入流以指定的名称写入文件。

当你创立一个流对象时，必须传入一个文件门路。该门路下，如果没有这个文件，会创立该文件。如果有这个文件，会清空这个文件的数据。

public class FileOutputStreamConstructor  {public static void main(String[] args) throws IOException{
            // 应用 File 对象创立流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 应用文件名称创立流对象
        //FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

写出字节数据

public class Test07 {public static void main(String[] args) throws IOException {FileOutputStream fos = new FileOutputStream("a.txt");
        //【write(int b)】// 写入的十进制会转换成二进制存储到 a.txt
        // 读取文件时，文件会依照指定的编码格局转换为对应的内容
        fos.write(97);  // 写入→97→110 0001‬→内存→读取→110 0001→ASCII→a
        fos.write(98);
        //【write(byte[] b)】byte[]bs = {97,98,99,101,102};
        fos.write(bs);
        //【字符串转换字节数组 getBytes()】fos.write("你好".getBytes());
        //【write(byte[] b, int off, int len)指定长度的字节数组】fos.write("xyz".getBytes(),0,2);
        fos.close();}
}

数据追加续写

问题：通过以上的演示，每次程序运行，创立输入流对象，都会清空指标文件中的数据。如何保留指标文件中数据，还能 持续增加新数据呢？

解决方案：

  • public FileOutputStream(File file, boolean append)：创立文件输入流以写入由指定的 File 对象示意的文件。
  • public FileOutputStream(String name, boolean append)：创立文件输入流以指定的名称写入文件。
  • 参数 boolean append：true 示意追加数据，false 示意清空原有数据。
public class Test08 {public static void main(String[] args) throws IOException {FileOutputStream fos = new FileOutputStream("a.txt",true);
        fos.write("我是新追加的数据".getBytes());
        fos.close();}
}

write 办法源码解析

  • 我调用 write 办法写出数据的时候，JDK 源代码中最终调用的办法是 writeBytes()办法。

  • private native void writeBytes(byte b[], int off, int len, boolean append)throws IOException

    • 办法是本地办法是和操作系统交互的办法。
    • 操作系统自身就具备 IO 性能，因而 JVM 是调用操作系统中的性能实现数据的读写！

写出换行

零碎中的换行：

  • Windows 零碎里，每行结尾是 回车 + 换行，即 \r\n；
  • Unix 零碎里，每行结尾只有 换行，即 \n；
  • Mac 零碎里，每行结尾是 回车，即 \r。从 Mac OS X 开始与 Linux 对立。

代码：

    FileOutputStream fos = new FileOutputStream("b.txt",true);
    for (int i = 0; i < 10; i++) {fos.write(("\r\n 第" + i +"行数据：" + i*100).getBytes());
        }
    fos.close();

4.4- 字节输出流 InputStream（重要）

概述

java.io.InputStream 抽象类是示意字节输出流的所有类的超类，能够读取字节信息到内存中。它定义了字节输出 流的根本共性功能办法。

办法

  • public void close()：敞开此输出流并开释与此流相关联的任何系统资源。
  • public abstract int read()：从输出流读取数据的下一个字节。

  • public int read(byte[] b)：从输出流中读取一些字节数，并将它们存储到字节数组 b 中。

    • 应用数组读取，每次读取多个字节，缩小了零碎间的 IO 操作次数，从而进步了读写的效率，倡议开发中使

      用。

留神：close 办法，当实现流的操作时，必须调用此办法，开释系统资源。

4.5-FileInputStream 类（重要）

java.io.FileInputStream 类是文件输出流，从文件中读取字节。

构造方法

  1. FileInputStream(File file)：通过关上与理论文件的连贯来创立一个 FileInputStream，该文件由文件系 统中的 File 对象 fifile 命名。
  2. FileInputStream(String name)：通过关上与理论文件的连贯来创立一个 FileInputStream，该文件由文件 零碎中的路径名 name 命名。

当你创立一个流对象时，必须传入一个文件门路。该门路下，如果没有该文件, 会抛出FileNotFoundException

public class FileInputStreamConstructor {public static void main(String[] args) throws IOException{
            // 应用 File 对象创立流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 应用文件名称创立流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}

读取字节数据

读取字节 ：read 办法，每次能够读取一个字节的数据，晋升为 int 类型，读取到文件开端，返回-1，代码应用演示：

文件：a.txt

abcd

读取：a.txt 文件

public class Test09 {public static void main(String[] args) throws IOException {
        // 应用文件名称创立流对象
        FileInputStream fis = new FileInputStream("a.txt");
        // 读取数据，返回一个字节
        int read = fis.read();
        System.out.println((char) read); // a
        read = fis.read();
        System.out.println((char) read); // b
        read = fis.read();
        System.out.println((char) read); // c
        read = fis.read();
        System.out.println((char) read); // d
        read = fis.read();
        System.out.println(read);       // -1
    }
}

留神 ：如果文件中存在 -1，咱们在读取文件时也不会间接读取到 -1，因为 - 1 是两个字节，即- 和1。每个文件都会被操作系统赋予一个完结的标识，JVM 调用操作系统性能实现文件读取的，因而操作系统读取到文件完结标识后，会将示意返回到 JVM 中，而 JVM 接管到文件完结标识后，返回 read()办法 -1。

应用循环改良：

public static void main(String[] args) throws IOException{
    // 应用文件名称创立流对象
    FileInputStream fis = new FileInputStream("a.txt");
    // 定义变量，保留数据
    int b = 0 ;
    // 循环读取
    while ((b = fis.read())!=-1) {System.out.println((char)b);
    }
    // 敞开资源
    fis.close();}

应用字节数组读取

read(byte[] b)，每次读取 b 的长度个字节到数组中，返回读取到的无效字节个数，读取到开端时，返回-1，代码应用演示：

public static void main(String[] args) throws IOException{
    // 应用文件名称创立流对象.
    FileInputStream fis = new FileInputStream("read.txt"); // 文件中为 abcde
    // 定义变量，作为无效个数
    int len；// 定义字节数组，作为装字节数据的容器   
    byte[] b = new byte[2];
    // 循环读取
    while ((len= fis.read(b))!=-1) {
    // 每次读取后, 把数组变成字符串打印
        System.out.println(new String(b));
    }
    // 敞开资源
    fis.close();}

谬误数据d，是因为最初一次读取时，只读取一个字节e，数组中，上次读取的数据没有被齐全替换，所以要通过len，获取无效的字节，代码应用演示：

public static void main(String[] args) throws IOException{
    // 应用文件名称创立流对象.
    FileInputStream fis = new FileInputStream("read.txt"); // 文件中为 abcde
    // 定义变量，作为无效个数
    int len；// 定义字节数组，作为装字节数据的容器   
    byte[] b = new byte[2];
    // 循环读取
    while ((len= fis.read(b))!=-1) {
    // 每次读取后, 把数组的无效字节局部，变成字符串打印
        System.out.println(new String(b，0，len));//  len 每次读取的无效字节个数
    }
    // 敞开资源
    fis.close();}

第五章：IO 异样解决

5.1-JDK7 之前的解决形式（重要）

解决形式：try-catch-finally

  • 在 finally 中开释资源

代码：

  public static void main(String[] args)  {
    // 创立输入流对象，向指定的文件中追加写入数据
    FileWriter fw2 = null;
    try{fw2 = new FileWriter("day07_IO\\b.txt",true);
      for (int i = 0; i < 10; i++) {fw2.write("你好，新的世界！" + i + "\r\n");
      }
    }catch (IOException e) {e.printStackTrace();
    }finally {if(fw2!=null){
        try {fw2.close();
        } catch (IOException e) {e.printStackTrace();
        }
      }
    }

  }

5.2-JDK7 中的新个性（理解）

解决形式：JDK7 优化后的 try-with-resource 语句，该语句确保了每个资源在语句完结时敞开。所谓的资源（resource）是指在程序实现后，必须敞开的对象。

try (创立流对象语句，如果多个, 应用 ';' 隔开) {// 读写数据} catch (IOException e) {e.printStackTrace(); 
}

代码：

public static void main(String[] args)  {
    // 创立输入流对象，向指定的文件中追加写入数据
    try(FileWriter fw2 = new FileWriter("day07_IO\\b.txt",true)){for (int i = 0; i < 100; i++) {fw2.write("你好，新的世界！" + i + "\r\n");
      }
    }catch (IOException e) {e.printStackTrace();
    }
  }

5.3-JDK9 中的新个性（理解）

JDK9 中 try-with-resource 的改良，对于引入对象的形式，反对的更加简洁。被引入的对象，同样能够主动敞开，无需手动 close

格局

// 被 final 润饰的对象 
final Resource resource1 = new Resource("resource1"); 
// 一般对象 
Resource resource2 = new Resource("resource2"); 
// 引入形式：间接引入 
try (resource1; resource2) {// 应用对象} catch (IOException e) {e.printStackTrace(); 
}

代码

public static void main(String[] args) throws IOException  {
    // 创立输入流对象，向指定的文件中追加写入数据
    FileWriter fw2 = new FileWriter("day07_IO\\b.txt",true);
    try(fw2){for (int i = 0; i < 100; i++) {fw2.write("你好，新的世界！" + i + "\r\n");
      }
    }catch (IOException e) {e.printStackTrace();
    }
  }

第六章：文件复制案例

6.1- 需要

应用字节流能够进行任何文件的复制，因为字节流操作的是组成文件的最小单元 - 字节。

实现图片文件的复制

6.2- 实现代码

 public static void main(String[] args) throws IOException {long s = System.currentTimeMillis();
    // 创立输出流对象 - 用来读取本地文件
    FileInputStream fis = new FileInputStream("D:\\test.jpg");
    // 创立输入流对象 - 用来写入本地文件
    FileOutputStream fos = new FileOutputStream("IODemo\\test_copy.jpg");
    // 创立字节数组，一次从本地读取多个字节
    byte[]bts = new byte[1024];
    int len = 0; // 示意读取的无效字节个数
    // 循环读取本地数据
    while ((len=fis.read(bts))!=-1){
      // 把理论读取的字节写入本地文件
      fos.write(bts,0,len);
    }
    // 敞开输入流资源
    fos.close();
    // 敞开输出流资源
    fis.close();
    long e = System.currentTimeMillis();
    System.out.println("复制胜利！");
    System.out.println("共耗时" + (e-s)+"毫秒");
  }

第七章：字节缓冲流

7.1- 概述（理解）

缓冲流：针对根底流对象进行高效解决的流对象。或者为根底流减少性能。

字节缓冲流：BufferedInputStream，BufferedOutputStream

缓冲流的基本原理，是在创立流对象时，会创立一个内置的默认大小的缓冲区数组，通过缓冲区读写，缩小零碎 IO 次数，从而进步读写的效率。

7.2- 字节缓冲流的应用（重要）

BufferedOutputStream 继承 OutputStream，write()办法不用从新学习。

BufferedInputStream 继承 InputStream，read()办法不用从新学习。

构造方法

  • public BufferedInputStream(InputStream in)：创立一个 新的缓冲输出流。
  • public BufferedOutputStream(OutputStream out)：创立一个新的缓冲输入流。
// 创立字节缓冲输出流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创立字节缓冲输入流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

留神：在应用缓冲流时，必须传递根底流。

效率测试

查问 API，缓冲流读写办法与根本的流是统一的，咱们通过复制大文件（375MB），测试它的效率。

根底流：

public static void main(String[] args) throws IOException {
    // 记录开始工夫
    long start = System.currentTimeMillis();
    // 创立流对象
    
    FileInputStream fis = new FileInputStream("jdk8.exe");
    FileOutputStream fos = new FileOutputStream("copy.exe")
   
    // 读写数据
    int b = 0;
    while ((b = fis.read()) != -1) {fos.write(b);
    }
    
    // 记录完结工夫
    long end = System.currentTimeMillis();
    System.out.println("一般流复制工夫:"+(end - start)+"毫秒");
}
// 根底流复制工夫：1 分钟以上

缓冲流

public static void main(String[] args) throws FileNotFoundException {
    // 记录开始工夫
    long start = System.currentTimeMillis();
    // 创立流对象
  
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk8.exe"));
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
    // 读写数据
    int len = 0;
    while ((len = bis.read()) != -1) {bos.write(len);
    }
   
    // 记录完结工夫
    long end = System.currentTimeMillis();
    System.out.println("缓冲流应用数组复制工夫:"+(end - start)+"毫秒");
}
// 缓冲流复制工夫:6969 毫秒，约 7 秒钟

缓冲流 + 字节数组

public static void main(String[] args) throws IOException {
        // 记录开始工夫
        long start = System.currentTimeMillis();
        // 创立流对象

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\70418\\Desktop\\test\\jdk8.exe"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\70418\\Desktop\\test\\copy2.exe"));
        // 读写数据
        int len = 0;
        byte[]b = new byte[1024];
        while ((len = bis.read(b)) != -1) {bos.write(b,0,len);
        }

        // 记录完结工夫
        long end = System.currentTimeMillis();
        System.out.println("缓冲流应用数组复制工夫:"+(end - start)+"毫秒");
    }
// 缓冲流应用数组复制工夫:796 毫秒, 约 0.7 秒

正文完
java
发表至： java
2020-08-26
 0
Java并发12-原子类无锁工具类的典范
关于java:阿里云服务器安装jdk8图文教程
关于java:详解Kafka背后优秀的架构设计图文版
关于java:探索-Java-线程的创建