核心概述：如何获取和遍历本地文件及目录信息？如何使用读写本地文件？本篇我们将学习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类的构造方法(重要)构造方法public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。
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
}注意一个File对象代表硬盘中实际存在的一个文件或者目录。
无论该路径下是否存在文件或者目录，都不影响File对象的创建。
1.4-File对象获取功能相关方法(重要)方法public String getAbsolutePath()：返回此File的绝对路径名字符串。
public String getPath() ：将此File转换为路径名字符串。
public String getName()：返回由此File表示的文件或目录的名称。
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对象的创建删除功能的方法(重要)方法public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
public boolean delete()：删除由此File表示的文件或目录。
public boolean mkdir() ：创建由此File表示的目录。
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方法。递归注意事项递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
构造方法,禁止递归
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文件代码实现方式1public 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-文件过滤器
分析：FileFilter接口作为参数，需要传递子类对象，重写其中方法。我们选择匿名内部类方式，比较简单。
accept 方法，参数为File，表示当前File下所有的子文件和子目录。保留住则返回true，过滤掉则返回 false。保留规则：要么是.java文件。
要么是目录，用于继续遍历。
通过过滤器的作用， 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类是文件输入流，从文件中读取字节。构造方法FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系 统中的 File对象 fifile命名。
FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件 系统中的路径名 name命名。
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundExceptionpublic 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.txtabcd
读取：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秒
扫一扫
734
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
