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

外围概述：如何获取和遍历本地文件及目录信息？如何应用读写本地文件？本篇咱们将学习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秒