Java文件操作完整指南：从File类到I/O流的实战解析

目录

1.File类

1.1File类的简单使用

1.2相对路径和绝对路径

1.3 需求案例

2. I/O流

2.1 利用文件字节输出流向文件写入数据

2.1.1 文件存在的情况

2.1.2 文件不存在的情况

2.1.3 在文件末尾追加

2.1.4处理异常

2.2利用文件字节输入流 读取文件里的内容

2.2.1文件存在的情况

2.2.2文件不存在的情况

2.2.3处理异常

2.2.4拷贝文件

2.3 利用带缓冲区的字节输出流向文件写入数据

2.4 利用带缓冲区的字节输入流 读取文件里的数据

2.4.1 缓冲区字节输入流的应用

2.4.2 文件拷贝应用

2.4.1 拷贝文件

2.5利用字符输出转换流 向文件写入数据

2.6 利用字符输入转换流 读取文件里的数据

2.6.1 字符输入转换流的应用

2.6.2 文件拷贝应用

2.6.1拷贝文件

2.7 利用文件字符输出流 向文件写入数据

2.8 利用文件字符输入流 读取文件里的数据

2.8.1 文件字符输入流的应用

2.8.1拷贝文件

2.9 利用带缓冲区字符输出流 向文件写入数据

2.10 利用带缓冲区字符输出流 读取文件里的数据

2.10.1 拷贝文件

---

1.File类

1.1File类的简单使用

知识点：

• File类: File类是文件和目录路径名的抽象表示形式。该类主要用于表示文件（目录）的信息，如名称、路径和大小，但它不包含访问文件内容的方法。

• 文件操作: 虽然File类不能直接操作文件内容，它是进行文件操作的基础。对文件里的数据进行操作需要使用IO流。 案例分析： 以下是使用File类获取文件信息的示例：

关键词解释：

• File对象: Java中用于表示文件或目录的一个实例。

• 绝对路径: 文件在计算机中的完整路径，包括驱动器标识符和所有目录。

• lastModified(): 返回文件最后修改时间的方法。

• SimpleDateFormat: 用于格式化和解析日期的具体类。

拓展知识：

• 路径：在操作系统中，文件和目录都通过路径进行访问和定位。

• 工作目录：程序运行时的当前目录，通常是从中启动JVM的目录。 通过这两段代码，我们可以学习到如何使用Java中的File类来获取文件的基本信息，包括文件名、路径、大小、权限以及最后修改时间。同时理解了绝对路径和相对路径的区别和应用场景。在实际开发中，根据需要选择适当的路径类型以确保文件路径的正确性和可移植性。

关键词	解释
File类	Java中的类，用于表示文件或目录的抽象，但不包含操作文件内容的方法。
绝对路径	文件在文件系统中的完整路径，从根目录（或驱动器）开始。
相对路径	相对于当前工作目录的文件路径。
File对象	Java中用于表示文件或目录的一个实例。
lastModified()	用于返回文件最后修改时间的方法。
SimpleDateFormat	Java中的类，用于格式化和解析日期。
getPath()	返回文件的路径，可以是绝对路径或相对路径。
getAbsolutePath()	返回文件的绝对路径。
getName()	返回文件或目录的名称。
length()	返回文件的长度（字节）。
canRead()	检查文件是否可读。
canWrite()	检查文件是否可写。
isHidden()	检查文件是否隐藏。

package com.qf.file01;
​
import java.io.File;
import java.text.SimpleDateFormat;
​
public class Test01 {
    /**
     * 知识点：File类
     * File，是文件和目录路径名的抽象表示
     * File只关注文件本身的信息，而不能操作文件里面的内容
     * 
     * File类 -- 表示文件或文件夹，不能对文件里的数据进行操作
     * 对文件里的数据进行操作的是：IO流
     * 
     * 需求1：通过程序，获取已知文件的以下信息
     */
    public static void main(String[] args) {
        
        //创建File对象
        File file = new File("C:\\Users\\何小宝\\Desktop\\hhy.txt");
        
        System.out.println("获取文件名：" + file.getName());
        System.out.println("获取绝对路径：" + file.getAbsolutePath());
        System.out.println("获取文件大小(字节)：" + file.length());
        System.out.println("获取文件是否可读：" + file.canRead());
        System.out.println("获取文件是否可写：" + file.canWrite());
        System.out.println("获取文件是否隐藏：" + file.isHidden());
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String datetime = sdf.format(file.lastModified());
        System.out.println("获取最后的修改时间：" + datetime);        
    }
}

1.2相对路径和绝对路径

知识点：

• 绝对路径: 一个文件在文件系统中的完整路径，从根目录（或驱动器）开始。

• 相对路径: 相对于当前工作目录的文件路径。

package com.qf.file01;
​
import java.io.File;
​
public class Test02 {
    /**
     * 知识点：相对路径 和 绝对路径
     * 
     * 绝对路径：在计算机内的具体路径（盘符:\文件夹\文件夹\...）
     * 相对路径：相对于当前项目下的路径
     */
    public static void main(String[] args) {
        
        //创建File对象
        File file = new File("hhy.txt");
        
        System.out.println("获取相对路径：" + file.getPath());
        System.out.println("获取绝对路径：" + file.getAbsolutePath());     
    }
}
​

1.3 需求案例

知识点：

• 文件检查：通过file.exists()方法可以检查文件是否存在。

• 文件创建：如果文件不存在，可以使用file.createNewFile()方法来创建一个新文件。 案例分析：

• 在指定路径下检查文件hhy.txt是否存在，如果不存在，则创建这个文件。

• 目录检查和创建：使用file.getParentFile()来获取文件的父目录对象，然后通过parentFile.exists()检查目录是否存在，若不存在，使用parentFile.mkdir()创建目录。 案例分析：

• 检查file01目录是否存在，如果不存在则创建它。然后再检查hhy.txt文件是否存在，如果不存在则创建文件。

• 文件数组：通过file.listFiles()方法获取一个目录下所有文件和目录的File数组。

• 日期格式化：使用SimpleDateFormat对文件的最后修改时间进行格式化。 案例分析：

• 获取D:\2023目录下所有文件和目录的名称及最后修改时间。 #####

• FilenameFilter：一个接口，用于过滤文件名。实现此接口允许指定哪些文件应该包含在文件列表中。 案例分析：

• 使用FilenameFilter实现，筛选出D:\2023目录下所有以.txt为后缀的文件。

关键词解释：

关键词	解释
exists()	检查文件或目录是否存在。
createNewFile()	创建一个新的空文件。
getParentFile()	获取文件的父目录对象。
mkdir()	创建目录。
listFiles()	返回目录下的文件和目录列表。
SimpleDateFormat	用于日期和时间的格式化。
endsWith(suffix)	检查字符串是否以指定的后缀结束。
FilenameFilter	文件名过滤器接口。
isDirectory()	检查File对象是否是目录。
isFile()	检查File对象是否是文件。

package com.qf.file02;
​
import java.io.File;
import java.io.IOException;
​
public class Test01 {
    /**
     * 知识点：File类
     * 
     * 需求1:通过程序，判断指定路径的文件是否存在，如果不存在，则创建该文件
        下面按各种情况来解决该问题
            1)目录已存在的情况
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        
        File file = new File("file01\\hhy.txt");
        
        //文件不存在
        if(!file.exists()){
            //创建文件
            file.createNewFile();
        }       
    }
}

package com.qf.file02;
import java.io.File;
import java.io.IOException;
​
public class Test02 {
    /**
     * 知识点：File类
     * 
     * 需求2:通过程序，判断指定路径的文件是否存在，如果不存在，则创建该文件
        下面按各种情况来解决该问题
            1)目录已存在的情况
            2)有一个层级的目录不存在的情况
     */
    public static void main(String[] args) throws IOException {
        
        //D:\2308workspace\Day23\file01\hhy.txt
        File file = new File("file01\\hhy.txt");
        
        //获取父路径 - D:\2308workspace\Day23\file01
        File parentFile = file.getParentFile();
        //判断目录路径是否存在
        if(!parentFile.exists()){
            //创建一层目录
            parentFile.mkdir();
        }       
        //判断文件是否存在
        if(!file.exists()){
            //创建文件
            file.createNewFile();
        }       
    }
}
​

package com.qf.file03;
​
import java.io.File;
import java.text.SimpleDateFormat;
​
public class Test01 {
    /**
     * 知识点：File类
     * 
     * 需求3:输出指定目录下的所有文件信息
     */
    public static void main(String[] args) {
        
        File file = new File("D:\\2023");
        
        //获取当前目录下所有的文件名，并返回数组
//      String[] list = file.list();
//      for (String str : list) {
//          System.out.println(str);
//      }
        
        //获取当前目录下所有的文件对象，并返回数组
        File[] listFiles = file.listFiles();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        for (File f : listFiles) {
            System.out.println(f.getName() + " -- " + sdf.format(f.lastModified()));
        }
        
    }
}
​

package com.qf.file03;
​
import java.io.File;
​
public class Test02 {
    /**
     * 知识点：File类
     * 
     * 需求3:输出指定目录下的所有文件信息
     *      1)要求只输出文件后缀名为txt的文件
     */
    public static void main(String[] args) {
        
        File file = new File("D:\\2023");
        
        //获取当前目录下所有的文件对象，并返回数组
        File[] listFiles = file.listFiles();
        for (File f : listFiles) {
            String name = f.getName();
            
            //判断f是文件对象 并且 后缀以.txt结尾
            if (f.isFile() && name.endsWith(".txt")) {
                System.out.println(name);
            }
        }
        
    }
}
​

package com.qf.file03;
​
import java.io.File;
import java.io.FilenameFilter;
​
public class Test03 {
    /**
     * 知识点：File类
     * 
     * 需求3:输出指定目录下的所有文件信息
     *      1)要求只输出文件后缀名为txt的文件
     *      2)根据API的过滤器来完成该功能
     */
    public static void main(String[] args) {
        
        File file = new File("D:\\2023");
        
        File[] listFiles = file.listFiles(new FilenameFilter() {
            /**
             * dir - D:\2023
             * name - 遍历到文件的文件名
             */
            @Override
            public boolean accept(File dir, String name) {
                //D:\2023\CSS3
                File f = new File(dir, name);
                
                if(f.isFile() && f.getName().endsWith(".txt")){
                    return true;
                }
                return false;
            }
        });
        
        for (File f : listFiles) {
            System.out.println(f);
        }
    }
}
​

package com.qf.file03;
​
import java.io.File;
​
public class Test04 {
    /**
     * 知识点：File类
     * 
     * 需求3:输出指定目录下的所有文件信息
     *      1)要求只输出文件后缀名为txt的文件
     *      2)根据API的过滤器来完成该功能
     *      3)需求继续跟进，列出当前目录及子目录中符合该条件的文件信息（递归）
     */
    public static void main(String[] args) {
        
        File file = new File("D:\\2023");
        
        search(file, ".jpg");
    }
    
    public static void search(File file,String suffix){
        
        File[] listFiles = file.listFiles();
        
        for (File f : listFiles) {
            if(f.isDirectory()){//文件夹
                search(f, suffix);
                
            }else if(f.isFile()){//文件
                String name = f.getName();
                if(name.endsWith(suffix)){
                    System.out.println(name + " -- " + f.getAbsolutePath());
                }
            }
        }
    }
}
​

2. I/O流

概念

I -- in -- 输入流（读）

O -- out -- 输出流（写）

流 -- 一点点的传输

注意：站在程序角度理解输入和输出

分类

按照方向分：输入流、输出流

按照单位分：字节流、字符流

按照功能分：节点流/基础流、处理流

注意：处理流效率更高，处理流中往往包含了基础流 -- new 处理流(new 基础流());

进制

1024byte = 1Kb

1024Kb = 1Mb

1024Mb = 1Gb

1024Gb = 1Tb

1024Tb = 1Pb

存储进制：1024

经验

1. 举一反三

2. 注重流与流之间的继承关系

字节流

应用场景：处理二进制文件

abstract class InputStream -- 字节输入流（基类）

abstract class OutputStream -- 字节输出流（基类）

class FileInputStream extends InputStream -- 文件字节输入流

class FileOutputStream extends OutputStream -- 文件字节输出流

class FilterInputStream extends InputStream -- 过滤器字节输入流

class FilterOutputStream extends OutputStream -- 过滤器字节输出流

class BufferedInputStream extends FilterInputStream -- 带缓冲区的字节输入流

class BufferedOutputStream extends FilterOutputStream -- 带缓冲区的字节输出流

默认缓冲区大小：8192字节

字符流

应用场景：处理文本数据

注意：字符流底层是字节流+编译器

abstract class Reader -- 字符输入流（基类）

abstract class Writer -- 字符输出流（基类）

class InputStreamReader extends Reader -- 字符输入转换流

class OutputStreamWriter extends Writer -- 字符输出转换流

理解：转换流就是将字节流转换为字符流，转换流就是字节流和字符流的桥梁

class FileReader extends InputStreamReader -- 文件字符输入流

class FileWriter extends OutputStreamWriter -- 文件字符输出流

class BufferedReader extends Reader -- 带缓冲区的字符输入流

class BufferedWriter extends Writer -- 带缓冲区的字符输出流

默认缓冲区大小：8192字符

2.1 利用文件字节输出流向文件写入数据

2.1.1 文件存在的情况

知识点：

• 文件字节输出流：FileOutputStream类用于将数据写入文件。它是字节流的一种，主要用于写入字节数据到文件。

案例分析：

• 创建FileOutputStream对象指向io.txt文件。

• 使用write方法将字节数据写入文件。

• 关闭流以释放资源。

关键词解释：

• FileOutputStream: 用于写入数据到文件的输出流类。

• write(): FileOutputStream的方法，用于写入数据到文件。

• getBytes(): 将字符串转换为字节数组的方法。

• try-catch-finally: 用于处理异常的Java语句块。

• IOException: 表示输入输出操作失败或中断的异常。

• FileNotFoundException: 文件未找到的异常。

package com.qf.io01;

import java.io.FileOutputStream;
import java.io.IOException;

public class Test01 {
	/**
	 * 知识点：利用文件字节输出流 向文件写入数据
	 * 
	 * 	1.文件存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileOutputStream fos = new FileOutputStream("io.txt");
		
		//2.写入数据
		//fos.write(97);//写入Unicode码
		//fos.write("123abcdef".getBytes());//写入字节数组
		fos.write("123abcdef".getBytes(), 3, 6);//写入字节数组,偏移量，写入长度
		
		//3.关闭资源
		fos.close();		
	}
}

2.1.2 文件不存在的情况

知识点：

• 自动创建文件：如果指定的文件不存在，FileOutputStream会自动创建该文件。

案例分析：

• 即使io.txt文件不存在，使用FileOutputStream时会自动创建。

package com.qf.io01;

import java.io.FileOutputStream;
import java.io.IOException;

public class Test02 {
	/**
	 * 知识点：利用文件字节输出流 向文件写入数据
	 * 
	 * 	1.文件存在的情况
	 *  2.文件不存在的情况
	 *  	经验：所有的输出流，当文件不存在时会创建文件
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileOutputStream fos = new FileOutputStream("io.txt");
		
		//2.写入数据
		fos.write("123abcdef".getBytes());//写入字节数组
		
		//3.关闭资源
		fos.close();
		
		
	}
}

2.1.3 在文件末尾追加

知识点：

• 追加模式：FileOutputStream构造方法可以接收一个布尔值，指定是否在文件末尾追加数据。

案例分析：

• 通过将true传递给FileOutputStream构造方法，可以实现在io.txt文件末尾追加内容。

package com.qf.io01;

import java.io.FileOutputStream;
import java.io.IOException;

public class Test03 {
	/**
	 * 知识点：利用文件字节输出流 向文件写入数据
	 * 
	 * 	1.文件存在的情况
	 *  2.文件不存在的情况
	 *  	经验：所有的输出流，当文件不存在时会创建文件
	 *  3.在文件末尾追加
	 *  	经验：考虑基础流的构造方法
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象(在末尾追加内容)
		FileOutputStream fos = new FileOutputStream("io.txt",true);
		
		//2.写入数据
		fos.write("123abcdef".getBytes());//写入字节数组
		
		//3.关闭资源
		fos.close();
		
		
	}
}

2.1.4处理异常

知识点：

• 异常处理：在文件操作过程中可能会抛出IOException，因此需要进行异常处理。

• 资源关闭：确保在finally块中关闭FileOutputStream，以防资源泄露。

案例分析：

• 使用try-catch-finally结构来处理可能发生的异常，并在finally块中关闭文件输出流。

package com.qf.io01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test04 {
	/**
	 * 知识点：利用文件字节输出流 向文件写入数据
	 * 
	 * 	1.文件存在的情况
	 *  2.文件不存在的情况
	 *  	经验：所有的输出流，当文件不存在时会创建文件
	 *  3.在文件末尾追加
	 *  	经验：考虑基础流的构造方法
	 *  4.处理异常
	 */
	public static void main(String[] args) {
		
		
		FileOutputStream fos = null;
		try {
			//1.创建流对象(在末尾追加内容)
			fos = new FileOutputStream("io.txt",true);
			
			//2.写入数据
			fos.write("123abcdef".getBytes());//写入字节数组
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//3.关闭资源
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
	}
}

2.2利用文件字节输入流 读取文件里的内容

2.2.1文件存在的情况

知识点：

• 文件字节输入流：FileInputStream用于从文件中读取数据。

• 逐字节读取：read()方法每次读取一个字节，返回读取的字节，文件末尾返回-1。

案例分析：

• 创建FileInputStream对象指向io.txt文件。

• 逐个字节读取文件内容，转换为字符后打印。

• 关闭流以释放资源。

package com.qf.io01;

import java.io.FileInputStream;
import java.io.IOException;

public class Test05 {
	/**
	 * 知识点：利用文件字节输入流 读取文件里的内容
	 * 
	 * 1.文件存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据
		//read()：读取一个字节，如果读取到文件末尾则返回-1
		int read = fis.read();
		System.out.println((char)read);
		read = fis.read();
		System.out.println((char)read);
		read = fis.read();
		System.out.println((char)read);
		read = fis.read();
		System.out.println((char)read);
		read = fis.read();
		System.out.println((char)read);
		read = fis.read();
		System.out.println((char)read);
		read = fis.read();
		System.out.println(read);
		
		//3.关闭资源
		fis.close();
		
	}
}

2.2.2文件不存在的情况

package com.qf.io01;

import java.io.FileInputStream;
import java.io.IOException;

public class Test06 {
	/**
	 * 知识点：利用文件字节输入流 读取文件里的内容
	 * 
	 * 1.文件存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据 - 一个字节一个字节的循环读取
		int read;
		while((read = fis.read()) != -1){
			System.out.println((char)read);
		}
		
		//3.关闭资源
		fis.close();
		
	}
}

package com.qf.io01;

import java.io.FileInputStream;
import java.io.IOException;

public class Test07 {
	/**
	 * 知识点：利用文件字节输入流 读取文件里的内容
	 * 
	 * 1.文件存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据 - 1024个字节1024个字节的循环读取
		//read(bs)：每次读取bs长度的数据并把数据存入bs数组中，返回读取到的有效字节数，如果读取到文件末尾则返回-1
		byte[] bs = new byte[1024];//[49,50,51,97,98,99,0,0,0,0,0,0,0]
		int len;
		while((len = fis.read(bs)) != -1){
			
			System.out.println(new String(bs, 0, len));
		}
		
		//3.关闭资源
		fis.close();
		
	}
}

2.2.3处理异常

package com.qf.io01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test08 {
	/**
	 * 知识点：利用文件字节输入流 读取文件里的内容
	 * 
	 * 1.文件存在的情况
	 * 2.文件不存在的情况
	 * 		经验：所有的输入流，当文件不存在时都会报错 -- FileNotFoundException
	 * 3.处理异常
	 */
	public static void main(String[] args){
		
		
		FileInputStream fis = null;
		try {
			//1.创建流对象
			fis = new FileInputStream("io.txt");
			
			//2.读取数据
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				
				System.out.println(new String(bs, 0, len));
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//3.关闭资源
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
	}
}

2.2.4拷贝文件

package com.qf.io01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy01 {
	/**
	 * 知识点：拷贝文件
	 * 
	 * 思路：读取源文件，写入到目标文件
	 */
	public static void main(String[] args) {
		
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("小晓.mp4");
			fos = new FileOutputStream("copy.mp4");
			
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				fos.write(bs, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		
		
	}
}

package com.qf.io01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy02 {
	/**
	 * 知识点：拷贝文件
	 * 
	 * 思路：读取源文件，写入到目标文件
	 */
	public static void main(String[] args) {
		
		
		try(FileInputStream fis = new FileInputStream("小晓.mp4");
			FileOutputStream fos = new FileOutputStream("copy.mp4");){
			
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				fos.write(bs, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} 
		
	}
}

2.3 利用带缓冲区的字节输出流向文件写入数据

知识点：

• BufferedOutputStream：带缓冲区的字节输出流，提高数据写入效率。

• 构造方法：可以指定缓冲区大小，也可以使用默认大小（通常为8192字节）。

• 写入数据：数据首先被写入缓冲区，缓冲区满时才写入文件。

案例分析：

• 创建BufferedOutputStream实例，指向文件io.txt。

• 数据写入操作是通过缓冲区进行的，提高了写入效率。

• 关闭流时，缓冲区的数据会被刷新到文件。

关键词解释：

关键词	解释
BufferedOutputStream	带缓冲区的字节输出流，提高数据写入效率。
BufferedInputStream	带缓冲区的字节输入流，提高数据读取效率。
OutputStreamWriter	将字符流的数据转换为字节流，可以指定编码格式。
InputStreamReader	将字节流的数据转换为字符流，可以指定编码格式。
FileInputStream	用于从文件中读取数据的字节输入流。
FileOutputStream	用于向文件中写入数据的字节输出流。
read()	用于从输入流中读取数据，可以是单个字节或字节数组。
write()	用于向输出流中写入数据，可以是单个字节、字节数组、字符或字符数组。
close()	关闭流，释放与流相关联的资源。

package com.qf.io02;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test01 {
	/**
	 * 知识点：利用带缓冲区的字节输出流向文件写入数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象 -- 默认缓冲区大小8192
		//BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"));
		
		//1.创建流对象 -- 自定义缓冲区大小1024*1024*5
		//BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"), 1024*1024*5);
		
		//1.创建流对象 (在末尾追加)
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt",true));
		
		//2.写入数据 -- 将数据写入到缓冲区数组里
		bos.write("123abcdef".getBytes());
		
		//3.关闭资源
		bos.close();
	}
}

2.4 利用带缓冲区的字节输入流 读取文件里的数据

2.4.1 缓冲区字节输入流的应用

知识点：

• BufferedInputStream：带缓冲区的字节输入流，提高数据读取效率。

• 构造方法：可以指定缓冲区大小，也可以使用默认大小。

• 读取数据：从文件中读取数据到缓冲区，然后从缓冲区中获取数据。

案例分析：

• 创建BufferedInputStream实例，指向文件io.txt。

• 使用字节数组作为缓冲区读取数据，每次读取一定量的字节。

• 关闭流时释放资源。

2.4.2 文件拷贝应用

知识点：

• 文件拷贝：使用带缓冲的输入/输出流进行高效的文件拷贝。

• 读取与写入：通过循环读取源文件数据到缓冲区，然后写入目标文件。

案例分析：

• 创建指向小阳.mp4的BufferedInputStream和指向copy.mp4的BufferedOutputStream。

• 使用字节数组作为缓冲进行数据传输，直到文件结束。

• 使用异常处理机制确保文件流正确关闭。

package com.qf.io02;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Test02 {
	/**
	 * 知识点：利用带缓冲区的字节输入流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象 -- 默认缓冲区大小8192
		//BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io.txt"));
		
		//1.创建流对象 -- 自定义缓冲区大小2048
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io.txt"),2048);
		
		//2.读取数据
		byte[] bs = new byte[1024];
		int len;
		while((len = bis.read(bs)) != -1){
			System.out.println(new String(bs, 0, len));
		}
		
		//3.关闭资源
		bis.close();
	}
}

2.4.1 拷贝文件

package com.qf.io02;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy {
	/**
	 * 知识点：拷贝文件
	 * 
	 * 思路：读取源文件，写入到目标文件
	 */
	public static void main(String[] args) {
		
		
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		
		try {
			bis = new BufferedInputStream(new FileInputStream("小阳.mp4"));
			bos = new BufferedOutputStream(new FileOutputStream("copy.mp4"));
			
			byte[] bs = new byte[1024];
			int len;
			while((len = bis.read(bs)) != -1){
				bos.write(bs, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(bis != null){
				try {
					bis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bos != null){
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
	}
}

2.5利用字符输出转换流 向文件写入数据

• 知识点：

  • OutputStreamWriter：字符输出转换流，将字符流转换为字节流。

  • 编码格式：可以指定输出的编码格式，如GBK、UTF-8等。

  • 写入数据：可以写入单个字符、字符数组或字符串。

  案例分析：

  • 创建OutputStreamWriter实例，指向io.txt，指定GBK编码格式。

  • 写入不同类型的数据，包括Unicode字符、字符数组和字符串。

  • 关闭流时释放资源。

package com.qf.io03;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Test01 {
	/**
	 * 知识点：利用字符输出转换流 向文件写入数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象（使用默认的编码格式）
		//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("io.txt"));
		
		//1.创建流对象（使用自定义的编码格式）-- 推荐
		//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("io.txt"),"GBK");
		
		//1.创建流对象（使用自定义的编码格式）+ 文件末尾追加 -- 推荐
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("io.txt",true),"GBK");
		
		//2.写入数据
		//osw.write(97);//写入Unicode码
		
		//char[] cs = {'1','2','3','a','b','c','木','头','人'};
		//osw.write(cs);//写入字符数组
		//osw.write(cs, 3, 6);//写入字符数组，偏移量，写入长度
		
		//osw.write("123abc木头人");//写入字符串
		osw.write("123abc木头人", 3, 6);//写入字符串，偏移量，写入长度
		
		//3.关闭资源
		osw.close();
	}
}

2.6 利用字符输入转换流 读取文件里的数据

2.6.1 字符输入转换流的应用

知识点：

• InputStreamReader：字符输入转换流，将字节流转换为字符流。

• 编码格式：可以指定读取时的编码格式。

• 读取数据：可以读取单个字符或字符数组。

案例分析：

• 创建InputStreamReader实例，指向io.txt，指定GBK编码格式。

• 通过循环读取单个字符或字符数组，直到文件末尾。

• 关闭流时释放资源。

2.6.2 文件拷贝应用

知识点：

• 文件拷贝：使用字符输入/输出转换流进行文件拷贝，适用于文本文件。

• 编码一致性：确保源文件和目标文件使用相同的编码格式。

案例分析：

• 读取小说.txt文件，使用InputStreamReader指定GBK编码。

• 使用OutputStreamWriter将读取的数据写入copy.txt，保持编码一致。

• 使用字符数组作为缓冲区进行数据传输。

package com.qf.io03;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test02 {
	/**
	 * 知识点：利用字符输入转换流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象(使用默认的编码格式)
		//InputStreamReader isr = new InputStreamReader(new FileInputStream("io.txt"));
		
		//1.创建流对象(使用自定义的编码格式) -- 推荐
		InputStreamReader isr = new InputStreamReader(new FileInputStream("io.txt"),"GBK");
		
		//2.读取数据
		//read():读取一个字符的Unicode码，如果读取到文件末尾则返回-1
		int read;
		while((read = isr.read()) != -1){
			System.out.println((char)read);
		}
		
		//3.关闭资源
		isr.close();
	}
}

package com.qf.io03;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test03 {
	/**
	 * 知识点：利用字符输入转换流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象(使用自定义的编码格式) -- 推荐
		InputStreamReader isr = new InputStreamReader(new FileInputStream("io.txt"),"GBK");
		
		//2.读取数据
		char[] cs = new char[1024];
		int len;
		while((len = isr.read(cs)) != -1){
			System.out.println(new String(cs,0,len));
		}
		
		//3.关闭资源
		isr.close();
	}
}

2.6.1拷贝文件

package com.qf.io03;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class Copy {
	/**
	 * 知识点：拷贝文件
	 */
	public static void main(String[] args) throws UnsupportedEncodingException, IOException {
		
		InputStreamReader isr = new InputStreamReader(new FileInputStream("小说.txt"), "GBK");
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("copy.txt"), "GBK");
		
		char[] cs = new char[1024];
		int len;
		while((len = isr.read(cs)) != -1){
			osw.write(cs, 0, len);
		}		
		isr.close();
		osw.close();		
	}
}

2.7 利用文件字符输出流 向文件写入数据

知识点：

• FileWriter：用于写入字符到文件的字符输出流。

• 追加模式：可以选择在文件末尾追加内容。

案例分析：

• 创建FileWriter实例，指向文件io.txt，可选择追加模式。

• 使用write方法写入字符串。

• 关闭流以释放资源。

package com.qf.io04;

import java.io.FileWriter;
import java.io.IOException;

public class Test01 {
	/**
	 * 知识点：利用文件字符输出流 向文件写入数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		//FileWriter fw = new FileWriter("io.txt");
		
		//1.创建流对象 + 在文件末尾追加
		FileWriter fw = new FileWriter("io.txt",true);
		
		//2.写入数据
		fw.write("123abc木头人");//写入字符串
		
		//3.关闭资源
		fw.close();
	}
}

2.8 利用文件字符输入流 读取文件里的数据

2.8.1 文件字符输入流的应用

知识点：

• FileReader：用于从文件中读取字符的字符输入流。

• 批量读取：可以使用字符数组进行批量读取。

案例分析：

• 创建FileReader实例，指向文件io.txt。

• 使用字符数组作为缓冲区读取数据，每次读取一定数量的字符。

• 关闭流时释放资源。

package com.qf.io04;

import java.io.FileReader;
import java.io.IOException;

public class Test02 {
	/**
	 * 知识点：利用文件字符输入流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileReader fr = new FileReader("io.txt");
		
		//2.读取数据
		char[] cs = new char[1024];
		int len;
		while((len = fr.read(cs)) != -1){
			System.out.println(new String(cs, 0, len));
		}
		
		//3.关闭资源
		fr.close();
	}
}

2.8.1拷贝文件

知识点：

• 文件拷贝：使用字符输入输出流进行文本文件的拷贝。

• 批量传输：通过字符数组进行批量数据传输。

案例分析：

• 读取小说.txt文件，使用FileReader。

• 使用FileWriter将读取的数据写入copy.txt。

• 使用字符数组作为缓冲区进行数据传输。

package com.qf.io04;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

public class Copy {
	/**
	 * 知识点：拷贝文件
	 */
	public static void main(String[] args) throws UnsupportedEncodingException, IOException {
		
		FileReader fr = new FileReader("小说.txt");
		FileWriter fw = new FileWriter("copy.txt");
		
		char[] cs = new char[1024];
		int len;
		while((len = fr.read(cs)) != -1){
			fw.write(cs, 0, len);
		}
		
		fr.close();
		fw.close();
		
	}
}

2.9 利用带缓冲区字符输出流 向文件写入数据

知识点：

• BufferedWriter：带缓冲区的字符输出流，提高数据写入效率。

• 构造方法：可以通过FileWriter创建，并选择追加模式。

案例分析：

• 创建BufferedWriter实例，指向io.txt，可选择追加模式。

• 使用write方法写入字符串。

• 关闭流以释放资源。

package com.qf.io05;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Test01 {
	/**
	 * 知识点：利用带缓冲区字符输出流 向文件写入数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象(FileOutputStream -> OutputStreamWriter -> BufferedWriter)
		//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("io.txt"), "GBK"));
		
		//1.创建流对象(FileWriter -> BufferedWriter)
		BufferedWriter bw = new BufferedWriter(new FileWriter("io.txt",true));
		
		//2.写入数据
		bw.write("123abc木头人");//写入字符串
		
		//3.关闭资源
		bw.close();
	}
}

2.10 利用带缓冲区字符输出流 读取文件里的数据

知识点：

• BufferedReader：带缓冲区的字符输入流，提高数据读取效率。

• 编码格式：可以指定编码格式，如GBK。

案例分析：

• 创建BufferedReader实例，指向io.txt，可指定编码格式。

• 使用字符数组作为缓冲区读取数据。

• 关闭流时释放资源。

关键词解释：

关键词	解释
FileWriter	用于写入字符到文件的字符输出流。
FileReader	用于从文件中读取字符的字符输入流。
BufferedWriter	带缓冲区的字符输出流，提高数据写入效率。
BufferedReader	带缓冲区的字符输入流，提高数据读取效率。
write()	用于向输出流中写入数据，可以是单个字符、字符数组或字符串。
read()	用于从输入流中读取数据，可以是单个字符或字符数组。
readLine()	用于从带缓冲的字符输入流中读取一行数据。
newLine()	用于在使用带缓冲的字符输出流时写入换行符。
close()	关闭流，释放与流相关联的资源。

package com.qf.io05;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test02 {
	/**
	 * 知识点：利用带缓冲区字符输出流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象(FileInputStream -> InputStreamReader -> BufferedReader)
		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("io.txt"), "GBK"));
		
		//2.读取数据
		char[] cs = new char[1024];
		int len;
		while((len = br.read(cs)) != -1){
			System.out.println(new String(cs, 0, len));
		}
		
		//3.关闭资源
		br.close();
	}
}

2.10.1 拷贝文件

package com.qf.io05;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

public class Copy01 {
	/**
	 * 知识点：拷贝文件
	 */
	public static void main(String[] args) throws UnsupportedEncodingException, IOException {
		
		BufferedReader br = new BufferedReader(new FileReader("小说.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
		
		char[] cs = new char[1024];
		int len;
		while((len = br.read(cs)) != -1){
			bw.write(cs, 0, len);
		}
		
		br.close();
		bw.close();
		
	}
}

package com.qf.io05;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

public class Copy02 {
	/**
	 * 知识点：拷贝文件
	 */
	public static void main(String[] args) throws UnsupportedEncodingException, IOException {
		
		BufferedReader br = new BufferedReader(new FileReader("小说.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
		
		String readLine;
		while((readLine = br.readLine()) != null){
			bw.write(readLine);
			bw.newLine();//换行
		}
		
		br.close();
		bw.close();
		
	}
}