Java IO流
 
前言
1 初识Java IO
1.1 IO流分类
1.2 案例实操
  
2 IO流对象
2.1 File类
2.2 字节流
2.3 字符流
2.4 序列化
  
3 IO流方法
3.1 字节流方法
3.2 字符流方法
  
4 附加内容
4.1 位、字节、字符
4.2 IO流效率对比
4.3 NIO
 

 
前言
 
 
 
有人曾问fastjson的作者（阿里技术专家高铁）：“你开发fastjson，没得到什么好处，反而挨了骂背了锅，这种事情你为什么要做呢？”
 
 
高铁答道：“因为热爱本身，就是奖励啊！”
 
 
这个回答顿时触动了我。想想自己，又何尝不是如此。写作是个痛苦的过程，用心写作就更加煎熬，需字字斟酌，反复删改才有所成。然而，当一篇篇精良文章出自己手而呈现眼前时，那些痛苦煎熬就都那么值得。如果这些博文能有幸得大家阅读和认可，就更加是莫大的鼓舞了。技术人的快乐就是可以这么纯粹和简单。
 
 
点波关注不迷路，一键三连好运连连！
 
IO流是Java中的一个重要构成部分，也是我们经常打交道的。这篇关于Java IO的博文干货满满，堪称全网前三（请轻喷！）
 
下面几个问题（问题还会继续补充），如果你能对答如流，那么恭喜你，IO知识掌握得很好，可以立即关闭文章。反之，你可以在后面得文章中寻找答案。
 
Java IO流有什么特点？
Java IO流分为几种类型？
字节流和字符流的关系与区别？
字符流是否使用了缓冲？
缓冲流的效率一定高吗？为什么？
缓冲流体现了Java中的哪种设计模式思想？
为什么要实现序列化?如何实现序列化?
序列化数据后，再次修改类文件，读取数据会出问题，如何解决呢?
 
1 初识Java IO
 
IO，即in和out，也就是输入和输出，指应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。
 
Java 中是通过流处理IO 的，那么什么是流？
 
流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。
 
当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。
 
一般来说关于流的特性有下面几点：
 
先进先出：最先写入输出流的数据最先被输入流读取到。
顺序存取：可以一个接一个地往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。（RandomAccessFile除外）
只读或只写：每个流只能是输入流或输出流的一种，不能同时具备两个功能，输入流只能进行读操作，对输出流只能进行写操作。在一个数据传输通道中，如果既要写入数据，又要读取数据，则要分别提供两个流。
 
1.1 IO流分类
 
IO流主要的分类方式有以下3种：
 
按数据流的方向：输入流、输出流
按处理数据单位：字节流、字符流
按功能：节点流、处理流
 
 
1、输入流与输出流
 
输入与输出是相对于应用程序而言的，比如文件读写，读取文件是输入流，写文件是输出流，这点很容易搞反。
 

 2、字节流与字符流
 
字节流和字符流的用法几乎完成全一样，区别在于字节流和字符流所操作的数据单元不同，字节流操作的单元是数据单元是8位的字节，字符流操作的是数据单元为16位的字符。
 
为什么要有字符流？
 
Java中字符是采用Unicode标准，Unicode 编码中，一个英文为一个字节，一个中文为两个字节。
 
 而在UTF-8编码中，一个中文字符是3个字节。例如下面图中，“云深不知处”5个中文对应的是15个字节：-28-70-111-26-73-79-28-72-115-25-97-91-27-92-124
 
 
那么问题来了，如果使用字节流处理中文，如果一次读写一个字符对应的字节数就不会有问题，一旦将一个字符对应的字节分裂开来，就会出现乱码了。为了更方便地处理中文这些字符，Java就推出了字符流。
 
字节流和字符流的其他区别：
 
字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件，如TXT文件等，但不能处理图像视频等非文本文件。用一句话说就是：字节流可以处理一切文件，而字符流只能处理纯文本文件。
字节流本身没有缓冲区，缓冲字节流相对于字节流，效率提升非常高。而字符流本身就带有缓冲区，缓冲字符流相对于字符流效率提升就不是那么大了。详见文末效率对比。
 
以写文件为例，我们查看字符流的源码，发现确实有利用到缓冲区：
 
 
 
3、节点流和处理流
 
节点流：直接操作数据读写的流类，比如FileInputStream
 
处理流：对一个已存在的流的链接和封装，通过对数据进行处理为程序提供功能强大、灵活的读写功能，例如BufferedInputStream（缓冲字节流）
 
处理流和节点流应用了Java的装饰者设计模式。
 
下图就很形象地描绘了节点流和处理流，处理流是对节点流的封装，最终的数据处理还是由节点流完成的。
 
 在诸多处理流中，有一个非常重要，那就是缓冲流。
 
我们知道，程序与磁盘的交互相对于内存运算是很慢的，容易成为程序的性能瓶颈。减少程序与磁盘的交互，是提升程序效率一种有效手段。缓冲流，就应用这种思路：普通流每次读写一个字节，而缓冲流在内存中设置一个缓存区，缓冲区先存储足够的待操作数据后，再与内存或磁盘进行交互。这样，在总数据量不变的情况下，通过提高每次交互的数据量，减少了交互次数。
 
 
联想一下生活中的例子，我们搬砖的时候，一块一块地往车上装肯定是很低效的。我们可以使用一个小推车，先把砖装到小推车上，再把这小推车推到车前，把砖装到车上。这个例子中，小推车可以视为缓冲区，小推车的存在，减少了我们装车次数，从而提高了效率。
 
 需要注意的是，缓冲流效率一定高吗？不一定，某些情形下，缓冲流效率反而更低，具体请见IO流效率对比。
 
完整的IO分类图如下：
 
 
1.2 案例实操
 
接下来，我们看看如何使用Java IO。
 
文本读写的例子，也就是文章开头所说的，将“松下问童子，言师采药去。只在此山中，云深不知处。”写入本地文本，然后再从文件读取内容并输出到控制台。
 
1、FileInputStream、FileOutputStream（字节流）
 
 
 
字节流的方式效率较低，不建议使用
 
 
public class IOTest {
	public static void main(String[] args) throws IOException {
		File file = new File("D:/test.txt");

		write(file);
		System.out.println(read(file));
	}

	public static void write(File file) throws IOException {
		OutputStream os = new FileOutputStream(file, true);

		// 要写入的字符串
		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
		// 写入文件
		os.write(string.getBytes());
		// 关闭流
		os.close();
	}

	public static String read(File file) throws IOException {
		InputStream in = new FileInputStream(file);

		// 一次性取多少个字节
		byte[] bytes = new byte[1024];
		// 用来接收读取的字节数组
		StringBuilder sb = new StringBuilder();
		// 读取到的字节数组长度，为-1时表示没有数据
		int length = 0;
		// 循环取数据
		while ((length = in.read(bytes)) != -1) {
			// 将读取的内容转换成字符串
			sb.append(new String(bytes, 0, length));
		}
		// 关闭流
		in.close();

		return sb.toString();
	}
}
 
2、BufferedInputStream、BufferedOutputStream（缓冲字节流）
 
 
 
缓冲字节流是为高效率而设计的，真正的读写操作还是靠FileOutputStream和FileInputStream，所以其构造方法入参是这两个类的对象也就不奇怪了。
 
 
public class IOTest {

	public static void write(File file) throws IOException {
		// 缓冲字节流，提高了效率
		BufferedOutputStream bis = new BufferedOutputStream(new FileOutputStream(file, true));

		// 要写入的字符串
		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
		// 写入文件
		bis.write(string.getBytes());
		// 关闭流
		bis.close();
	}

	public static String read(File file) throws IOException {
		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file));

		// 一次性取多少个字节
		byte[] bytes = new byte[1024];
		// 用来接收读取的字节数组
		StringBuilder sb = new StringBuilder();
		// 读取到的字节数组长度，为-1时表示没有数据
		int length = 0;
		// 循环取数据
		while ((length = fis.read(bytes)) != -1) {
			// 将读取的内容转换成字符串
			sb.append(new String(bytes, 0, length));
		}
		// 关闭流
		fis.close();

		return sb.toString();
	}
}
 
3、InputStreamReader、OutputStreamWriter（字符流）
 
 
 
字符流适用于文本文件的读写，OutputStreamWriter类其实也是借助FileOutputStream类实现的，故其构造方法是FileOutputStream的对象
 
 
public class IOTest {
	
	public static void write(File file) throws IOException {
		// OutputStreamWriter可以显示指定字符集，否则使用默认字符集
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8");

		// 要写入的字符串
		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
		osw.write(string);
		osw.close();
	}

	public static String read(File file) throws IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "UTF-8");
		// 字符数组：一次读取多少个字符
		char[] chars = new char[1024];
		// 每次读取的字符数组先append到StringBuilder中
		StringBuilder sb = new StringBuilder();
		// 读取到的字符数组长度，为-1时表示没有数据
		int length;
		// 循环取数据
		while ((length = isr.read(chars)) != -1) {
			// 将读取的内容转换成字符串
			sb.append(chars, 0, length);
		}
		// 关闭流
		isr.close();

		return sb.toString()
	}
}
 
4、字符流便捷类
 
 
 
Java提供了FileWriter和FileReader简化字符流的读写，new FileWriter等同于new OutputStreamWriter(new FileOutputStream(file, true))
 
 
public class IOTest {
	
	public static void write(File file) throws IOException {
		FileWriter fw = new FileWriter(file, true);

		// 要写入的字符串
		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
		fw.write(string);
		fw.close();
	}

	public static String read(File file) throws IOException {
		FileReader fr = new FileReader(file);
		// 一次性取多少个字节
		char[] chars = new char[1024];
		// 用来接收读取的字节数组
		StringBuilder sb = new StringBuilder();
		// 读取到的字节数组长度，为-1时表示没有数据
		int length;
		// 循环取数据
		while ((length = fr.read(chars)) != -1) {
			// 将读取的内容转换成字符串
			sb.append(chars, 0, length);
		}
		// 关闭流
		fr.close();

		return sb.toString();
	}
}
 
5、BufferedReader、BufferedWriter（字符缓冲流）
 
public class IOTest {
	
	public static void write(File file) throws IOException {
		// BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new
		// FileOutputStream(file, true), "UTF-8"));
		// FileWriter可以大幅度简化代码
		BufferedWriter bw = new BufferedWriter(new FileWriter(file, true));

		// 要写入的字符串
		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
		bw.write(string);
		bw.close();
	}

	public static String read(File file) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader(file));
		// 用来接收读取的字节数组
		StringBuilder sb = new StringBuilder();

		// 按行读数据
		String line;
		// 循环取数据
		while ((line = br.readLine()) != null) {
			// 将读取的内容转换成字符串
			sb.append(line);
		}
		// 关闭流
		br.close();

		return sb.toString();
	}
}
 
2 IO流对象
 
第一节中，我们大致了解了IO，并完成了几个案例，但对IO还缺乏更详细的认知，那么接下来我们就对Java IO细细分解，梳理出完整的知识体系来。
 
Java种提供了40多个类，我们只需要详细了解一下其中比较重要的就可以满足日常应用了。
 
2.1 File类
 
File类是用来操作文件的类，但它不能操作文件中的数据。
 
public class File extends Object implements Serializable, Comparable<File>
 
File类实现了Serializable、 Comparable<File>，说明它是支持序列化和排序的。
 
File类的构造方法
 
方法名
说明
File(File parent, String child)
根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
File(URI uri)
通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。
File类的常用方法
 
方法
说明
createNewFile()
当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
delete()
删除此抽象路径名表示的文件或目录。
exists()
测试此抽象路径名表示的文件或目录是否存在。
getAbsoluteFile()
返回此抽象路径名的绝对路径名形式。
getAbsolutePath()
返回此抽象路径名的绝对路径名字符串。
length()
返回由此抽象路径名表示的文件的长度。
mkdir()
创建此抽象路径名指定的目录。
File类使用实例
 
public class FileTest {
	public static void main(String[] args) throws IOException {
		File file = new File("C:/Mu/fileTest.txt");

		// 判断文件是否存在
		if (!file.exists()) {
			// 不存在则创建
			file.createNewFile();
		}
		System.out.println("文件的绝对路径：" + file.getAbsolutePath());
		System.out.println("文件的大小：" + file.length());

		// 刪除文件
		file.delete();
	}
}
 
2.2 字节流
 
InputStream与OutputStream是两个抽象类，是字节流的基类，所有具体的字节流实现类都是分别继承了这两个类。
 
以InputStream为例，它继承了Object，实现了Closeable
 
public abstract class InputStream
extends Object
implements Closeable
 
InputStream类有很多的实现子类，下面列举了一些比较常用的：
 
 详细说明一下上图中的类：
 
InputStream：InputStream是所有字节输入流的抽象基类，前面说过抽象类不能被实例化，实际上是作为模板而存在的，为所有实现类定义了处理输入流的方法。
FileInputSream：文件输入流，一个非常重要的字节输入流，用于对文件进行读取操作。
PipedInputStream：管道字节输入流，能实现多线程间的管道通信。
ByteArrayInputStream：字节数组输入流，从字节数组(byte[])中进行以字节为单位的读取，也就是将资源文件都以字节的形式存入到该类中的字节数组中去。
FilterInputStream：装饰者类，具体的装饰者继承该类，这些类都是处理类，作用是对节点类进行封装，实现一些特殊功能。
DataInputStream：数据输入流，它是用来装饰其它输入流，作用是“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。
BufferedInputStream：缓冲流，对节点流进行装饰，内部会有一个缓存区，用来存放字节，每次都是将缓存区存满然后发送，而不是一个字节或两个字节这样发送，效率更高。
ObjectInputStream：对象输入流，用来提供对基本数据或对象的持久存储。通俗点说，也就是能直接传输对象，通常应用在反序列化中。它也是一种处理流，构造器的入参是一个InputStream的实例对象。
 
OutputStream类继承关系图：
 
 
OutputStream类继承关系与InputStream类似，需要注意的是PrintStream.
 
2.3 字符流
 
与字节流类似，字符流也有两个抽象基类，分别是Reader和Writer。其他的字符流实现类都是继承了这两个类。
 
以Reader为例，它的主要实现子类如下图：
 
 各个类的详细说明：
 
InputStreamReader：从字节流到字符流的桥梁（InputStreamReader构造器入参是FileInputStream的实例对象），它读取字节并使用指定的字符集将其解码为字符。它使用的字符集可以通过名称指定，也可以显式给定，或者可以接受平台的默认字符集。
BufferedReader：从字符输入流中读取文本，设置一个缓冲区来提高效率。BufferedReader是对InputStreamReader的封装，前者构造器的入参就是后者的一个实例对象。
FileReader：用于读取字符文件的便利类，new FileReader(File file)等同于new InputStreamReader(new FileInputStream(file, true),"UTF-8")，但FileReader不能指定字符编码和默认字节缓冲区大小。
PipedReader ：管道字符输入流。实现多线程间的管道通信。
CharArrayReader：从Char数组中读取数据的介质流。
StringReader ：从String中读取数据的介质流。
 
Writer与Reader结构类似，方向相反，不再赘述。唯一有区别的是，Writer的子类PrintWriter。
 
2.4 序列化
 
待续…
 
3 IO流方法
 
3.1 字节流方法
 
字节输入流InputStream主要方法：
 
read() ：从此输入流中读取一个数据字节。
read(byte[] b) ：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
read(byte[] b, int off, int len) ：从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
close()：关闭此输入流并释放与该流关联的所有系统资源。
 
字节输出流OutputStream主要方法：
 
write(byte[] b) ：将 b.length 个字节从指定 byte 数组写入此文件输出流中。
write(byte[] b, int off, int len) ：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
write(int b) ：将指定字节写入此文件输出流。
close() ：关闭此输入流并释放与该流关联的所有系统资源。
 
3.2 字符流方法
 
字符输入流Reader主要方法：
 
read()：读取单个字符。
read(char[] cbuf) ：将字符读入数组。
read(char[] cbuf, int off, int len) ： 将字符读入数组的某一部分。
read(CharBuffer target) ：试图将字符读入指定的字符缓冲区。
flush() ：刷新该流的缓冲。
close() ：关闭此流，但要先刷新它。
 
字符输出流Writer主要方法：
 
write(char[] cbuf) ：写入字符数组。
write(char[] cbuf, int off, int len) ：写入字符数组的某一部分。
write(int c) ：写入单个字符。
write(String str) ：写入字符串。
write(String str, int off, int len) ：写入字符串的某一部分。
flush() ：刷新该流的缓冲。
close() ：关闭此流，但要先刷新它。
 
另外，字符缓冲流还有两个独特的方法：
 
BufferedWriter类newLine() ：写入一个行分隔符。这个方法会自动适配所在系统的行分隔符。
BufferedReader类readLine() ：读取一个文本行。
 
4 附加内容
 
4.1 位、字节、字符
 
字节(Byte)是计量单位，表示数据量多少，是计算机信息技术用于计量存储容量的一种计量单位，通常情况下一字节等于八位。
 
字符(Character)计算机中使用的字母、数字、字和符号，比如’A’、‘B’、’$’、’&'等。
 
一般在英文状态下一个字母或字符占用一个字节，一个汉字用两个字节表示。
 
字节与字符：
 
ASCII 码中，一个英文字母（不分大小写）为一个字节，一个中文汉字为两个字节。
UTF-8 编码中，一个英文字为一个字节，一个中文为三个字节。
Unicode 编码中，一个英文为一个字节，一个中文为两个字节。
符号：英文标点为一个字节，中文标点为两个字节。例如：英文句号 . 占1个字节的大小，中文句号 。占2个字节的大小。
UTF-16 编码中，一个英文字母字符或一个汉字字符存储都需要 2 个字节（Unicode 扩展区的一些汉字存储需要 4 个字节）。
UTF-32 编码中，世界上任何字符的存储都需要 4 个字节。
 
4.2 IO流效率对比
 
首先，对比下普通字节流和缓冲字节流的效率：
 
public class MyTest {
	public static void main(String[] args) throws IOException {
		File file = new File("C:/Mu/test.txt");
		StringBuilder sb = new StringBuilder();

		for (int i = 0; i < 3000000; i++) {
			sb.append("abcdefghigklmnopqrstuvwsyz");
		}
		byte[] bytes = sb.toString().getBytes();

		long start = System.currentTimeMillis();
		write(file, bytes);
		long end = System.currentTimeMillis();

		long start2 = System.currentTimeMillis();
		bufferedWrite(file, bytes);
		long end2 = System.currentTimeMillis();

		System.out.println("普通字节流耗时：" + (end - start) + " ms");
		System.out.println("缓冲字节流耗时：" + (end2 - start2) + " ms");

	}

	// 普通字节流
	public static void write(File file, byte[] bytes) throws IOException {
		OutputStream os = new FileOutputStream(file);
		os.write(bytes);
		os.close();
	}

	// 缓冲字节流
	public static void bufferedWrite(File file, byte[] bytes) throws IOException {
		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(file));
		bo.write(bytes);
		bo.close();
	}
}
 
运行结果：
 
普通字节流耗时：250 ms
缓冲字节流耗时：268 ms
 
这个结果让我大跌眼镜，不是说好缓冲流效率很高么？要知道为什么，只能去源码里找答案了。翻看字节缓冲流的write方法：
 
public synchronized void write(byte b[], int off, int len) throws IOException {
    if (len >= buf.length) {
        /* If the request length exceeds the size of the output buffer,
           flush the output buffer and then write the data directly.
           In this way buffered streams will cascade harmlessly. */
        flushBuffer();
        out.write(b, off, len);
        return;
    }
    if (len > buf.length - count) {
        flushBuffer();
    }
    System.arraycopy(b, off, buf, count, len);
    count += len;
}
 
注释里说得很明白：如果请求长度超过输出缓冲区的大小，刷新输出缓冲区，然后直接写入数据。这样，缓冲流将无害地级联。
 
但是，至于为什么这么设计，我没有想明白，有哪位明白的大佬可以留言指点一下。
 
基于上面的情形，要想对比普通字节流和缓冲字节流的效率差距，就要避免直接读写较长的字符串，于是，设计了下面这个对比案例：用字节流和缓冲字节流分别复制文件。
 
public class MyTest {
	public static void main(String[] args) throws IOException {
		File data = new File("C:/Mu/data.zip");
		File a = new File("C:/Mu/a.zip");
		File b = new File("C:/Mu/b.zip");

		StringBuilder sb = new StringBuilder();

		long start = System.currentTimeMillis();
		copy(data, a);
		long end = System.currentTimeMillis();

		long start2 = System.currentTimeMillis();
		bufferedCopy(data, b);
		long end2 = System.currentTimeMillis();

		System.out.println("普通字节流耗时：" + (end - start) + " ms");
		System.out.println("缓冲字节流耗时：" + (end2 - start2) + " ms");
	}

	// 普通字节流
	public static void copy(File in, File out) throws IOException {
		// 封装数据源
		InputStream is = new FileInputStream(in);
		// 封装目的地
		OutputStream os = new FileOutputStream(out);
		
		int by = 0;
		while ((by = is.read()) != -1) {
			os.write(by);
		}
		is.close();
		os.close();
	}

	// 缓冲字节流
	public static void bufferedCopy(File in, File out) throws IOException {
		// 封装数据源
		BufferedInputStream bi = new BufferedInputStream(new FileInputStream(in));
		// 封装目的地
		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(out));
		
		int by = 0;
		while ((by = bi.read()) != -1) {
			bo.write(by);
		}
		bo.close();
		bi.close();
	}
}
 
运行结果：
 
普通字节流耗时：184867 ms
缓冲字节流耗时：752 ms
 
这次，普通字节流和缓冲字节流的效率差异就很明显了，达到了245倍。
 
再看看字符流和缓冲字符流的效率对比：
 
public class IOTest {
	public static void main(String[] args) throws IOException {
		// 数据准备
		dataReady();

		File data = new File("C:/Mu/data.txt");
		File a = new File("C:/Mu/a.txt");
		File b = new File("C:/Mu/b.txt");
		File c = new File("C:/Mu/c.txt");

		long start = System.currentTimeMillis();
		copy(data, a);
		long end = System.currentTimeMillis();

		long start2 = System.currentTimeMillis();
		copyChars(data, b);
		long end2 = System.currentTimeMillis();

		long start3 = System.currentTimeMillis();
		bufferedCopy(data, c);
		long end3 = System.currentTimeMillis();

		System.out.println("普通字节流1耗时：" + (end - start) + " ms,文件大小：" + a.length() / 1024 + " kb");
		System.out.println("普通字节流2耗时：" + (end2 - start2) + " ms,文件大小：" + b.length() / 1024 + " kb");
		System.out.println("缓冲字节流耗时：" + (end3 - start3) + " ms,文件大小：" + c.length() / 1024 + " kb");
	}

	// 普通字符流不使用数组
	public static void copy(File in, File out) throws IOException {
		Reader reader = new FileReader(in);
		Writer writer = new FileWriter(out);

		int ch = 0;
		while ((ch = reader.read()) != -1) {
			writer.write((char) ch);
		}
		reader.close();
		writer.close();
	}

	// 普通字符流使用字符流
	public static void copyChars(File in, File out) throws IOException {
		Reader reader = new FileReader(in);
		Writer writer = new FileWriter(out);

		char[] chs = new char[1024];
		while ((reader.read(chs)) != -1) {
			writer.write(chs);
		}
		reader.close();
		writer.close();
	}

	// 缓冲字符流
	public static void bufferedCopy(File in, File out) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader(in));
		BufferedWriter bw = new BufferedWriter(new FileWriter(out));

		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// 释放资源
		bw.close();
		br.close();
	}

	// 数据准备
	public static void dataReady() throws IOException {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 600000; i++) {
			sb.append("abcdefghijklmnopqrstuvwxyz");
		}
		OutputStream os = new FileOutputStream(new File("C:/Mu/data.txt"));
		os.write(sb.toString().getBytes());

		os.close();
		System.out.println("完毕");
	}
}
 
运行结果：
 
普通字符流1耗时：1337 ms,文件大小：15234 kb
普通字符流2耗时：82 ms,文件大小：15235 kb
缓冲字符流耗时：205 ms,文件大小：15234 kb
 
测试多次，结果差不多，可见字符缓冲流效率上并没有明显提高，我们更多的是要使用它的readLine()和newLine()方法。
 
4.3 NIO
 
待续…

IO简介
 
1 流Stream
 
在学习IO流之前,我们首先需要学习的概念就是Stream流
 为了方便理解,我们可以把数据的读写操作抽象成数据在"管道"中流动,但需注意:
 1.流只能单方向流动
 2.输入流用来读取 → in
 3.输出流用来写出 → out
 4.数据只能从头到尾顺序的读写一次
 所以以程序的角度来思考,In/out 相对于程序而言的输入(读取)/输出(写出)的过程.
 
 
2 IO流的继承结构
 
在java中,根据处理的数据单位不同,可以把流分为字节流和字符流
 字节流 : 针对二进制文件
 字符流 : 针对文本文件
 再结合对应类型的输入和输出方向,常用的流有:
 
 
 
File
 
 
字节流:针对二进制文件
 
 
InputStream
 
 
FileInputStream
 
 
BufferedInputStream
 
 
ObjectInputStream
 
 
OutputStream
 
 
FileOutputStream
 
 
BufferedOutputStream
 
 
ObjectOutputStream
 
 
字符流:针对文本文件
 
 
Reader
 
 
FileReader
 
 
BufferedReader
 
 
InputStreamReader
 
 
Writer
 
 
FileWriter
 
 
BufferedWriter
 
 
OutputStreamWriter
 
 
PrintWriter一行行写出
 
 
3 File文件类
 
3.1概述
 
封装一个磁盘路径字符串,对这个路径可以执行一次操作
 可以封装文件路径、文件夹路径、不存在的路径
 
3.2创建对象
 
File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例
 new File(“d:/abc/a.txt”);
 new File(“d:/abc”,”a.txt”);
 
3.3常用方法
 
 
3.4 练习：测试常用方法
 
创建包: cn.tedu.file
 创建类: TestFile.java
 
package cn.tedu.file;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

/*本类用于测试文件类File*/
public class TestFile {
    public static void main(String[] args) throws IOException {
        //1.创建File类对象
        /*1.ready目录与1.txt需要自己手动创建
        * 2.File需要导包：import java.io.File;
        * 3.路径是String类型，必须写正确，不然找不到文件
        * 4.完整的文件名包含两部分：文件名+后缀名*/
        File file = new File("E:\\ready\\1.txt");

        //2.1测试File中的常用方法
        System.out.println(file.length());//3，获取文件的字节量
        System.out.println(file.exists());//true,判断文件是否存在
        System.out.println(file.isFile());//true,判断是否为文件
        System.out.println(file.isDirectory());//false，判断是否为文件夹
        System.out.println(file.getName());//1.txt获取文件名
        System.out.println(file.getParent());//E:\ready 获取父级路径
        System.out.println(file.getAbsolutePath());//E:\ready\1.txt 获取带盘符的完整路径：绝对路径

        //2.2 测试创建与删除
        /*new 只会帮你在内存中创建一个File类型的对象
        * 并不会帮你在磁盘中创建一个真实存在的2.txt文件*/
        file = new File("E:\\ready\\2.txt");

        //创建一个之前不存在的文件2.txt,如果创建成功，会返回true
        /*如果指定创建文件的路径不对，会抛出异常：java.io.Exception
        * 所以需要提前处理这个问题，我们暂时选择在main()上抛出
        * 这个IO异常是目前我们遇到的强制要求必须预先处理的异常
        * 如果不处理，方法的调用会报错，通不过编译*/
        System.out.println(file.createNewFile());//创建之前不存在的文件

        file = new File("E:\\ready\\m");
        System.out.println(file.mkdir());//创建之前不存在的单层文件夹

        file = new File("E:\\ready\\a\\b\\c");
        System.out.println(file.mkdirs());//创建之前不存在的多层文件夹

        System.out.println(file.delete());//c被删除，删除空文件夹或者文件

        file = new File("E:\\ready\\a");
        System.out.println(file.delete());//false,a文件夹不是空的，里面有内容

        file = new File("E:\\ready\\2.txt");
        System.out.println(file.delete());//2.txt被删除，可以删除文件

        //2.3测试展示文件列表
        file = new File("E:\\ready");
        String[] list = file.list();/*不常用*/
        System.out.println(Arrays.toString(list));
        //这句话会报错，因为这是一个String[],所以数组中每个元素都是String类型的
        //那么只能用String类中的方法，而isDirectory()是File类中的方法
        //System.out.println(list[0].isDirectory());

        File[] fs = file.listFiles();/*常用*/
        System.out.println(Arrays.toString(fs));
        System.out.println(fs[0].isDirectory());
    }
}
 
4 字节流读取
 
字节流是由字节组成的,字符流是由字符组成的.
 Java里字符由两个字节组成.字节流是基本流，主要用在处理二进制数据。
 所以字节流是比较常用的，可以可以处理多种不同种类的文件，比如文本文档/音频/视频等等
 
4.1 InputStream抽象类
 
此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象哦
 
 
 
常用方法：
 abstract int read() 从输入流中读取数据的下一个字节
 int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
 int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
 void close() 关闭此输入流并释放与该流关联的所有系统资源
 
 
4.2 FileInputStream子类
 
直接插在文件上，直接读取文件数据
 
 
 
创建对象
 FileInputStream(File file)—直接传文件对象
 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定FileInputStream(String pathname)—传路径
 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定
 
 
4.3 BufferedInputStream子类
 
BufferedInputStream 为另一个输入流添加一些功能，在创建BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
 
 
 
创建对象
 BufferedInputStream(InputStream in)
 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
 
 
4.4 练习：字节流读取案例
 
创建包: cn.tedu.file
 创建类: TestIn.java
 
package cn.tedu.file;

import java.io.*;

/*本类用于练习字节输入流*/
public class TestIn {
    public static void main(String[] args) {
        //method();//字节流的读取
        method2();//高效字节流的读取
    }

    //本方法用于测试高效字节流的读取
    private static void method2() {
        //定义一个在本方法中都生效的局部变量in,注意手动初始化，值为null
        InputStream in = null;
        try {
            //1.创建高效字节输入流对象
//            InputStream in = new BufferedInputStream(
//                    new FileInputStream(new File("E:\\ready\\1.txt")));
              in = new BufferedInputStream
                      (new FileInputStream("E:\\ready\\1.txt"));
            //2.使用流进行读取
            int b;
            while ((b= in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {//关流操作写在finally{}中
            //3.流用完以后一定要关闭！！！
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

    //本方法用于测试字节流的读取
    private static void method() {
        //创建一个在本方法都生效的局部变量注意手动初始化
        InputStream in = null;
        try {
            //1.创建字节输入流对象用于读取
            //InputStream in = new InputStream();//报错原因：抽象类不可实例化
            //InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
            in = new FileInputStream("E:\\ready\\1.txt");
            //2.开始读取
            /*read()每次调用都会读取一个字节，如果读到了数据的末尾，返回-1*/
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
            //需求：需要循环读取文件中的所有内容，直至读完
            //定义变量，记录读到的数据
            int b;
            while((b=in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();//打印错误信息
        /*try-catch结构中的第三个部分：finally{}
        * 这部分不论是否捕获到异常，是一定会被执行到的代码，常用于关流*/
        }finally {
            try {
                //3.释放资源，流资源用完必须释放！！！
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 
5 字符流读取
 
常用于处理纯文本数据,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8
 
5.1 Reader抽象类
 
用于读取字符流的抽象类。
 
 
 
常用方法：
 int read() 读取单个字符
 int read(char[] cbuf) 将字符读入数组
 abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分
 int read(CharBuffer target) 试图将字符读入指定的字符缓冲区
 abstract void close() 关闭该流并释放与之关联的所有资源
 
 
5.2 FileReader子类
 
用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
 
 
 
创建对象
 FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
 FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader
 
 
5.3 BufferedReader子类
 
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
 
 
 
创建对象
 BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流
 
 
5.4 练习：字符流读取案例
 
创建包: cn.tedu.file
 创建类: TestIn2.java
 
package cn.tedu.file;

import java.io.*;

/*本类用于测试字符流的读取*/
public class TestIn2 {
    public static void main(String[] args) {
        //method();//测试普通字符输入流
        method2();//测试高效字符输入流
    }
    //创建一个用于测试高效字符输入流的方法
    private static void method2() {
        //1.定义一个在本方法都生效的局部变量，手动初始化值null
        Reader in=null;
        try{
            //1.创建高效字符读取流对象
            //in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));
            in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));
            //2.使用流对象
            int b;
            while((b=in.read())!=-1){
                System.out.println(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //3.关闭流对象
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //创建一个用于测试普通字符输入流的方法
    private static void method() {
        //1.1创建一个在本方法中都生效的局部变量，注意初始化值null
        Reader in = null;
        try {
            //1.2创建字符输入流对象，注意需要捕获异常
            //Reader in = new Reader();//报错原因：抽象父级不可实例化
            //in = new FileReader(new File("E:\\ready\\1.txt"));
            in = new FileReader("E:\\ready\\1.txt");
            //2.使用流对象
            //System.out.println(in.read());
            //需求：循环读取文件中的所有内容，只要不是-1，就说明还有数据，继续读取
            //3.1定义变量，记录读取到的数据
            int b;
            while((b = in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {//3.关流
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 
6 字节流写出
 
6.1 OutputStream抽象类
 
此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.
 
 
 
常用方法:
 Void close() 关闭此输出流并释放与此流相关的所有系统资源
 Void flush() 刷新此输出流并强制写出所有缓冲的输出字节
 Void write(byte[ ] b) 将b.length个字节从指定的byte数组写入此输出流
 Void write(byte[ ] b,int off ,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流
 Abstract void write(int b) 将指定的字节写入此输出流
 
 
6.2 FileOutputStream 子类
 
直接插在文件上,直接写出文件数据
 
 
 
构造方法(创建对象):
 FileOutputStream(String name)
 创建一个向具有指定名称的文件中写入数据的文件输出流
 FileOutStream(File file)
 创建一个向指定File对象表示的文件中写入数据的文件输出流
 FileOutStream(File file,boolean append)—如果第二个参数为true,表示追加,不覆盖
 创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容
 
 
6.3 BufferedOutputstream 子类
 
该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统
 
 
 
构造方法(创建对象):
 BufferedOutputStream(OutputStream out)
 创建一个新的缓冲输出流,用以将数据写入指定的底层输出流
 
 
6.4 练习: 字节输出流测试:
 
创建包: cn.tedu.file
 创建类: TestOut.java
 
package cn.tedu.file;

import java.io.*;

/*本类用于测试字节输出流*/
public class TestOut {
    public static void main(String[] args) {
        method();//用于测试普通字节输出流
        //method2();//用于测试高效字节输出流
    }
    //创建一个用于测试高效字节输出流的方法
    private static void method2() {
        //1.创建一个在本方法都生效的局部变量，注意手动初始化
        OutputStream out = null;
        try{
            //2.创建高效字节输出流对象
//          out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
            out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
            //3.使用流对象--进行写出操作
            out.write(97);
            out.write(97);
            out.write(97);
        }catch (Exception e){
            e.printStackTrace();
        }finally {//关流操作要放在finally{}中
            try {
                //4.关流
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //创建一个用于测试普通字节输出流的方法
    private static void method() {
        //1.创建一个在本方法中都生效的局部变量，注意手动初始化null
        OutputStream out = null;
        //2.创建try-catch-finally结构，因为IO操作可能会产生异常
        try{
            //3.创建普通字节输出流对象
            //out = new FileOutputStream(new File("E:\\ready\\2.txt"));
            //out = new FileOutputStream("E:\\ready\\2.txt");
            out = new FileOutputStream("E:\\ready\\2.txt",true);
            //4.使用流对象--进行写出操作
            out.write(99);//对应ASCII码表中的a
            out.write(99);//对应ASCII码表中的b
            out.write(99);//对应ASCII码表中的c
        }catch (Exception e){
            e.printStackTrace();
        }finally {//如果想要代码一定会执行，需要写在finally中
            try {
                //5.关流操作
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 
7 字符流写出
 
7.1 Writer 抽象类
 
写入字符流的抽象类
 
 
 
常用方法:
 Abstract void close() 关闭此流,但要先刷新它
 Void write(char[ ] cbuf) 写入字符数组
 Void write(int c) 写入单个字符
 Void write(String str) 写入字符串
 Void write(String str,int off,int len) 写入字符串的某一部分
 Abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分
 
 
7.2 FileWriter 子类
 
用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.
 
 
 
构造方法(创建对象):
 FileWriter(String filename)
 根据给定的文件名构造一个FileWriter对象
 FileWriter(String filename,boolean append)
 根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter
 
 
7.3 BufferedWriter子类
 
将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了
 
 
 
构造方法(创建对象):
 BufferedWriter(Writer out)
 创建一个使用默认大小输出缓冲区的缓冲字符输出流
 
 
7.4 练习: 字符输出流测试:
 
创建包: cn.tedu.file
 创建类: TestOut2.java
 
package cn.tedu.file;

import java.io.*;

/*本类用于测试字符输出流*/
public class TestOut2 {
    public static void main(String[] args) {
        //method();//用于测试普通字符输出流
        method2();//用于测试高效字符输出流
    }
    //创建一个用于测试高效字符输出流的方法
    private static void method2() {
        //1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！
        Writer out = null;
        //2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构
        try{//存放可能会抛出异常的代码
            //3.创建普通字符输出流对象
            //out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));
            //out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));
            out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));
            //4.使用流对象
            out.write(100);
            out.write(100);
            out.write(100);
            out.write(100);
            out.write(100);
        }catch (Exception e){//匹配并捕获异常
            e.printStackTrace();//如果捕获到异常就打印错误信息
        }finally {//一定会被执行到的代码块，常用于关流
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //创建一个用于测试普通字符输出流的方法
    private static void method() {
        //1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！
        Writer out = null;
        //2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构
        try{//存放可能会抛出异常的代码
            //3.创建普通字符输出流对象
            //out = new FileWriter(new File("E:\\ready\\2.txt"));
            //out = new FileWriter("E:\\ready\\2.txt");
            out = new FileWriter("E:\\ready\\2.txt",true);
            //4.使用流对象
            out.write(98);
            out.write(98);
            out.write(98);
            out.write(98);
        }catch (Exception e){//匹配并捕获异常
            e.printStackTrace();//如果捕获到异常就打印错误信息
        }finally {//一定会被执行到的代码块，常用于关流
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 
8 拓展
 
通过学习以上的几种流,我们也可以拓展尝试做下文件的复制:
 创建包: cn.tedu.file
 创建类: TestCopyFile.java
 
package cn.tedu.file;

import java.io.*;
import java.util.Scanner;

/*本类用于练习文件复制综合案例*/
public class TestCopyFile {
    public static void main(String[] args) {
        //1.提示并接收用户输入的两个路径
        System.out.println("请输入源文件路径");//--被复制的那个文件
        String f = new Scanner(System.in).nextLine();
        System.out.println("请输入新文件路径：");//--复制好的新文件
        String t = new Scanner(System.in).nextLine();

        //2.调用创建好的自定义方法完成文件复制
        //ZFCopy(f,t);//用字符流完成文件的复制案例
        ZJCopy(f,t);//用字节流完成文件的复制案例
    }
    //利用字节流完成文件复制案例
    private static void ZJCopy(String f, String t) {
        //1.定义在整个方法都生效的局部变量，注意手动初始化，引用类型默认值为null
        InputStream in = null;
        OutputStream out = null;
        //2.由于代码可能会发生异常，所以需要编写try-catch-finally结构
        try{
            //3.1创建高效字节输入流对象--FIS的参数是用户传入的源文件路径f
            in = new BufferedInputStream(new FileInputStream(f));
            //3.2创建高效字节输出流对象--FOS的参数是用户传入的新文件路径t
            out = new BufferedOutputStream(new FileOutputStream(t));

            //4.利用创建好的流对象完成业务
            //4.1定义变量用来保存读到的数据
            int b;
            //4.2循环读取源文件中的数据，只要不是-1，说明还有数据循环继续
            while((b = in.read()) != -1){
                //4.3将读到的数据写入到新文件中
                out.write(b);
            }
            System.out.println("恭喜您！文件复制成功！");
        }catch (Exception e){
            System.out.println("很抱歉！文件复制失败！");
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //利用字符流完成文件复制案例
    private static void ZFCopy(String f, String t) {
        //1.定义在整个方法中都生效的局部变量，注意手动初始化，默认值为null
        Reader in = null;
        Writer out = null;
        //2.由于代码可能会发生异常，所以需要编写try-catch-finally结构
        try{
            //3.1创建高效字符输入流对象
            in = new BufferedReader(new FileReader(f));
            //3.2创建高效字符输出流对象
            out = new BufferedWriter(new FileWriter(t));

            //4.拿到流对象以后，就可以使用流对象来完成业务了
            //4.1定义变量用来保存读到的数据
            int b;
            //4.2循环读取源文件，直到返回值为-1，说明没有数据了，再结束循环
            while ((b=in.read())!=-1) {
                //4.3将本轮循环中读到的数据写入到新文件中
                out.write(b);
            }
            System.out.println("恭喜您！文件复制成功！");
        }catch (Exception e){
            System.out.println("很抱歉！文件复制失败！");
            e.printStackTrace();
        }finally {
            /*关流是有顺序的：如果有多个流，最后创建的流最先关闭
            * 多条关流语句需要各自try-catch*/
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}


 
9 总结:IO的继承结构
 
1.主流分类
 
按照方向进行分类:输入流 输出流(相对于程序而言,从程序写数据到文件中是输出)
按照传输类型进行分类:字节流 字符流
组合: 字节输入流 字节输出流 字符输入流 字符输出流
 
2.学习方法:在抽象父类中学习通用的方法,在子类中学习如何创建对象
 3.字节输入流:
 
InputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
 
--FileInputStream 子类,操作文件的字节输入流,普通类
--BufferedInputStream 子类,缓冲字节输入流,普通类
 
4.字符输入流
 
Reader 抽象类,不能new,可以作为超类,学习其所提供的共性方法
 
--FileReader,子类,操作文件的字符输入流,普通类
--BufferedReader,子类,缓冲字符输入流,普通类
 
5.字节输出流:
 
OutputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
 
--FileOutputStream 子类,操作文件的字节输出流,普通类
--BufferedOutputStream 子类,缓冲字节输出流,普通类
 
6.字符输出流
 
Writer 抽象类,不能new,可以作为超类,学习其所提供的共性方法
 
--FileWriter,子类,操作文件的字符输出流,普通类
--BufferedWriter,子类,缓冲字符输出流,普通类

字符流与字节流的区别
 
（尊重劳动成果，转载请注明出处：https://blog.csdn.net/cynhafa/article/details/6882061 )
 字节流与和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？
 
实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如下图所示。
 
 下面以两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。
 
范例：使用字节流不关闭执行
 
package org.lxh.demo12.byteiodemo;    
import java.io.File;    
import java.io.FileOutputStream;    
import java.io.OutputStream;    
public class OutputStreamDemo05 {    
public static void main(String[] args) throws Exception {   // 异常抛出，  不处理    
// 第1步：使用File类找到一个文件    
     File f = new File("d:" + File.separator + "test.txt"); // 声明File  对象    
// 第2步：通过子类实例化父类对象    
     OutputStream out = null;            
// 准备好一个输出的对象    
     out = new FileOutputStream(f);      
// 通过对象多态性进行实例化    
// 第3步：进行写操作    
     String str = "Hello World!!!";      
// 准备一个字符串    
     byte b[] = str.getBytes();          
// 字符串转byte数组    
     out.write(b);                      
// 将内容输出    
 // 第4步：关闭输出流    
    // out.close();                  
// 此时没有关闭    
        }    
    } 
 
程序运行结果：
 
 此时没有关闭字节流操作，但是文件中也依然存在了输出的内容，证明字节流是直接操作文件本身的。而下面继续使用字符流完成，再观察效果。
 
范例：使用字符流不关闭执行
 
package org.lxh.demo12.chariodemo;    
import java.io.File;    
import java.io.FileWriter;    
import java.io.Writer;    
public class WriterDemo03 {    
    public static void main(String[] args) throws Exception { // 异常抛出，  不处理    
        // 第1步：使用File类找到一个文件    
        File f = new File("d:" + File.separator + "test.txt");// 声明File 对象    
        // 第2步：通过子类实例化父类对象    
        Writer out = null;                 
// 准备好一个输出的对象    
        out = new FileWriter(f);            
// 通过对象多态性进行实例化    
        // 第3步：进行写操作    
        String str = "Hello World!!!";      
// 准备一个字符串    
        out.write(str);                    
// 将内容输出    
        // 第4步：关闭输出流    
        // out.close();                   
// 此时没有关闭    
    }    
}   
 
程序运行结果：
 
 
程序运行后会发现文件中没有任何内容，这是因为字符流操作时使用了缓冲区，而 在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的，所以得出结论：字符流使用了缓冲区，而字节流没有使用缓冲区。
 
提问：什么叫缓冲区？
 
在很多地方都碰到缓冲区这个名词，那么到底什么是缓冲区？又有什么作用呢？
 
回答：缓冲区可以简单地理解为一段内存区域。
 
可以简单地把缓冲区理解为一段特殊的内存。
 
某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。
 
在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区暂存数据。
 
如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。
 
范例：强制性清空缓冲区
 
package org.lxh.demo12.chariodemo;    
import java.io.File;    
import java.io.FileWriter;    
import java.io.Writer;    
public class WriterDemo04 {    
    public static void main(String[] args) throws Exception { // 异常抛出不处理    
        // 第1步：使用File类找到一个文件    
        File f = new File("d:" + File.separator + "test.txt");// 声明File    
对象    
        // 第2步：通过子类实例化父类对象    
        Writer out = null;                   
// 准备好一个输出的对象    
        out = new FileWriter(f);             
// 通过对象多态性进行实例化    
        // 第3步：进行写操作    
        String str = "Hello World!!!";      
// 准备一个字符串    
        out.write(str);                    
// 将内容输出    
        out.flush();                       
// 强制性清空缓冲区中的内容    
        // 第4步：关闭输出流    
        // out.close();                
// 此时没有关闭    
    }    
}   
 
程序运行结果：
 
 此时，文件中已经存在了内容，更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。
 
提问：使用字节流好还是字符流好？
 
学习完字节流和字符流的基本操作后，已经大概地明白了操作流程的各个区别，那么在开发中是使用字节流好还是字符流好呢？
 
回答：使用字节流更好。
 
在回答之前，先为读者讲解这样的一个概念，所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。
 
字节流与字符流主要的区别是他们的的处理方式
 
流分类：
 1.Java的字节流
 InputStream是所有字节输入流的祖先，而OutputStream是所有字节输出流的祖先。
 2.Java的字符流
 Reader是所有读取字符串输入流的祖先，而writer是所有输出字符串的祖先。
 InputStream，OutputStream,Reader,writer都是抽象类。所以不能直接new
 
字节流是最基本的，所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的
 但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化
 这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联
 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的
 
在从字节流转化为字符流时，实际上就是byte[]转化为String时，
 public String(byte bytes[], String charsetName)
 有一个关键的参数字符集编码，通常我们都省略了，那系统就用操作系统的lang
 而在字符流转化为字节流时，实际上是String转化为byte[]时，
 byte[] String.getBytes(String charsetName)
 也是一样的道理
 
至于java.io中还出现了许多其他的流，按主要是为了提高性能和使用方便，如BufferedInputStream,PipedInputStream等。需注意，使用BufferedOutputStream输出数据时如果没有关闭流，数据也是不会输出到文件当中的，即并不是所有字节流都不用到缓冲区，输入缓冲字节流BufferedInputStream和输出缓冲字节流BufferedOutputStream还是要用到缓冲区的。
 
补充：
 字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点. 所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列. 1.字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 2. 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。 字节流与字符流主要的区别是他们的的处理方式

 
我们知道Java中的流分为字符流和字节流，其中字符流主要针对字符文本进行处理，而字节流处理范围更为广泛，毕竟图片、电影等只要是文件都是以二进制的形式存在的，而不是字符。
 字符流：
 FileReader
 FileWriter。
 
 
 BufferedReader
 BufferedWriter
 
 
 字节流：
 FileInputStream
 FileOutputStream
 
 
 BufferedInputStream
 BufferedOutputStream
 
 我们看一下J2SE文档：
 
 
 BufferedReader(Reader in)：创建一个使用默认大小输入缓冲区的缓冲字符输入流。
 可以看出BufferedReader是一个Reader的子类，构造函数传进来的是父类Reader类，其实是装饰者模式，将父类比较低效的读取数据的方式做成了比较高效的缓冲区读取方式。
   String  readLine()：读取一个文本行。
 它有一个方法readLine()，直接读取一行，相对于父类Reader的read()方法更加方便。
 
 
 System.in:对应的标准输入设备：键盘。
 static InputStream in ：“标准”输入流。
 我们可以写一个类来使用System中的静态方法in来从键盘读取数据：
 
 
<span style="font-size:18px;">import java.io.*;
class  ReadIn{
	public static void main(String[] args) throws IOException{
		InputStream inin = System.in;		//新建一个InputStream对象，读取位置为键盘
		StringBuilder sb = new StringBuilder();	//用于存储读入的字符，相当于自己建了一个缓存区

		while(true){
			int ch = inin.read();			//读取字节
			if(ch=='\r')
				continue;

			if(ch=='\n'){
				String s = sb.toString();//读到回车符就转成String，看看是否是"over"，是就退出度数
				if("over".equals(s))
					break;
				else{
					System.out.println(s.toUpperCase());//不是"over"的话就不退出，一行读取完毕，输出到屏幕上
					sb.delete(0,sb.length());	//清空缓存StringBuilder sb
				}
			}
			else
				sb.append((char)ch);	//如果没读到换行符，就继续往缓存StringBuilder里添加读取的字符
		}
	}
}</span>

 System的in的类型是InputStream，属于字节流，和BufferedReader属于不同的流类。在InputStream中没有readLine()这样的整行读取方法，只有read()。
 那么能不能直接使用readLine()方法来完成键盘录入的一行数据的读取呢？
 即“能不能将字节流转成字符流，然后再使用字符流缓冲区的readLine方法呢”？
 可以的！
 在字符流中有这样的字符流：
 将字节流转换成字符流的桥梁——InputStreamReader；
 InputStreamReader(InputStream in) ：创建一个使用默认字符集的 InputStreamReader。传入的对象是InputStream类型，而自己本身是Reader的子类。
 将字符流转换成字节流的桥梁——OutputStreamWriter。
 OutputStreamWriter(OutputStream out) ：创建使用默认字符编码的 OutputStreamWriter。传入的对象是OutputStream类型，而自己本身是Writer的子类。
 从名字就可以看出，他们分别属于（从属关系看名字的后半部分）字符流Reader和Writer，他们的功能（功能看名字的前半部分）和字节流InputStream、OutputStream相关。
  
 
 
<span style="font-size:18px;">import java.io.*;
class  TransStreamDemo{
	public static void main(String[] args) throws IOException{
		InputStream in = System.in;				//获取键盘录入对象。
		InputStreamReader isr = new InputStreamReader(in);	//将字节流对象转成字符流对象，使用转换流。InputStreamReader
		BufferedReader bufr = new BufferedReader(isr);		//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

//		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));	//最常见写法，以后都这样写！！！

		OutputStream out = System.out;
		OutputStreamWriter osw = new OutputStreamWriter(out);
		BufferedWriter bufw = new BufferedWriter(osw);
//		BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));	//同上！！！

		String line = null;

		while( ( line = bufr.readLine() ) != null ){
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());	//bufw将osw包装了，osw将out包装了，本例中out是Syetem.out的对象实现，所以原本用System.out.println的地方直接可以用包装后的bufw输出字符串。
			bufw.newLine();			//输出换行符：可以根据Linux和Windows的不同自动输出\n或\r\n
			bufw.flush();			//输出流有缓冲区，需要flush才输出来
		}

		bufr.close();

	}
}</span>
 
 
即——
 从文件读取字符，用FileReader，但是为了让其读取更高效，使用BufferedReader将其包装一下；
 从键盘读取数据，（新建一个InputStream对象获取键盘录入对象，）用InputStreamReader转换流将InputStream转换，然后用BufferedReader将InputStreamReader包装。
 当然InputStream也可以从文件读取，这个时候使用的就不是InputStream in = System.in，而是InputStream in = new FileInputStream(String fileName)。
 即：
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 和
 BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(String fileName)));