背景

在之前的学习中就提到过IO流,但是对其理解还不够深刻,所以特意单独记录一篇关于IO流的相关知识,也顺便加深一下自己的印象。

IO流

1,原理

I/O是Input和Output的缩写,用于处理设备之间的数据传输,在Java程序中,对于数据的输入与输出操作以“流”(stream)的方式进行。

2,流的分类

按操作数据单位不同分为:字节流(8bit)一般是图片,视频等,字符流(16bit)一般都指文本

按数据流的流向不同分为:输入流,输出流

按流的角色不同分为:节点流,处理流(包裹节点流,使传输的速度更快)

3,流的体系结构

抽象基类 字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Writer

我们是站在程序的角度来说,如果数据需要写入到内存中,那么对于程序来说就是输入流。

相反如果需要把内存中的数据拿出去的话,那么对于程序来说就是输出流。

直接能访问到文件的FileInputStream、FileOutputStream、FileReader、FileWrite,这四个是节点流,其他的流作用于已有流的基础之上的都是处理流。

分类 字节输入流 字节输出流 字符输入流 字符输出流
抽象基类 InputStream OutputStream Reader Writer
访问文件 FileInputStream FIleOutputStream FIleReader FileWriter
缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
转换流 InputStreamReader OutputStreamWriter
对象流 ObjectInputStream ObjectOutputStream

节点流实例

1,FileReader类从文件读取数据

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
方式一
@Test
public void testFileReader() throws IOException {
//1,实例化File对象,指明要操作的文件
File file = new File("hello.txt");
//System.out.print(file);
//2,提供具体的流
FileReader fr = new FileReader(file);
//3,数据的读入
//read()返回读入的是一个字符,如果读到文件末尾就返回-1
int data = fr.read();
while (data != -1){
//Log.e(TAG, "testFileReader: 读出的数据为" + (char)data);
System.out.print((char)data);
data = fr.read();
}
//4,流的关闭操作
fr.close();
//Log.e(TAG, "路径:" + file.getAbsolutePath());
}

方式二

@Test
public void testFileReader() {

FileReader fr = null;
try {
//1,实例化File对象,指明要操作的文件
File file = new File("hello.txt");
//System.out.print(file);
//2,提供具体的流
fr = new FileReader(file);
//3,数据的读入
//read()返回读入的是一个字符,如果读到文件末尾就返回-1
int data;
while ((data = fr.read()) != -1){
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4,流的关闭操作
try {
if(fr != null){
fr.close();
}

} catch (IOException e) {
e.printStackTrace();
}
}
//Log.e(TAG, "路径:" + file.getAbsolutePath());
}


//有参数的read
@Test
public void testFileReader() {

FileReader fr = null;
try {
//1,实例化File对象,指明要操作的文件
File file = new File("hello.txt");
//System.out.print(file);
//2,提供具体的流
fr = new FileReader(file);
//3,数据的读入
//read()返回读入的是一个字符,如果读到文件末尾就返回-1
//int data;
char[] cubf = new char[5];
int len;
//read有参读入
while ((len = fr.read(cubf)) != -1){

String str = new String(cubf, 0, len);
System.out.print(str);
/* for (int i = 0; i < len; i++){
System.out.print(cubf[i]);
}*/
//System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4,流的关闭操作
try {
if(fr != null){
fr.close();
}

} catch (IOException e) {
e.printStackTrace();
}
}
}

2,FileWriter写入数据到文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
public void tsetFileWriter(){
FileWriter fw = null;
String data = "采菊东篱下,悠然见南山";
try{
File file = new File("hell2.txt");
fw = new FileWriter(file);
fw.write(data);
} catch (IOException e){
e.printStackTrace();

} finally {
try {
if(fw != null){
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

3,(字符流)文件读取和写入

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
@Test
public void testCopy() {
FileReader fileReader = null;
FileWriter fileWriter = null;
try {
File srcFile = new File("hello.txt");
File wrtFile = new File("hello2.txt");

fileReader = new FileReader(srcFile);
fileWriter = new FileWriter(wrtFile, true);

char[] cubf = new char[5];
int len;

while ((len = fileReader.read(cubf)) != -1){
fileWriter.write(cubf, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fileReader != null){

fileReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fileWriter != null){

fileWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

4,(字节流)图片的读取和写入

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
@Test
public void imageCopy() {
FileInputStream inputStream = null;
FileOutputStream outputStream = null;

try {
File srcFile = new File("sun.jpg");
File endFile = new File("cSun.jpg");

inputStream = new FileInputStream(srcFile);
outputStream = new FileOutputStream(endFile);

byte[] cubf = new byte[1024];
int len;
while ((len = inputStream.read(cubf)) != -1){
outputStream.write(cubf, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(inputStream != null){

inputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(outputStream != null){

outputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

缓冲流实例

1,作用

提高读写的速度(因为内部提供了一个缓冲区)

2,(字符流)文件的读取和写入

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
@Test
public void bufferedCopyFile() {
BufferedReader br = null;
BufferedWriter bw = null;
FileReader fr = null;
FileWriter wr = null;
try {
File srcFile = new File("hello.txt");
File endFile = new File("hello3.txt");

fr = new FileReader(srcFile);
wr = new FileWriter(endFile);

br = new BufferedReader(fr);
bw = new BufferedWriter(wr);

char[] mChar = new char[5];
int len;
while ((len = br.read(mChar)) != -1){
bw.write(mChar, 0, len);
}

System.out.print("复制成功");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null){

br.close();
}
} catch (IOException e) {
e.printStackTrace();
}

try {
if(bw != null){

bw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}

}

3,(字节流)图片的读取和写入

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
@Test
public void bufferedCopyImage() {
FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
File srcFile = new File("sun.jpg");
File endFile = new File("cSun2.jpg");

fis = new FileInputStream(srcFile);
fos = new FileOutputStream(endFile);

bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);

byte[] buffer = new byte[6];
int len;
while((len = bis.read(buffer)) != -1){
bos.write(buffer, 0, len);
}

System.out.print("复制成功");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bis != null){

bis.close();
}
} catch (IOException e) {
e.printStackTrace();
}

try {
if (bos != null){

bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}

}

图片的加密解密

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
//图片加密
@Test
public void ImageEncryption(){

BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {

bis = new BufferedInputStream(new FileInputStream("sun.jpg"));
bos = new BufferedOutputStream(new FileOutputStream("sunEcryptions.jpg"));

byte[] buffer = new byte[5];
int len;

while((len = bis.read(buffer)) != -1){

for(int i = 0; i < len; i++){
buffer[i] = (byte) (buffer[i] ^5);
}
bos.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(bis != null){

bis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(bos != null){

bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

//图片的解密
@Test
public void PicturesDecryption(){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {

bis = new BufferedInputStream(new FileInputStream("sunEcryptions.jpg"));
bos = new BufferedOutputStream(new FileOutputStream("sunDecryptions.jpg"));

byte[] buffer = new byte[5];
int len;

while((len = bis.read(buffer)) != -1){

for(int i = 0; i < len; i++){
buffer[i] = (byte) (buffer[i] ^5);
}
bos.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(bis != null){

bis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(bos != null){

bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

转换流

属于字符流

InputStreamReader:将一个字节的输入流转换为字符的输入流;(从文件中读取数据)

OutputStreamWriter:讲一个字符的输出流转换为字节的输出流;(把数据存储在文件中)

作用

提供字节流与字符流之间的转换