输入流和输出流

文件夹和文件路径

package cn.ekgc.javasenior.day20210627;

import java.io.File;
import java.io.IOException;

public class FileDemo01 {
	public static void main(String[] args) {
		/*
		 * 1、任何数据，在硬盘上都是以文件的形式进行存储。
		 * 2、对于程序中所产生的任何数据，或者是程序所需要的任何数据都必须以文件的形式来存储。
		 * 3、Java 要想操作硬盘的文件，那么这些文件都必须以一个对象的形式出现在 Java 中。
		 * 因此，Java 中通过 java.io.File 类的对象来代指硬盘上的某个具体的对象。
		 */
		// 要想获得硬盘上某个文件所对应的 java.io.File 对象，只需要给定该文件的路径，直接创建对象即可
		// 使用一个 String 类型的变量存储硬盘上某个文件的路径
		String filePath = "D:\\HelloWorld.java";
		// 使用这个文件路径，创建 File 对象
		File file = new File(filePath);
		// 当通过该文件的路径，所创建的 File 对象，那么通过这个对象，能够操作该硬盘上的该文件
		// 通过 File 对象，能够获得该文件的文件名
		String fileName = file.getName();
		System.out.println("该文件的文件名是：" + fileName);
		// 通过 File 对象，获得该文件的路径
		String path = file.getPath();
		System.out.println("该文件的路径是：" + path);
		// 获得该文件的绝对路径
		String absPath = file.getAbsolutePath();
		System.out.println("该文件的绝对路径是：" + absPath);
		// 判断该 File 对象所对应的硬盘文件是否存在
		boolean isExists = file.exists();
		System.out.println("该 File 对象所对应的硬盘文件是否存在：" + isExists);
		// 通过 File 对象可以将该对象所对应的硬盘文件进行创建。
		// 在计算机中，所有的数据都是以文件的形式存在，无论是具体的文件还是文件夹。
		// 因此，无论是文件还是文件夹，在 Java 中都是一个个 java.io.File 对象。
		// 对于计算机来说，本质上是没有文件夹这个概念，我们将文件夹称之为目录。
		// 那么，要想创建一个文件，需要通过 createNewFile() 实现。
		try {
			// 为了防止覆盖文件，往往会判断，如果文件不存在，那么就创建该文件
			if (!isExists) {
				// 当 isExists 为 false 时，说明该文件不能存在，
				// 因此只有将 isExists 变为 true，才能够进入到 if 分支中
				file.createNewFile();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		// 获得这个文件的空间大小
		long spaceSize = file.getTotalSpace();
		System.out.println("该文件所占用的总的空间大小：" + spaceSize);
		// 获得该文件的内容大小
		long freeSpace = file.getFreeSpace();
		System.out.println("该文件的内容大小：" + freeSpace);
		// 该文件的可用空间大小
		long useableSpace = file.getUsableSpace();
		System.out.println("该文件的可用空间大小：" + useableSpace);
		
		// 在经过操作完成文件之后，就可以删除这个文件
		// 通过 delete() 是将文件彻底从硬盘上进行删除
		file.delete();
	}
}

package cn.ekgc.javasenior.day20210627;

import java.io.File;

public class FileDemo02 {
	public static void main(String[] args) {
		// 和操作文件一致，对于 Java 来说，文件和目录都是 File 对象
		// 设定目录所在的路径
		String folderPath = "D://李静平//张涛//袁帅杰";
		// 根据该文件夹的路径，创建对应的 File 对象
		File folderFile = new File(folderPath);
		// 判断该目录是否存在
		boolean isExists = folderFile.exists();
		System.out.println("该目录是否存在：" + isExists);
		// 如果该文件夹不存在，那么就创建该文件夹
		if (!isExists) {
			// 创建该文件夹
			// 对于 mkdir() 方法来说只能够创建一级文件夹，
			// 如果该文件夹是多级的，而且其外层的文件夹都不存在，那么是无法创建的
			// folderFile.mkdir();
			// 如果需要创建一系列的文件夹，可以使用 mkdirs()
			folderFile.mkdirs();
		}
		// 获得该目录的目录名
		String folderName = folderFile.getName();
		System.out.println("该目录的名称是：" + folderName);
		// 获得该目录的路径和绝对路径
		String path = folderFile.getPath();
		String absPath = folderFile.getAbsolutePath();
		System.out.println("该目录的路径是：" + path);
		System.out.println("该目录的绝对路径是：" + absPath);
		// 获得该目录的大小
		long size = folderFile.length();
		System.out.println("该目录的大小是：" + size);
		// 将该目录进行删除
		// 如果要判断一个 File 对象是不是目录，可以使用 isDirectory()
		boolean isDirectory = folderFile.isDirectory();
		System.out.println("该 File 对象是否是一个目录：" + isDirectory);
		// 如果要判断一个 File 对象是否是一个文件，可以使用 isFile()
		boolean isFile = folderFile.isFile();
		System.out.println("该 File 对象是否是一个文件：" + isFile);
		
		// 删除该目录
		folderFile.delete();
	}
}

 文件的复制带缓冲区和不带缓冲区

package cn.ekgc.javasenior.day20210628;

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

public class CopyDemo01 {
	public static void main(String[] args) {
		/*
		 * 使用 FileInputStream 和 FileOutputStream 实现对于一个文件的复制功能。
		 * 思路：
		 * 1、通过 FileInputStream 将文件读取到程序中；
		 * 2、通过 FileOutputStream 将读取到的文件写入到另外一个文件中。
		 */
		// 设定需要读取的文件路径
		String srcFilePath = "C:\\Users\\Arthur\\Desktop\\123.wmv";
		// 设定所要写入的文件路径
		String descFilePath = "C:\\Users\\Arthur\\Desktop\\456.wmv";
		// 根据 srcFilePath 创建对应的 File 对象
		File srcFile = new File(srcFilePath);
		// 根据 descFilePath 创建对应的 File 对象
		File descFile = new File(descFilePath);
		// 要想读取文件，那么需要 FileInputStream 对象，创建 FileInputStream 类型的变量
		FileInputStream in = null;
		// 要想将所读取到的数据存储到文件中，那么需要用到 FileOutputStream，创建 FileOutputStream 变量
		FileOutputStream out = null;
		try {
			// 根据 srcFile 对象创建 FileInputStream 对象
			in = new FileInputStream(srcFile);
			// 根据 descFile 对象创建 FileOutputStream 对象
			out = new FileOutputStream(descFile);
			// 使用输入流读取 src 文件中的数据
			int i;
			while ((i = in.read()) != -1) {
				// 每读取到一个字节，那么就将这个字节借助于 FileOutputStream 写入到文件中
				out.write(i);
			}
			System.out.println("文件复制完成！");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭输入流
				in.close();
				// 关闭输出流
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

package cn.ekgc.javasenior.day20210628;

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

public class CopyDemo02 {
	public static void main(String[] args) {
		/*
		 * 使用 FileInputStream 和 FileOutputStream 实现对于一个文件的复制功能。
		 * 思路：
		 * 1、通过 FileInputStream 将文件读取到程序中；
		 * 2、通过 FileOutputStream 将读取到的文件写入到另外一个文件中。
		 */
		// 设定需要读取的文件路径
		String srcFilePath = "C:\\Users\\Arthur\\Desktop\\123.wmv";
		// 设定所要写入的文件路径
		String descFilePath = "C:\\Users\\Arthur\\Desktop\\456.wmv";
		// 根据 srcFilePath 创建对应的 File 对象
		File srcFile = new File(srcFilePath);
		// 根据 descFilePath 创建对应的 File 对象
		File descFile = new File(descFilePath);
		// 要想读取文件，那么需要 FileInputStream 对象，创建 FileInputStream 类型的变量
		FileInputStream in = null;
		// 要想将所读取到的数据存储到文件中，那么需要用到 FileOutputStream，创建 FileOutputStream 变量
		FileOutputStream out = null;
		try {
			// 根据 srcFile 对象创建 FileInputStream 对象
			in = new FileInputStream(srcFile);
			// 根据 descFile 对象创建 FileOutputStream 对象
			out = new FileOutputStream(descFile);
			// 在读取时，原始的方式一个字节一个字节的读取，那么效率较低，因此使用一个 byte[] 作为缓冲区
			// 首先将读取到的数据存储在数组中，当数组中的所有元素都有值之后，将该数组交给程序，提高读取效率
			byte[] buffers = new byte[1024];
			// 使用输入流读取 src 文件中的数据
			int i;
			while ((i = in.read(buffers)) != -1) {
				// 如果使用了缓冲区，那么此时的 i 将不再是某个字节的编码，而是该缓冲区数组中有数据的元素个数
				// 那么在写出数据的时候，就只能将该数组中有数据的部分写入到文件
				out.write(buffers, 0, i); 
			}
			System.out.println("文件复制完成！");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭输入流
				in.close();
				// 关闭输出流
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 输入流读取

package cn.ekgc.javasenior.day20210627;

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

public class FileInputStreamDemo01 {
	public static void main(String[] args) {
		/*
		 * 由于计算机本质上存储和能够识别的都是 0 和 1 的字节，
		 * 因此字节流是最基础的流。
		 * 按照传输方向，可分为输入字节流和输出字节流两个类。
		 * 其中输入字节流的最顶级接口是：InputStream
		 * 因此最基础的输入字节流是 FileInputStream。
		 * 所有其他输入字节流都必须借助于 FileInputStream 实现，
		 * 我们将这些其他的输入字节流称之为包装流。
		 */
		// 为了能够创建 FileInputStream 首先必须将所读取的文件变为一个 File 对象。
		// 设定所要读取文件的路径
		String filePath = "D:\\test.txt";
		// 根据文件路径创建该文件所对应的 File 对象
		File file = new File(filePath);
		// 创建一个 FileInputStream 的变量
		FileInputStream fis = null;
		try {
			// 根据 File 对象创建 FileInputStream 对象
			fis = new FileInputStream(file);
			// 当设定好需要读取的文件以及文件和程序之间的流之后，就可以通过流来读取文件中的数据
			// 那么在读取是，是一个个字节进行读取的。
			// 声明一个 int 类型的变量 i，用于存储此时所读取的字节的编码
			int i;
			// 每读到一个字节，那么这个 i 就是这个字节所对应的编码，如果整个文件读取结束，那么 i 就是 -1
			while ((i = fis.read()) != -1) {
				// 此时 i 就存储的是当前文件的一个字节编码
				System.out.println(i);
			}
		} catch(Exception e) {
			e.printStackTrace();
		} finally {
			// 无论是否在读取的过程中产生异常，都必须管理传输管道（FileInputStream）
			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 带缓冲区的读取

package cn.ekgc.javasenior.day20210627;

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

public class FileInputStreamDemo02 {
	public static void main(String[] args) {
		// 设定需要读取的文件路径
		String filePath = "C:\\Users\\Arthur\\Desktop\\123.wmv";
		// 根据该文件名创建对应的 File 对象
		File file = new File(filePath);
		// 创建 FileInputStream
		FileInputStream in = null;
		try {
			// 根据 File 对象创建 FileInputStream 对象
			in = new FileInputStream(file);
			// 声明一个 int 类型的变量 i 存储此时所读取的字符编码
			// 由于在读取文件时，是一个一个字节读取，然后使用的，那么对于文件过大，那么效率极慢
			int i;
			// 因为为了能够提高读取的效率，往往可以准备一个 byte[] 用于存储所读入的字节，
			// 当数组装满数据后，可以一次性的交给程序
			// 此时我们将这个 byte[] 就称之为缓冲区
			byte[] buffer = new byte[1024];
			// 循环读取文件数据
			// 记录文件开始读取时间
			long begin = System.currentTimeMillis();
			while ((i = in.read(buffer)) != -1) {
				// 当使用了缓冲区后，i 所存储的就是当前缓冲区数组中有元素的个数
				System.out.println(i);
			}
			// 记录读取结束时间
			long end = System.currentTimeMillis();
			System.out.println("文件读取结束！所需要的时间是：" + (end - begin));
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				in.close();
			} catch (IOException e2) {
				e2.printStackTrace();
			}
		}
	}
}

 输出流

package cn.ekgc.javasenior.day20210627;

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

public class FileOutputStreamDemo01 {
	public static void main(String[] args) {
		/*
		 * 对于输出字节流来说，其顶级的接口是 OutputStream。
		 * 其最基本的输出字节流就是 FileOutputStream
		 */
		// 设定所写出文件的路径
		String filePath = "D:\\李静平\\张涛\\礼金哈哈.txt";
		// 根据文件路径创建 File 对象
		File file = new File(filePath);
		// 创建 FileOutputStream 类型的变量
		FileOutputStream out = null;
		try {
			// 根据 File 对象创建 FileOutputStream
			out = new FileOutputStream(file);
			// 和读取文件数据不同，在写出文件数据时，可以一次性全部写出
			// 在写出数据时，写的也是字节
			byte[] messages = {65, 66, 67, 68, 69, 70};
			out.write(messages);
			System.out.println("数据写入文件成功！");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

package cn.ekgc.javasenior.day20210628;

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

public class InputStreamReaderDemo01 {
	public static void main(String[] args) {
		/*
		 * 对于字符流来说，其底层就是使用字节流来实现的，
		 * 当使用字符流读取字符的时候，首先还是按照字节进行读取，然后再根据字符的编码方案进行重新编码。
		 * 因此就可以借助于 InputStreamReader/OuputStreamWriter 将一个字节流变为一个字符流，
		 * 而且 InputStreamReader/OuputStreamWriter 在变幻是可以设置字符的编码方案
		 */
		// 使用 FileReader 读取文件中的字符
		// 设定所要读取的文件路劲
		String filePath = "C:\\Users\\Arthur\\Desktop\\过秦论.txt";
		// 通过文件路径，创建对应的 File 对象
		File file = new File(filePath);
		// 由于编码格式的不统一，因此会产生乱码，那么为了解决乱码，因此可以在读取的时候先按照字节流进行读取
		// 初始化 FileInputStream 和 InputStreamReader 变量
		FileInputStream fis = null;
		InputStreamReader isr = null;
		BufferedReader br = null;
		
		try {
			// 创建 FileInputStream 对象
			fis = new FileInputStream(file);
			// 通过 FileInputStream 对象创建 InputStreamReader 对象
			// 在创建该对象时，可以设置编码方案，也就是通过字节流读取到数据之后，然后再制定编码的方式
			isr = new InputStreamReader(fis, "GBK");
			// 获得 InputStreamReader 之后，为了方便操作，可以在其外面在套上 BufferedReader
			br = new BufferedReader(isr);
			String str;
			while ((str = br.readLine()) != null) {
				System.out.println(str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 fileread

package cn.ekgc.javasenior.day20210628;

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

public class FileReaderDemo01 {
	public static void main(String[] args) {
		/*
		 * 1、对于计算机来说，所有的数据都是一个字节一个字节组成的，
		 * 因此字节流可以处理任何数据信息，不仅仅包括音频、视频，同时也包括了字符。
		 * 2、但是对于人类来说，在所有的数据中，字符的数量占比是最大的，因此为了能够更加方便的
		 * 读取和写入字符，因此在字节流的基础之上，开发了字符流，字符流专门用于处理字符的读取和写出。
		 * 3、对于字符流来说，也就两个顶级接口：
		 * （1）字符输入流：Reader
		 * （2）字符输出流：Writer
		 * 4、字符流有连个最基本的实现类：
		 * （1）基础字符输入流：FileReader
		 * （2）基础字符输出流：FileWriter
		 */
		// 使用 FileReader 读取文件中的字符
		// 设定所要读取的文件路劲
		String filePath = "C:\\Users\\Arthur\\Desktop\\过秦论.txt";
		// 通过文件路径，创建对应的 File 对象
		File file = new File(filePath);
		// 初始化 FileReader 类型的变量
		FileReader reader = null;	
		try {
			// 根据 File 对象创建 FileReader 对象
			reader = new FileReader(file);
			// 要想读取文件中的数据，那么也是一个字符一个字符的读取
			// 使用 int 类型的变量 i 存储该字符的 Unicode 编码
			/*
			 * 字符编码的发展：
			 * 1、最早提出字符编码的方案就是 ASCII
			 * 所有的编码方案都基于 ASCII 方案。
			 * 2、当编码汉字时，发现 1 byte 所能够编的汉字过少，于是在 1988 中国推出双字节编码方案 GB2312
			 * 对于 GB2312 方案来说，能够实现常用的两万多个汉字的编码，这些汉字只包含简体字，没有编码繁体字。
			 * 3、随着大陆的变体字、繁体字的使用，那么原始的 GB2312 所编码的字符不再够用，
			 * 因此在 GB2312 的基础之上，诞生了 GBK 编码方案。因此基本上所有的中文编码都采用 GBK 编码
			 * 4、由于世界上会产生各种各样的编码方案，那么对于某一个二进制，在不同编码方案下，所对应的字符是不一样的。
			 * 因此由于不同的编码方案，在解释二进制时，就会产生混乱，这就是乱码现象。为了决绝乱码，于是提出了全球
			 * 进行统一编码，由此形成了 Unicode 编码方案。Unicode 又称为万国码。
			 * Unicode 编码方案不是一个具体的编码方案，而是一个编码意见或者是规范，类似于接口。
			 * 5、于是在 Unicode 编码方案的指导之下，将原来的定长编码的 Unicode 编程可变长度的编码方案，
			 * 于是就形成了 UTF-8 编码方案。
			 * 6、Java 的字符采用了 Unicode 编码方案，因此所读取的内容就是该字符的 Unicode 编码
			 */
			int i;
			while ((i = reader.read()) != -1) {
				System.out.println(i);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				reader.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 file 带缓冲区

package cn.ekgc.javasenior.day20210628;

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

public class FileReaderDemo02 {
	public static void main(String[] args) {
		// 使用 FileReader 读取文件中的字符
		// 设定所要读取的文件路劲
		String filePath = "C:\\Users\\Arthur\\Desktop\\过秦论.txt";
		// 通过文件路径，创建对应的 File 对象
		File file = new File(filePath);
		// 初始化 FileReader 类型的变量
		FileReader reader = null;
		
		try {
			// 根据 File 对象创建 FileReader 对象
			reader = new FileReader(file);
			// 要想读取文件中的数据，那么也是一个字符一个字符的读取
			// 由于在读取的时候，是一个字符一个字符的读取，效率较低，因此也可以使用缓冲区
			// 那么字符缓冲区是一个 char[]
			char[] buffers = new char[1024];
			// 使用 int 类型的变量 i 存储该字符的 Unicode 编码
			int i;
			while ((i = reader.read(buffers)) != -1) {
				// 此时的 i 就是 char[] 中有值的元素值
				System.out.println(i);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				reader.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 输出流

package cn.ekgc.javasenior.day20210628;

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

public class FileWriterDemo01 {
	public static void main(String[] args) {
		// 使用 FileWriter 实现字符的输出
		// 设定所需要写出的文件路径
		String filePath = "C:\\Users\\lenovo\\Desktop\\java 复习\\da.txt";
		// 根据文件路径创建对应的 File 对象
		File file = new File(filePath);
		// 初始化 FileWriter 类型的变量
		FileWriter writer = null;
		try {
			// 根据 File 对象创建 FileWriter 对象
			writer = new FileWriter(file);
			// FileWriter 来说，就可以直接写出 String 类型的数据
			String message = "ASCII ((American Standard Code for Information Interchange): 美国信息交换标准代码）"
					+ "是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。"
					+ "它是最通用的信息交换标准，并等同于国际标准ISO/IEC 646。"
					+ "ASCII第一次以规范标准的类型发表是在1967年，"
					+ "最后一次更新则是在1986年，到目前为止共定义了128个字符";
			// 使用 FileWriter 将信息写出
			writer.write(message);
			System.out.println("文件已写出！");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 对于字符输出流来说，其本质上在输出字符的时候，并不是将字符直接写入到文件中，
				// 而是将这些字符存储到缓冲区中，那么在所有的字符写完之后，需要强制将缓冲区中的字符写入到文件中。
				// 要想将字符输出流中的缓冲内容强制写到文件中，需要使用 flush() 方法
				writer.flush();
				// 对于字符输出流的 close() 来说，其内部会自动调用 flush()
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 bufferRead

package cn.ekgc.javasenior.day20210628;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class BufferReaderDemo01 {
	public static void main(String[] args) {
		/*
		 * 为了提高读取字符的效率，Java 提供了含有缓冲区的字符包装流就是 BufferReader
		 */
		// 创建所需要读取的文件路径
		String filePath = "C:\\Users\\Arthur\\Desktop\\西游记123.txt";
		// 根据文件路径创建 File 对象
		File file = new File(filePath);
		// 分别初始化 FileReader 和 BufferReader
		FileReader fr = null;
		BufferedReader br = null;
		
		try {
			// 根据 File 对象创建 FileReader 对象
			fr = new FileReader(file);
			// 当创建完毕基础流之后，才能够创建包装流
			br = new BufferedReader(fr);
			// 有了 BufferedReader 之后，就可以直接通过 BufferedReader 读取文件的字符
			// 对于 BufferedReader 可以一次性就读取一行文字
			String str;
			while ((str = br.readLine()) != null) {
				System.out.println(str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 对于含有包装流，可以只关闭包装流，那么其中的基本流也就跟着关闭了，
				// 也可以一个个进行关闭
				fr.close();
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 BufferRead

  package cn.ekgc.javasenior.day20210628;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class BufferedWriterDemo01 {
	public static void main(String[] args) {
		// 创建所需要写出文件的路径
		String path = "C:\\Users\\Arthur\\Desktop\\test.txt";
		// 根据文件路径创建 File 对象
		File file = new File(path);
		// 分别初始化 FileWriter 和 BufferedWriter 变量
		FileWriter fw = null;
		BufferedWriter bw = null;
		
		try {
			// 根据 File 对象创建 FileWriter 兑现
			// 在创建输出流的时候，默认是覆盖原来的文件内容，如果需要在原来的文件内容后面追加
			// 需要在构造方法的参数中增加一个 true，表示开启追加模式
			fw = new FileWriter(file, true);
			// 根据 FileWriter 对象创建 BufferedWriter 对象
			bw = new BufferedWriter(fw);
			// 实现通过控制台交互输入信息，写入到文件中
			// 创建 Scanner 对象
			Scanner input = new Scanner(System.in);
			System.out.println("请输入您的留言（输入 Q 表示退出）：");
			// 创建变量 message 用于存储信息
			String message = "";
			// 当将一个固定的字符串写在前面，可以规避空指针异常
			while (true) {
				// 进行输入
				message = input.next();
				if ("Q".equalsIgnoreCase(message)) {
					break;
				}
				bw.write(message);
				// 如果需要在输出的字符中实现换行，那么只需要执行 bw.newLine() 即可
				bw.newLine();
			}
			System.out.println("写出成功！");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 直接将包装流关闭
				bw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}