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);
  }

图解

image

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的分类(了解)

image

根据数据的流向分为:输入流和输出流。

  • 输入流 :把数据从 其他设备 上读取到 内存 中的流。
  • 输出流 :把数据从 内存 中写出到 其他设备 上的流。

根据数据的类型分为:字节流和字符流。

  • 字节流 :以字节为单位,读写数据的流。
  • 字符流 :以字符为单位,读写数据的流。

3.3-IO的顶级父类(了解)

image

第四章:字节流

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-需求

使用字节流可以进行任何文件的复制,因为字节流操作的是组成文件的最小单元-字节。

实现图片文件的复制

image

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-概述(了解)

缓冲流:针对基础流对象进行高效处理的流对象。或者为基础流增加功能。

字节缓冲流BufferedInputStreamBufferedOutputStream

缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统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秒