Java Io流的概念，分类，类图

目录

1、Java Io流的概念，分类，类图

1.1、Java Io流的概念

1.2、Io流的分类

1.2.1、按照流的流向分，可以分为输入流和输出流

1.2.2、按照操作单元划分，可以划分为字节流和字符流

1.2.3、按照流的角色划分为节点流和处理流

1.3、流的原理浅析和常用的流的分类表

1.3.1、流的原理浅析

1.3.2、java输入/输出流体系中常用的流的分类表（重点）

2、常用的io流的用法

2.1、Io体系的基类（InputStream/Reader，OutputStream/Writer）

2.2、文件流(FileInputStream/FileReader ，FileOutputStream/FileWriter)

2.2.1、FileInputStream、FileOutputStream

2.2.2、FileReader、FileWriter

2.2、缓存流(BufferedInputStream/BufferedOutputStream, BufferedReader/BufferedWriter)

2.2.1、字节缓存流（BufferedInputStream/BufferedOutputStream）

2.2.2、字节缓存流（BufferedReader/BufferedWriter）

2.3、转换流（InputStreamReader、OutputStreamWriter）

---

1、Java Io流的概念，分类，类图

1.1、Java Io流的概念

      java的io是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。stram是从起源（source）到接收的（sink）的有序数据。

注：java把所有的传统的流类型都放到在java io包下，用于实现输入和输出功能。

1.2、Io流的分类

按照不同的分类方式，可以把流分为不同的类型。常用的分类有三种：

1.2.1、按照流的流向分，可以分为输入流和输出流

        输入流： 只能从中读取数据，而不能向其写入数据。

        输出流：只能向其写入数据，而不能向其读取数据。

      此处的输入,输出涉及一个方向的问题，对于如图15.1所示的数据流向，数据从内存到硬盘，通常称为输出流——也就是说，这里的输入，输出都是从程序运行所在的内存的角度来划分的。

注：如果从硬盘的角度来考虑，图15.1所示的数据流应该是输入流才对；但划分输入/输出流时是从程序运行所在的内存的角度来考虑的，因此如图15.1所在的流时输出流。而不是输入流。

      对于如图15.2所示的数据流向，数据从服务器通过网络流向客户端，在这种情况下,Server端的内存负责将数据输出到网络里，因此Server端的程序使用输出流；Client端的内存负责从网络中读取数据，因此Client端的程序应该使用输入流。

注：java的输入流主要是InputStream和Reader作为基类，而输出流则是主要由outputStream和Writer作为基类。它们都是  一些抽象基类，无法直接创建实例。

---

1.2.2、按照操作单元划分，可以划分为字节流和字符流

    字节流和字符流的用法几乎完成全一样，区别在于字节流和字符流所操作的数据单元不同，字节流操作的单元是数据单元是8位的字节，字符流操作的是数据单元为16位的字符。

字节流主要是由InputStream和outPutStream作为基类，而字符流则主要有Reader和Writer作为基类。

---

1.2.3、按照流的角色划分为节点流和处理流

    可以从/向一个特定的IO设备（如磁盘，网络）读/写数据的流，称为节点流。节点流也被称为低级流。图15.3显示了节点流的示意图。 
    从图15.3中可以看出，当使用节点流进行输入和输出时，程序直接连接到实际的数据源，和实际的输入/输出节点连接。 
处理流则用于对一个已存在的流进行连接和封装，通过封装后的流来实现数据的读/写功能。处理流也被称为高级流。图15.4显示了处理流的示意图。

      从图15.4可以看出，当使用处理流进行输入/输出时，程序并不会直接连接到实际的数据源，没有和实际的输入和输出节点连接。使用处理流的一个明显的好处是，只要使用相同的处理流，程序就可以采用完全相同的输入/输出代码来访问不同的数据源，随着处理流所包装的节点流的变化，程序实际所访问的数据源也相应的发生变化。

1.3、流的原理浅析和常用的流的分类表

1.3.1、流的原理浅析

     java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java Io流的40多个类都是从如下4个抽象类基类中派生出来的。

       InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。

      OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

    对于InputStream和Reader而言，它们把输入设备抽象成为一个”水管“，这个水管的每个“水滴”依次排列，如图15.5所示： 
    从图15.5可以看出，字节流和字符流的处理方式其实很相似，只是它们处理的输入/输出单位不同而已。输入流使用隐式的记录指针来表示当前正准备从哪个“水滴”开始读取，每当程序从InputStream或者Reader里面取出一个或者多个“水滴”后，记录指针自定向后移动；除此之外，InputStream和Reader里面都提供了一些方法来控制记录指针的移动。

   对于OutputStream和Writer而言，它们同样把输出设备抽象成一个”水管“，只是这个水管里面没有任何水滴，如图15.6所示：

      正如图15.6所示，当执行输出时，程序相当于依次把“水滴”放入到输出流的水管中，输出流同样采用隐示指针来标识当前水滴即将放入的位置，每当程序向OutputStream或者Writer里面输出一个或者多个水滴后，记录指针自动向后移动。 
      图15.5和图15.6显示了java Io的基本概念模型，除此之外，Java的处理流模型则体现了Java输入和输出流设计的灵活性。处理流的功能主要体现在以下两个方面。

       性能的提高：主要以增加缓冲的方式来提供输入和输出的效率。

      操作的便捷：处理流可能提供了一系列便捷的方法来一次输入和输出大批量的内容，而不是输入/输出一个或者多个“水滴”。

    处理流可以“嫁接”在任何已存在的流的基础之上，这就允许Java应用程序采用相同的代码，透明的方式来访问不同的输入和输出设备的数据流。图15.7显示了处理流的模型。

---

1.3.2、java输入/输出流体系中常用的流的分类表（重点）

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushbackReader
特殊流	DataInputStream	DataOutputStream

注：表中粗体字所标出的类代表节点流，必须直接与指定的物理节点关联；斜体字标出的类代表抽象基类，无法直接创建实例；红色为经常使用的流。

2、常用的io流的用法

       下面是整理的常用的Io流的特性及使用方法，只有清楚每个Io流的特性和方法。才能在不同的需求面前正确的选择对应的IO流进行开发。

2.1、Io体系的基类（InputStream/Reader，OutputStream/Writer）

字节流和字符流的操作方式基本一致，只是操作的数据单元不同——字节流的操作单元是字节，字符流的操作单元是字符。所以字节流和字符流就整理在一起了。

       InputStream和Reader是所有输入流的抽象基类，本身并不能创建实例来执行输入，但它们将成为所有输入流的模板，所以它们的方法是所有输入流都可使用的方法。 
在InputStream/Reader里面包含如下3个方法：

        int read()/int read()，从输入流中读取单个字节/字符（相当于从图15.5所示的水管中取出一滴水），返回所读取的字节/字符数据（字节/字符数据可直接转换为int类型）。

       int read(byte[] b)/int read(char[] b)，从输入流中最多读取b.length个字节/字符的数据，并将其存储在字节/字符数组b中，返回实际读取的字节/字符数。

       int read(byte[] b,int off,int len)/int read(char[] b,int off,int len)， 从输入流中最多读取len个字节/字符的数据，并将其存储在数组b中，放入数组b中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字节/字符数。

       对比InputStream和Reader所提供的方法，就不难发现这两个基类的功能基本是一样的。InputStream和Reader都是将输入数据抽象成如图15.5所示的水管，所以程序即可以通过read()方法每次读取一个”水滴“，也可以通过read（char[] b）或者read（byte[] b）方法来读取多个“水滴”。当使用数组作为read（）方法中的参数, 我们可以理解为使用一个“竹筒”到如图15.5所示的水管中取水，如图15.8所示read(char[] b)方法的参数可以理解成一个”竹筒“，程序每次调用输入流read(char[] b)或read（byte[] b）方法，就相当于用“竹筒”从输入流中取出一筒“水滴”，程序得到“竹筒”里面的”水滴“后，转换成相应的数据即可；程序多次重复这个“取水”过程，直到最后。程序如何判断取水取到了最后呢？直到read（char[] b）或者read（byte[] b）方法返回-1，即表明到了输入流的结束点。

InputStream和Reader提供的一些移动指针的方法：

        void mark(int readAheadLimit); 在记录指针当前位置记录一个标记（mark）。

        boolean markSupported(); 判断此输入流是否支持mark()操作，即是否支持记录标记。

        void reset(); 将此流的记录指针重新定位到上一次记录标记（mark）的位置。

        long skip(long n); 记录指针向前移动n个字节/字符。

OutputStream和Writer： 
        OutputStream和Writer的用法也非常相似，它们采用如图15.6所示的模型来执行输入，两个流都提供了如下三个方法：

        void write(int c); 将指定的字节/字符输出到输出流中，其中c即可以代表字节，也可以代表字符。

        void write(byte[]/char[] buf); 将字节数组/字符数组中的数据输出到指定输出流中。

        void write(byte[]/char[] buf, int off,int len ); 将字节数组/字符数组中从off位置开始，长度为len的字节/字符输出到输出流中。

        因为字符流直接以字符作为操作单位，所以Writer可以用字符串来代替字符数组，即以String对象作为参数。Writer里面还包含如下两个方法：

        void write(String str); 将str字符串里包含的字符输出到指定输出流中。

        void write (String str, int off, int len); 将str字符串里面从off位置开始，长度为len的字符输出到指定输出流中。

2.2、文件流(FileInputStream/FileReader ，FileOutputStream/FileWriter)

      前面说过InputStream/OutputStream和Reader/Writer都是抽象类，本身不能创建实例，但它们分别有一个用于读取文件的输入流：FileInputStream和FileReader，它们都是节点流——会直接和指定文件关联。下面程序示范使用FileInputStream、FileOutputStream和FileReader、FileWriter。 

2.2.1、FileInputStream、FileOutputStream

package byte_stream;

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

public class File_X_Stream_Sample {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		FileInputStream fis=null;
        FileOutputStream fos=null;

        try {
        	
        	File file = new File("D:\\workspace\\file_calss_test","file_learn.txt");
            if(!file.exists())
            {
            	System.out.println("file is not exist");
            	file.createNewFile();
            }
            
        	File file2 = new File("D:\\workspace\\file_calss_test","file_learn2.txt");
            if(!file2.exists())
            {
            	System.out.println("file2 is not exist");
            	file2.createNewFile();
            }
            		
            //创建字节输入流
            fis=new FileInputStream(file);
            //创建字节输出流
            fos=new FileOutputStream(file2);

            byte[] b=new byte[1024];
            int hasRead=0;
			while((hasRead = fis.read(b,0,10))>0) {
				System.out.println("hasRead="+hasRead+","+new String(b));//b.tostring
				fos.write(b,0,hasRead);
			}
        }finally {
				fis.close();
        	    fos.close();
		}
	}
}

运行结果：file_learn.txt中的内容被正确读出，写入file_learn2.txt

2.2.2、FileReader、FileWriter

package char_stream;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;;

public class File_Reader_Writer_Sample {

	static private Reader file_in = null;
	static private Writer file_out =null;
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
      	File file = new File("D:\\workspace\\file_calss_test","file_learn.txt");
        if(!file.exists())
        {
        	System.out.println("file is not exist");
        	file.createNewFile();
        }
        
    	File file2 = new File("D:\\workspace\\file_calss_test","file_learn2.txt");
        if(!file2.exists())
        {
        	System.out.println("file2 is not exist");
        	file2.createNewFile();
        }
        
        file_in = new FileReader(file);
        file_out = new FileWriter(file2);
        
        char [] temp = new char[1024];
        int hasread=0;
        while((hasread= file_in.read(temp, 0, 10))>0) {
        	System.out.println("hasread="+hasread+","+new String(temp));
        	file_out.write(temp, 0, hasread);
        }
        
        file_in.close();
        file_out.close();
		
	}

}

运行结果：file_learn.txt中的内容被正确读出，写入file_learn2.txt

注意：文件中的汉字不能被字符流正确解析

2.2、缓存流(BufferedInputStream/BufferedOutputStream, BufferedReader/BufferedWriter)

        缓冲流是处理流的一种，它依赖于原始的输入输出流, 它令输入输出流具有1个缓冲区, 显著减少与外部设备的IO次数, 而且提供一些额外的方法。而我们使用缓冲流无非两个目的:

      1.减少IO次数(提升performance)

      2. 使用一些缓冲流的额外的方法

2.2.1、字节缓存流（BufferedInputStream/BufferedOutputStream）

       如下代码拷贝一个25M的文本文件out.txt：

       1、使用原始文件流FileInputStream/FileOutputStream的read()，wrire(int x)方法拷贝时长为：450s；

       2、将原始文件流封装成缓冲流BufferedInputStream/BufferedOutputStream拷贝时长变为 ：3s

       3、使用原始文件流FileInputStream/FileOutputStream的read(byte[] b)，wrire(byte[] b)方法拷贝时长为：1s，貌似比缓冲流效果还好，切其实原理是一致的一次读取多个字节。

package byte_stream;

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

public class BufferStreamSample {

	static FileInputStream fileIn=null;
	static FileOutputStream fileOut=null;
	static BufferedInputStream bufferFileIn=null; 
	static BufferedOutputStream bufferFileOut=null; 
    static int gBufferedSize = 512;
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
 
        try {
        	//out.txt = 25M
        	File file = new File("D:\\workspace\\io_stream_test","out.txt");
            if(!file.exists())
            {
            	System.out.println("file is not exist");
            	file.createNewFile();
            }
            
        	File file2 = new File("D:\\workspace\\io_stream_test","out_bk.txt");
            if(!file2.exists())
            {
            	System.out.println("file2 is not exist");
            	file2.createNewFile();
            }
            		
            //创建字节输入流、输出流
            fileIn=new FileInputStream(file);
            fileOut=new FileOutputStream(file2);
            //创建缓存流
            bufferFileIn = new BufferedInputStream(fileIn, gBufferedSize);
            bufferFileOut = new BufferedOutputStream(fileOut, gBufferedSize);
            
            byte[] buffer=new byte[gBufferedSize];
            int hasRead=0;
            
            long startTime = System.currentTimeMillis();
            while((hasRead = fileIn.read(buffer)) != -1) {
            	fileOut.write(buffer);			
			}
            fileOut.flush();
            long endTime = System.currentTimeMillis();
            System.out.println("copy time:"+(endTime-startTime)/1000+"s");
			
        }finally {
				fileIn.close();
        	    fileOut.close();
		}
	}
}

2.2.2、字节缓存流（BufferedReader/BufferedWriter）

        相比于原始字符流Reader/Writer新增了文本行的读写方式，具体方法：readLine():读取单行文本不包括换行符'\n'；newLine():向文件中写入一个换行符'\n'。

package char_stream;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;;

public class File_Reader_Writer_Sample {

	static private Reader fileIn = null;
	static private Writer fileOut =null;
	static private BufferedReader bufferFileIn = null;
	static private BufferedWriter bufferFileOut =null;	
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
      	File file = new File("D:\\workspace\\io_stream_test","test.txt");
        if(!file.exists())
        {
        	System.out.println("file is not exist");
        	file.createNewFile();
        }
        
    	File file2 = new File("D:\\workspace\\io_stream_test","test_bk.txt");
        if(!file2.exists())
        {
        	System.out.println("file2 is not exist");
        	file2.createNewFile();
        }
        
        fileIn = new FileReader(file);
        fileOut = new FileWriter(file2);
        
        bufferFileIn = new BufferedReader(fileIn,512);       
        bufferFileOut = new BufferedWriter(fileOut, 512);
        		
        String readBuff =null;
        while((readBuff=bufferFileIn.readLine())!=null) {
        	System.out.print(readBuff);
        	bufferFileOut.write(readBuff);
        	bufferFileOut.newLine();
        }        
        bufferFileOut.flush();

        fileIn.close();
        fileOut.close();
		
	}

}

运行结果：

       

2.3、转换流（InputStreamReader、OutputStreamWriter）

        在《Java网络编程》中，有这样一段话：
        “Reader和Writer最重要的子类是InputStreamReader和OutputStreamWriter类。
         InputStreamReader类包含了一个底层输入流，可以从中读取原始字节。它根据指定的编码方式，将这些字节转换为Unicode字符。
        OutputStreamWriter从运行的程序中接收Unicode字符，然后使用指定的编码方式将这些字符转换为字节，再将这些字节写入底层输出流中。”

        转换流的特点：
       1. 其是字符流和字节流之间的桥梁
       2. 可对读取到的字节数据经过指定编码转换成字符
       3. 可对读取到的字符数据经过指定编码转换成字节

       什么时候使用转换流呢？
       1，源或者目的对应的设备是字节流，但是操作的却是文本数据，可以使用转换作为桥梁。提高对文本操作的便捷。 
       2，一旦操作文本涉及到具体的指定编码表时，必须使用转换流。

    
        具体的对象体现：
        1. InputStreamReader:字节到字符的桥梁
        2. OutputStreamWriter:字符到字节的桥梁

这两个流对象是字符体系中的成员，它们有转换作用，本身又是字符流，所以在构造的时候需要传入字节流对象进来。

字节流InputStream(System.in)转为字符流Reader:

package byte_to_char_sample;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

public class IoStream_to_ReadWriterSample {

	static private InputStream pre_is = null;
	static private OutputStream pre_os= null;
	
	static private Reader is = null;
	static private Writer os = null;
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
        
		pre_is = System.in;
		pre_os = new FileOutputStream("D:\\workspace\\file_calss_test\\file_learn2.txt");
		
		is = new InputStreamReader(pre_is);
	    os = new OutputStreamWriter(pre_os);
		
		char []temp = new char[100];
		int read_cnt = 0;
		//while((read_cnt = is.read(temp))>0) {
		System.out.println("输入字符串：");
		read_cnt = is.read(temp);
		System.out.println("read_cnt="+read_cnt+","+new String(temp));
		os.write(temp,0,read_cnt);
		//}
		
		is.close();
		os.close();
	}
}