io 输入输出流学习

发表于 | 分类于

Java流类图结构

流的概念和作用

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作 。

IO流的分类

1.根据处理数据类型的不同分为：字符流和字节流。

2.根据数据流向不同分为：输入流和输出流。

字符流和字节流

字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别：

读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

字节流：一次读入或读出是8位二进制。

字符流：一次读入或读出是16位二进制。

设备上的数据无论是图片或者视频，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

输入流和输出流
输入流只能进行读操作，输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。

输入字节流 InputStream

  1. InputStream 是所有的输入字节流的父类，它是一个抽象类。

  2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。

  3. PipedInputStream 是从与其它线程共用的管道中读取数据，与Piped 相关的知识后续单独介绍。
  4. ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。

输出字节流 OutputStream

  1. OutputStream 是所有的输出字节流的父类，它是一个抽象类。
  2. ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。
  3. PipedOutputStream 是向与其它线程共用的管道中写入数据。
  4. ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

总结：

  1. 输入流：InputStream或者Reader：从文件中读到程序中；
  2. 输出流：OutputStream或者Writer：从程序中输出到文件中；

节点流

节点流：直接与数据源相连，读入或读出。
直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。

常用的节点流

  1. 父　类 ：InputStream 、OutputStream、 Reader、 Writer
  2. 文　件 ：FileInputStream 、 FileOutputStrean 、FileReader 、FileWriter 文件进行处理的节点流
  3. 数　组 ：ByteArrayInputStream、 ByteArrayOutputStream、 CharArrayReader 、CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）
  4. 字符串 ：StringReader、 StringWriter 对字符串进行处理的节点流
  5. 管　道 ：PipedInputStream 、PipedOutputStream 、PipedReader 、PipedWriter 对管道进行处理的节点流

处理流

处理流和节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

常用的处理流

  1. 缓冲流：BufferedInputStream 、BufferedOutputStream、 BufferedReader、 BufferedWriter 增加缓冲功能，避免频繁读写硬盘。
  2. 转换流：InputStreamReader 、OutputStreamReader实现字节流和字符流之间的转换。
  3. 数据流： DataInputStream 、DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来。

转换流
InputStreamReader 、OutputStreamWriter 要InputStream或OutputStream作为参数，实现从字节流到字符流的转换。

构造函数

1
2
3
4
5
6

InputStreamReader(InputStream);        //通过构造函数初始化，使用的是本系统默认的编码表GBK。
InputStreamReader(InputStream,String charSet);   //通过该构造函数初始化，可以指定编码表。
OutputStreamWriter(OutputStream);      //通过该构造函数初始化，使用的是本系统默认的编码表GBK。
OutputStreamwriter(OutputStream,String charSet);   //通过该构造函数初始化，可以指定编码表。

实战演练：

  • FileInputStream类的使用：读取文件内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class A1 {

	public static void main(String[] args) {
		A1 a1 = new A1();
	
		//电脑d盘中的abc.txt 文档
		String filePath = "D:/abc.txt" ;
		String reslut = a1.readFile( filePath ) ;
	    System.out.println( reslut ); 
	}


	/**
	 * 读取指定文件的内容
	 * @param filePath ： 文件的路径
	 * @return  返回的结果
	 */
	public String readFile( String filePath ){
		FileInputStream fis=null;
		String result = "" ;
		try {
			// 根据path路径实例化一个输入流的对象
			fis  = new FileInputStream( filePath );
	
			//2. 返回这个输入流中可以被读的剩下的bytes字节的估计值；
			int size =  fis.available() ;
			//3. 根据输入流中的字节数创建byte数组；
			byte[] array = new byte[size];
			//4.把数据读取到数组中；
			fis.read( array ) ; 
	
			//5.根据获取到的Byte数组新建一个字符串，然后输出；
			result = new String(array);	
	
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch (IOException e) {
			e.printStackTrace();
		}finally{
			if ( fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	
		return result ;
	}


}

- FileOutputStream 类的使用：将内容写入文件

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class A2 {

	public static void main(String[] args) {
		A2 a2 = new A2();
	
		//电脑d盘中的abc.txt 文档
		String filePath = "D:/abc.txt" ;
	
		//要写入的内容
		String content = "今天是2017/1/9,天气很好" ;
		a2.writeFile( filePath , content  ) ;
	
	}
	
	/**
	 * 根据文件路径创建输出流
	 * @param filePath ： 文件的路径
	 * @param content : 需要写入的内容
	 */
	public void writeFile( String filePath , String content ){
		FileOutputStream fos = null ;
		try {
			//1、根据文件路径创建输出流
			fos  = new FileOutputStream( filePath );
	
			//2、把string转换为byte数组；
			byte[] array = content.getBytes() ;
			//3、把byte数组输出；
			fos.write( array );
	
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch (IOException e) {
			e.printStackTrace();
		}finally{
			if ( fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}


}

文件、流、byte直接的相互转换

如下多以图片为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

//文件转换为流：

InputStream fis = new FileInputStream("xxx.jpg");

//将流转换为byte[]

ByteArrayOutputStream byteArray = new ByteArrayOutputStream();

btye [] bytes = new byte [1024];

int n;

while ((n = fis.read(bytes)) !=  -1){

​	byteArray.write(bytes, 0, n);

​	}

 fis.close();

byteArray.close();

byte[] imageBytes =  byteArray.toByteArray();



//将文件byte[] 转发为流

InputStream inp = new ByteArrayInputStream(imageBytes );

原文链接：https://blog.csdn.net/zhaoyanjun6/article/details/54292148/