首先，流是什么？

流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。设备可以是文件，网络，内存等。



流具有方向性，至于是输入流还是输出流则是一个相对的概念【取决于流向】，一般以程序为参考，如果数据的流向是程序至设备，我们成为输出流，反之我们称为输入流。

可以将流想象成一个“水流管道”，水流就在这管道中形成了，【水滴救赎数据】自然就出现了方向的概念。



当程序需要从某个数据源读入数据的时候，就会开启一个输入流，数据源可以是文件、内存或网络等等。相反地，需要写出数据到某个数据源目的地的时候，也会开启一个输出流，这个数据源目的地也可以是文件、内存或网络等等。

流有哪些分类？

可以从不同的角度对流进行分类：

1. 处理的数据单位不同，可分为：字符流，字节流

2.数据流方向不同，可分为：输入流，输出流

3.功能不同，可分为：节点流，处理流

1. 和 2. 都比较好理解，对于根据功能分类的，可以这么理解：

节点流：节点流从一个特定的数据源读写数据。即节点流是直接操作文件，网络等的流，例如FileInputStream和FileOutputStream，他们直接从文件中读取或往文件中写入字节流。



处理流：“连接”在已存在的流（节点流或处理流）之上通过对数据的处理为程序提供更为强大的读写功能。过滤流是使用一个已经存在的输入流或输出流连接创建的，过滤流就是对节点流进行一系列的包装。例如BufferedInputStream和BufferedOutputStream，使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率，以及DataInputStream和DataOutputStream，使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。他们都属于过滤流。






处理流对已经存在的节点流进行包装，使用了装饰者模式，实际和数据打交道还是节点流，更重要的好处进一步包装之后，在更上层的子类的使用时统一的，无须关注输入输出节点具体是硬盘，网络还是其他设备。

目录

前言

流的概念

I/O设备与文件

面向字节的输入流

InputStream类

类InputStream的子类的使用

文件输入流（FileInputStream）

文件输入流（FileInputStream）实例

字节数组输入流（ByteArrayInputStream）

字节数组输入流（ByteArrayInputStream）实例

数据输入流（DataInputStream）

数据输入流（DataInputStream）实例

面向字节的输出流

文件输出流（FileOutputStream）

文件输出流（FileOutputStream）实例

字节数组输出流（ByteArrayOutputStream）

字节数组输出流（ByteArrayOutputStream）实例

数据输出流类（DataOutputStream）

数据流类（DataOutputStream）实例

最后

前言

Java不是在语言层面上对输入/输出提供支持，而是将这个任务交由类库来完成，这样类库可以充分、灵活地运用各种输入/输出技术。输入/输出是程序与用户之间沟通的桥梁，程序从外界获得数据称为输入，程序将运算结果等信息传递给外界称为输出，Java的输入、输出是以流的方式来进行处理的，那么什么是流，流是怎样来处理输入、输出的呢，今天我们来学习Java中的输入/输出流。

流的概念

在Java中，把一组有序的数据序列称为流，流系列中的数据有未经加工的原始二进制数据，也有经过特定包装过滤处理的格式数据。

流式输入、输出特点是数据的获得和发送均沿数据序列顺序进行。

输出流是向存储介质或数据通道中写入数据，而输入流是从存储介质或数据通道中读取数据，如下图所示：



流的特性：

先进先出：最先用输出流写入存储介质的数据最先被输入流读取到；
	
顺序存取：写入和读取流数据均按顺序逐个字节进行，不能随机访问中间的数据；
	
只读或只写：每个流只能是输入流或输出流的一种，不能同时具备两个功能。
Java API提供了两套流来处理输入/输出来满足不同性质的输入/输出需要：

面向字节的流：数据的处理是以字节为基本单位；
	
面向字符的流：用于字符数据的处理。
注意：为了满足字符的国际化表示要求，Java的字符编码是采用16位表示一个字符的Unicode码，而普通的文本文件中采用的是8位的ASCII码。

Java系统定义了以下3个可以直接使用的流对象：

标准输入（System.in）：InputStream类型，通常代表键盘输入；
	
标准输出（System.out）：PrintStream类型，通常写往显示器；
	
标准错误输出（System.err）：PrintStream类型，通常写往显示器。
在Java中使用字节流和字符流的步骤基本相同，以输出流为例：

创建一个与数据源相关的流对象；
	
利用流对象的方法往流写入数据；
	
执行close()方法关闭流。
I/O设备与文件

计算机外部设备分为两类：存储设备与输入/输出设备。

存储设备：包括硬盘、软盘、光盘等，数据以文件的形式进行组织；
	
输入/输出设备：输入设备(键盘、鼠标、扫描仪等)和输出设备(显示器、打印机、绘图仪等)，从数据操作的角度，文件内容可以是字节的序列；
根据数据的组织方式，文件可以分为文本文件和二进制文件。

文本文件：存放的是ASCII码（或其他编码）表示的字符；
	
二进制文件：具有特定结果的字节数据。
面向字节的输入流

InputStream类

在java.io包中，InputStream类表示字节输入流，它是抽象类，不能实例化，其作用是用来表示那些从不同数据源产生输入的类。

面向字节的输入流类都是类InputStream的子类，如下图：



类InputStream定义了以下方法：

public int read()：读一个字节，返回读到字节的int表示方式，读到流的未尾时返回-1；
	
public int read(byte b[])：读多个字节数组，返回结果为读到的实际字节个数，当输入流中无数据可读时返回-1；
	
public int read(byte[] b,int off,int count)：从输入流读count个字节到字节数组，数据从数组的off处开始存放，当输入流中无数据可读时返回-1；
	
public long skip(long n)：指针跳过n个字节，定位输入位置指针的方法；
	
public void mark()：在当前位置指针处做一标记；
	
public void reset()：将位置指针返回标记处；
	
publicvoid close()：关闭流。
数据的读取通常是按照顺序逐个字节进行访问，在某些特殊情况下，要重复处理某个字节可通过mark()加标记，以后用reset()返回该标记处再处理。

类InputStream的子类的使用

类InputStream的主要子类及功能如下表：

类名
			
构造方法的主要参数
			
功能描述
		

			
ByteArrayInputStream
			
			
字节数组
			
以程序中的一个字节组作为输入源，通常用于对字节数组中的数据进行转换
		
FileInputStream
			
类File的对象或字符串表示的文件名
			
以文件作为数据源，用于实现对磁盘文件中数据的读取
		
PipedInputStream
			
PipedOutputStream的对象
			
与另一输出管道相连，读取写入输出管道中的数据，用于程序中线程间通信
		
FilterInputStream
			
InputStream的对象
			
用于装饰另一输入流以提供对输入数据的附加处理功能
		
SequeueInputStream
			
一系列InputStream的对象
			
将两个其他流首尾相接，合并为一个完整的输入流
		
ObjectInputStream
			
InputStream的对象
			
用于从输入流读取串行化对象，可实现轻量级对象持久性
		
类FilterInputStream的常见子类及功能

类名
			
功能描述
		
BufferedInputStream
			
为所装饰的输入流提供缓存区的功能，以提高输入数据的效率
		
DataInputStream
			
为所装饰的输入流提供数据转换功能，可从数据源读取各种基本类型的数据
		
LineNumberInputStream
			
为文本文件输入流附加行号
		
PushbackInputStream
			
提供回压数据的功能，可以多次读取同样数据
		
文件输入流（FileInputStream）

FileInputStream类用于从二进制文件读取数据，它的对象可以用关键字 new 来创建，构造方法为：

FileInputStream(File file)：打开一个到实际文件的连接来创建文件输入流，该文件通过文件系统的File对象指定；
	
FileInputStream(String name)：打开一个到实际文件的连接来创建文件输入流，该文件通过文件系统的路径名name指定。
文件输入流（FileInputStream）实例

例如：在屏幕上显示文件内容：

import java.io.*;
public class first {
	public static void main(String[] args) throws Exception{
		try {
			FileInputStream file=new FileInputStream("e:/新建文本文档.txt");    //创建一个FileInputStream类实例对象file
			int byteRead=file.read();            //创建一个byteRead变量存储读一个字节
			while(byteRead!=-1) {                //如果返回值不是-1则继续执行file的读操作
				System.out.print((char)byteRead);    //将int类型转换为char类型并输出
				byteRead=file.read();    
			}
		}catch(ArrayIndexOutOfBoundsException e) {        //访问数组元素下标越界的异常
			System.out.println("要一个文件名作为命令行参数！");
		}catch(FileNotFoundException e) {                 //访问文件不存在的异常
			System.out.println("文件不存在");
		}catch(IOException e) {}                          //输入输出异常
	}
}

注意：读到文件结尾时read方法返回-1，编程时可以利用该特点来组织循环，从文件的第一个字节一直读到最后一个字节。

字节数组输入流（ByteArrayInputStream）

ByteArrayInputStream类从内存的字节数组中读取数据（数据源是一个字节数组），它本身采用适配器设计模式，把字节数组转换为输入流类型，使程序能对字节数组进行读操作。

字节数组输入流（ByteArrayInputStream）实例

使用ByteArrayInputStream类读取数组中的字节

import java.io.*;
public class first {
	public static void main(String[] args) throws Exception{
		String str="123456789qwerty";        //创建一个字符串变量
		byte[]strBuf=str.getBytes();         //把字符串转换为字节数组
		ByteArrayInputStream bais=new ByteArrayInputStream(strBuf);    //创建一个字节数组流对象
		int data=bais.read();                 //从字节数组输入流读取字节
		while(data!=-1) {
			char upper=Character.toUpperCase((char)data);    //小写转换为大写
			System.out.print(upper+" ");
			data=bais.read();                 //读取字节
		}
		bais.close();                         //关闭字节数组输入流
	}
}

运行结果为：

1 2 3 4 5 6 7 8 9 Q W E R T Y 

数据输入流（DataInputStream）

DataInputStream类的所有读方法都以“read”开头，具体如下：

readByte()：从输入流中读取1个字节，把它转换为byte类型的数据；
	
readFloat()：从输入流中读取4个字节，把它转换为float类型的数据；
	
readLong()：从输入流中读取8个字节，把它转换为Long类型的数据；
	
readUTF()：从输入流中读取若干字节，把它转换为UTF-8编码的字符串。
我们发现在数据输出流(DataOutputStream)实例中写入的文件，会发现是一些乱码，原因是在于该文件中的数据不是文本格式的数据，要读取其中的数据需要以输入流的方式访问文件，用DataInputStream的readInt方法读取对应数据。

数据输入流（DataInputStream）实例

import java.io.*;
public class first {
	public static void main(String[] args) throws Exception{
		try {
			FileInputStream file=new FileInputStream("d:/x.txt");
			DataInputStream in=new DataInputStream(file);
			while(true) {
				int n1=in.readInt();
				int n2=in.readInt();
				System.out.println(n1+","+n2);
			}
		}catch(EOFException e) {}
		catch(IOException e) {}
	}
}

运行结果为：

11,13
17,19
29,31
41,43
59,61
71,73

面向字节的输出流

面向字节的输出流都是类OutputStream的后代类，如下图：



类OutputStream是一个抽象类，含一套所有输出流均需要的方法：

public void write(int b)：将参数b的低字节写入输出流；
	
public void write(byte b[])：将字节数组全部写入输出流；
	
public void write(byte b[],int off,int count)：将字节数组从off处开始的count个字节数据写入输出流；
	
public void flush()：强制将缓冲区数据写入输出流对应的外设；
	
public void close()：关闭输出流。
文件输出流（FileOutputStream）

FileOutputStream类用于向二进制文件写入数据，构造方法为：

FileOutputStream(String name ,boolean append)：创建一个向指定名字的文件中写入数据的流，若第二个参数为true，则以添加方式写入字节，文件中原有的内容不会被清除；
	
FileOutputStream(File file,boolean)：创建一个向指定File对象表示的文件中写入数据流，若第二个参数为true，则将字节写入文件末尾而不是文件开始处。
文件输出流（FileOutputStream）实例

使用文件输出流将100~200之间能被3整除的数写到文本文件中，要求每10个数一行

import java.io.*;
public class first {
	public static void main(String[] args) throws Exception{
		int n,num,i=0;
		try {
			FileOutputStream fos=new FileOutputStream("D:/t.txt",true);
			for(n=100;n<=200;n++) {
				if(n%3==0) {
					i++;
					String str=String.valueOf(n);
					String str1=str+" ";
					byte[]buff=str1.getBytes();
					fos.write(buff);
					if(i%10==0) {
						str="\r\n";
						byte[]buf=str.getBytes();
						fos.write(buf);
					}
				}
			}
			fos.close();
		}catch(FileNotFoundException e1) {
			System.out.println(e1);
		}catch(IOException e2) {
			System.out.println(e2);
		}
	}
}


运行结果为：



字节数组输出流（ByteArrayOutputStream）

ByteArrayOutputStream类向内存的字节数组写入数据，它也采用了适配器设计模式，把字节数组类型转换为输出流类型，使程序能对字节数组进行写操作。其构造方法为：

ByteArrayOutputStream()：创建一个新的字节数组输出流；
	
ByteArrayOutputStream(int size)：创建指定大小缓冲区的字节数组输出流。
字节数组输出流（ByteArrayOutputStream）实例

import java.io.*;
public class first {
	public static void main(String[] args) throws Exception{
		ByteArrayOutputStream baos=new ByteArrayOutputStream();
		String s="Welcome to java";
		byte[]buf=s.getBytes();
		baos.write(buf);
		System.out.println(baos.toString());
		byte[]b=baos.toByteArray();
		for(int i=0;i<b.length;i++) {
			System.out.print((char)b[i]);
		}
	}
}

运行结果为：

Welcome to java
Welcome to java

数据输出流类（DataOutputStream）

类DataOutputStream实现各种基本类型数据的输出处理，它实现了DataOutput接口，在该接口中定义了基本类型数据的输出方法。

DataOutputStream类的所有方法都以“write”开头，具体如下：

writeByte()：向输出流中写入byte类型的数据；
	
writeLong()：向输出流中写入Long类型的数据；
	
writeFloat()：向输出流中写入float类型的数据；
	
writeUTF()：向输出流中写入UTF-8编码的数据。
其中，writeBytes、writeChars、writeUTF这3个方法均是以字符串作为参数，但它们的数据写入结果不同，writeBytes是按字节写入数据，它会丢弃掉字符的高8位，所以，不适合处理汉字。writeChars是按字符写入数据。writeUTF是按UTF-8字符编码写入数据。

数据流类（DataOutputStream）实例

找出10~100之间的所有姐妹素数，写入文件中。所谓姐妹素数，是指相邻两个奇数均为素数。

import java.io.*;
public class first {
	public static boolean isPrime(int n) {
		for(int k=2;k<=Math.sqrt(n);k++) {
			if(n%k==0)
				return false;
		}
		return true;
	}
	public static void main(String[] args) throws Exception{
		try {
			FileOutputStream file=new FileOutputStream("D:/x.txt");
			DataOutputStream out=new DataOutputStream(file);
			for(int n=11;n<100;n+=2) {               
				if(isPrime(n)&&isPrime(n+2)) {         //两个相邻奇数是否为素数
					out.writeInt(n);                   //将素数写入文件
					out.writeInt(n+2);
				}
			}
			out.close();
		}catch(IOException e) {}
	}
}

运行结果为：



最后

好了，关于Java  I/O流——面向字节的输入/输出流的知识学到这里，谢谢观看！！！

我们下篇文章再见！！！

成功不是将来才有的，而是从决定去做的那一刻起，持续累积而成。

Java网络编程与IO流目录：

【Java网络编程与IO流】Java中IO流分为几种？字符流、字节流、缓冲流、输入流、输出流、节点流、处理流
【Java网络编程与IO流】计算机网络常见面试题高频核心考点
【Java网络编程与IO流】Java之Java Servlet详解
【Java网络编程与IO流】Apache Tomcat和Nginx的区别是什么？
【Java网络编程与IO流】Web实时通信技术即消息推送机制- 简要介绍短连接 长连接 轮询 长轮询 SSE WebSocket？
【Java网络编程与IO流】Java中BIO、NIO、AIO的区别是什么？
【Java网络编程与IO流】Java之Netty网络编程
【Java网络编程与IO流】Spring boot整合SSE实现服务器实时推送流信息
【Java网络编程与IO流】SpringBoot + WebSocket + Netty实现实时的服务器消息推送

【Java网络编程与IO流】Java中IO流分为几种？字符流、字节流、缓冲流、输入流、输出流、节点流、处理流


摘自大佬的文章 [吃透Java IO：字节流、字符流、缓冲流](

摘自大佬的文章 吃透Java IO：字节流、字符流、缓冲流

1.Java的IO流是什么？
IO：即in和out，输入和输出，指的是应用程序和外部设备之间的数据传递；
Java是通过流来处理IO的，流(Stream)是一个抽象的概念，是指一连串的树(字符或字节)，是以先进先出的方式发送信息的通道；
一般流有以下特性：

先进先出：最先写入输出流的数据最先被输入流读取到；
顺序存取：可以一个接一个的往流中写入一串字节，读出时也会按写入顺序读取一串字节，不能随机访问中间的数据。
只读或者只写：每个流只能是输入流或输出流的一种，不能同时具备两个功能。

2.IO流的分类：

按数据流的方向：输入流和输出流
按处理数据单位：字节流和字符流
按功能：节点流、处理流


a.输入流与输出流
输入与输出是相对于应用程序而言的，比如文件读写，读取文件是输入流，写文件是输出流。

b.字节流与字符流
两者的用法几乎一样，区别在于字节流和字符流所操作的数据单位不同，字节流操作的数据单位是8位的字节，字符流操作的数据单位是16位的字符。
为什么有了字节流还要推出字符流？
Java中字符是采用Unicode标准，在Unicode编码中，一个英文为一个字节，一个中文为两个字节。

为了更加方便的处理中文这些字符，Java推出了字符流。

补充：在UTF-8中，一个中文字符是3个字节。

字节流和字符流的区别是什么？

字节流可以处理一切文件，而字符流只能处理纯文本文件；例如字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件，如txt文件。
字节流本身没有缓冲区，缓冲字节流相比于字节流，效率提升非常高。而字符流本身就带有缓冲区，缓冲字符流相比于字符流提升没有那么大。

c.节点流和处理流


节点流：直接操作数据读写的流类，比如FileInputStream


处理流：对一个已存在的流的链接和封装，通过对数据进行处理为程序提供功能强大、灵活的读写功能，例如BufferedInputStream（缓冲字节流）




节点流和处理流应用了Java的装饰者设计模式


抽象组件(InputStream) ：装饰者模式中的超类，它只有一个抽象方法read()，子类都需要对该方法进行处理
被装饰者(FileInputStream , ByteArrayInputStream , StringBufferInputStream) ：拥有通用实现read()基本方法
装饰者组件(FilterInputStream) ：定义具体装饰者的行为规范，可以做统一基础处理。
具体装饰(BufferedInputStream , DataInputStream , Base64InputStream) ：具体的装饰类，拥有对流的读操作做完成具体拓展能力。

装饰者模式让我们可以有不同的被装饰者，例如FileInputStream，并且如果想使用缓冲功能那么只需写一下代码 ：
new BufferedInputStream(new FileInputStream(new File("path")));1

也可以对上面代码再进行加工，简单的加密处理 ：
new Base64InputStream(new BufferedInputStream(new FileInputStream(new File(""))),0)1

哪怕你突然改需求了，读取的对象不是文件，而是文本或字符，那么可以轻松的将代码改为 ：
new Base64InputStream(new BufferedInputStream(new StringBufferInputStream("str")),0)


d.什么是缓冲流？
程序与磁盘的交互相对于内存运算是很慢的，容易成为程序的性能瓶颈。减少程序与磁盘的交互，是提升程序效率一种有效手段。缓冲流，就应用这种思路：普通流每次读写一个字节，而缓冲流在内存中设置一个缓存区，缓冲区先存储足够的待操作数据后，再与内存或磁盘进行交互。这样，在总数据量不变的情况下，通过提高每次交互的数据量，减少了交互次数。

3.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();
	}
}
12345678910111213141516171819202122232425262728293031323334

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()
	}
}
12345678910111213141516171819202122232425262728293031

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();
	}
}
123456789101112131415161718192021222324252627282930

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();
	}
}

首先，流是什么？

流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。设备可以是文件，网络，内存等。

如果数据的流向是程序至设备，我们成为输出流，反之我们称为输入流。







流有哪些分类？


可以从不同的角度对流进行分类：

1. 处理的数据单位不同，可分为：字符流，字节流

字节流河字符流的区别：（各自在什么情况下使用）

字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节， 操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是 音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点. 


2.数据流方向不同，可分为：输入流，输出流

3.功能不同，可分为：节点流，处理流

1. 和 2. 都比较好理解，对于根据功能分类的，可以这么理解：

节点流：节点流从一个特定的数据源读写数据。即节点流是直接操作文件，网络等的流，例如FileInputStream和FileOutputStream，他们直接从文件中读取或往文件中写入字节流。




处理流：“连接”在已存在的流（节点流或处理流）之上通过对数据的处理为程序提供更为强大的读写功能。处理流是使用一个已经存在的输入流或输出流连接创建的，处理流就是对节点流进行一系列的包装。例如BufferedInputStream和BufferedOutputStream，使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率，以及DataInputStream和DataOutputStream，使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。他们都属于处理流。










流结构介绍：


Java所有的流类位于java.io包中，都分别继承字以下四种抽象流类型。

 

字节流

字符流

输入流

InputStream

Reader

输出流

OutputStream

Writer
1.继承自InputStream/OutputStream的流都是用于向程序中输入/输出数据，且数据的单位都是字节(byte=8bit)，如图，深色的为节点流，浅色的为处理流。




2.继承自Reader/Writer的流都是用于向程序中输入/输出数据，且数据的单位都是字符(2byte=16bit)，如图，深色的为节点流，浅色的为处理流。







常见流类介绍：（后面的文章会一一介绍）


节点流类型常见的有：

对文件操作的字符流有FileReader/FileWriter，字节流有FileInputStream/FileOutputStream。

处理流类型常见的有：

缓冲流：缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写效率，同事增加了一些新的方法。

　　字节缓冲流有BufferedInputStream/BufferedOutputStream，字符缓冲流有BufferedReader/BufferedWriter，字符缓冲流分别提供了读取和写入一行的方法ReadLine和NewLine方法。字符缓冲流当然要套结字符流（Reader和Writer）

　　对于输出地缓冲流，写出的数据，会先写入到内存中，再使用flush方法将内存中的数据刷到硬盘。所以，在使用字符缓冲流的时候，一定要先flush，然后再close，避免数据丢失。

转换流：用于字节数据到字符数据之间的转换。

　　仅有字符流InputStreamReader/OutputStreamWriter。其中，InputStreamReader需要与InputStream“套接”，OutputStreamWriter需要与OutputStream“套接”。

数据流：提供了读写Java中的基本数据类型的功能。

　　DataInputStream和DataOutputStream分别继承自InputStream和OutputStream，需要“套接”在InputStream和OutputStream类型的节点流之上。

对象流：用于直接将对象写入写出。

　　流类有ObjectInputStream和ObjectOutputStream，本身这两个方法没什么，但是其要写出的对象有要求，该对象必须实现Serializable接口，来声明其是可以序列化的。否则，不能用对象流读写。