流动的是数据—用于传输数据的一套API—IO->Input和Output—输入流和输出流—当数据是从外部流向程序的时候，输入流；数据是从程序流向外部的时候，输出流。读取文件—将数据从文件读到程序中—输入流；向文件中写入数据—数据从程序流向了文件—输出流。

根据数据的传输方向：输入流、输出流
根据数据的传输形式：字节流、字符流

在这里插入图片描述
这四个基本流都是抽象类。
数据来源(目的地)：硬盘，网络，输入设备，内存

FileWriter

向txt文件写入一个字符串—输出流，字符流，和文件有关的流—FileWriter
FileWriter(String path)—创建一个新文件。如果文件不存在，会创建一个新文件。
FileWriter继承了OutputStreamWriter。

流操作的过程:
创建流→流出数据→冲刷缓冲区→关闭流。
最后将流对象赋值为null标记为一个垃圾对象。

构造函数:
①FileWriter(File file);
无论文件是否存在，都会创建一个新的文件覆盖原来的文件。
②FileWriter(File file,boolean append);
是否追加内容。如果存在目标文件，不会删除原文件。
③FileWriter(String fileName);
根据给定的文件名fileName构造一个对象。
④FileWriter(String fileName,boolean append);
判断是否追加数据。

重要方法:
①write(String s);
写入数据。
数据不是直接写到文件中个，而是先写到缓冲区，缓冲区满了之后，才会将数据挪到文件中。如果缓冲区没有满而程序已经结束了，那么数据就死在来缓冲区。

②flush();
冲刷缓冲区。

③close();
关流。为了释放文件。流在关闭之前会自动的冲刷一次缓冲区，以防有数据死在缓冲区中。流关闭了，流对象依然存在。

流中的异常处理

1.将流对象放在try外定义并且赋值为null，放在try中初始化
2.在关流之前需要判断流对象是否初始化成功
3.需要将流强制置为null以防关流失败产生数据丢失
4.需要在写完数据之后手动添加flush操作以防关流失败产生数据丢失

FileWriter fw = null;
		try {
	// 创建对象
			fw = new FileWriter("D:\\b.txt");
			fw.write("稻香村");
	// 尽量防止数据丢失
	// 因为可能关闭不成功，那么就不会冲刷缓冲区
			fw.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
	// 关闭资源
	// fw可能创建失败,会出现空指针异常
			if (fw!= null){
				try {
					fw.close();
				} catch (IOException e) {
	// TODO Auto-generated catch block
					e.printStackTrace();
				}finally{
	// 如果关闭成功，那么释放内存
	// 如果关闭失败，依然需要释放内存
					fw = null;
				}
			}
			
		}

FileReader

读取一个txt文件—输入流字符流和文件有关的流—FileReader，FileReader继承了InputStreamReader。是缓冲流的一个子类

流操作的过程
创建流→读取数据→关闭流
在输入流中没有缓冲区，可以自己指定缓冲区。

构造函数
①FileReader(File file);
读取给定的文件。
②FileReader(String fileName);
读取给定的文件名称的文件。

重要方法
①read();
每次只读取一个字符。返回值是一个int类型，表示的是这个字符对应的编码。

复制文件
import java.io.FileReader;
import java.io.FileWriter;
public class CopyFileDemo {
	public static void main(String[] args) {
		// 创建一个输入流指向要复制的文件
		FileReader reader = null;
		// 创建一个输出流指向要存储的文件
		FileWriter writer = null;
		try {
			reader = new FileReader("E:\\a.txt");
			writer = new FileWriter("F:\\a.txt");
			// 定义一个变量来记录读取的字符个数
			int i = -1;
			// 定义一个数组作为缓冲区使用
			char[] cs = new char[4];
			// 读取文件
			while ((i = reader.read(cs)) != -1) {
				// 将读取的数据写出
				writer.write(cs, 0, i);
			}
			// 需要手动冲刷缓冲区
			writer.flush();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					reader = null;
				}
			}
			if (writer != null) {
				try {
					writer.close();
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					writer = null;
				}
			}
		}
	}
}

缓冲流

BufferedReader

BufferedReader—需要传入字符输入流，真正读取数据的是传入的这个字符输入流，缓冲流仅仅提供了一个缓冲区。
继承了Reader
在读取文件的过程中，考虑到FileReader没有缓冲区，读取效率比较低，就利用bufferedReader包装上一层缓冲区。关闭的时候只关闭外层流即可，因为关闭外层流的时候，会自动关闭里层的流。也可以手动关闭，关闭顺序要从里往外关闭。

构造函数
①BufferedReader(Reader in);
使用默认大小输入缓冲区的缓冲字符输入流。
②BufferedReader(Reader in ,int sz)
创建一个使用指定大小输s入缓冲区的缓冲字符输入流。

重要方法
①readLine();
读取一行（以回车换行作为一行的结束），返回的是String类型。

BufferedWriter

用其他字符输出流来写出数据，提供来一个更大的缓冲区，同时提供来newLine();能够屏蔽不同系统之间换行的差异性。

构造函数
①BufferedWriter(Writer out);
②BufferedWriter(Writer out , int sz)

重要方法
①newLine();
换行。在不同的系统中，转换为对应的换行。

统计Java代码的行数
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class GetRowCountDemo {
	// 记录行数
	static int count = 0;
	public static void main(String[] args) {
		// 创建一个File对象指向工作空间
		File file = new File("E:\\workspace");
		count(file);
		System.out.println(count);
	}
	private static void count(File file) {
		// 判断file是否为空
		if (file == null) {
			throw new NullPointerException("亲，文件不能为空哦~~~");
		}
		// 判断是否是一个目录
		if (file.isDirectory()) {
			// 获取子文件和子目录
			File[] fs = file.listFiles();
			for (File f : fs) {
				count(f);
			}
		} else if (file.getName().endsWith(".java")) {
			// 统计代码行数---按行读取
			BufferedReader br = null;
			try {
				// 创建一个缓冲流指向要统计的文件
				br = new BufferedReader(new FileReader(file));
				// 按行读取
				while (br.readLine() != null) {
					count++;
				}
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				if (br != null) {
					try {
						br.close();
					} catch (Exception e) {
						e.printStackTrace();
					} finally {
						br = null;
					}
				}
			}
		}
	}
}

public class BufferedWriterDemo {
	public static void main(String[] args) throws IOException {
		// 创建对象  
		FileWriter fw = new FileWriter("D:\\c.txt");
		// 底层本质上还是使用FileWriter进行写入
		BufferedWriter bw = new BufferedWriter(fw);
		// 写入数据
		bw.write("你好，2019！");
		// 换行 会自动根据当前操作系统调整换行符
		bw.newLine();
		bw.write("你好，2019！");
		// 冲刷缓冲区
		bw.flush();
		
		// 关闭流
		bw.close();
		
		
	}
}

StringReader

读取字符串的流

字节流

以字节形式来读写文件。

FileOutputStream

FileOutputStream class 继承了OutputStream class。
创建一个字节流→写入数据→关流

构造函数
①FileOutputStream(File file);

②FileOutputStream(String name);

③FileOutputStream(String name,boolean append)

重要方法

未完待续…

来源：CSDN

作者：霄练

链接：https://blog.csdn.net/qq_34800986/article/details/103630366

标签

io流

IO流