Java 进阶IO流(二)

一、字符流

1、FileReader文件字符写入流

把磁盘中的数据以字符的形式读入到内存中

import java.io.FileReader;
import java.io.IOException;

public class ClassStructure {
    public static void main(String[] args) throws IOException {
        int read = 0;
        //创建一个读入数据的相对路径的流
        FileReader fileReader = new FileReader("data/access.log");
        //直接读取字符输出
//        while((read = fileReader.read()) != -1){
//            System.out.printf("%c",read);
//        }

        //根据数组存储要求输出
        char[] by = new char[8];
        while((read = fileReader.read(by)) != -1){
            System.out.println(by);
        }
        //关闭读入流
        fileReader.close();
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2、FIleWriter文件字符输出流

把内存中的数据以字符的形式写出到磁盘中

• 构造器

• 常用方法

import java.io.*;

public class ClassStructure {
    public static void main(String[] args) throws IOException {
        int read = 0;
        //创建一个读入数据的相对路径的流
        FileReader fileReader = new FileReader("data/access.log");
        FileWriter fileWriter = new FileWriter("data/access1.log");
        //直接读取字符输出
        while((read = fileReader.read()) != -1){
            fileWriter.write(read);
        }

        //根据数组存储要求输出
        char[] ch = new char[8];
        while ((read = fileReader.read(ch)) != -1) {
            fileWriter.write(new String(ch, 0, read));
        }

        System.out.println("复制OK");

        fileWriter.flush();
        //关闭读入流
        fileReader.close();
        //关闭写出
        fileWriter.close();
    }
}


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

• 场景

字节流适合做文件数据的拷贝（音视频，文本）
字节流不适合读取中文内容输出
字符流适合做文本文件的操作（读，写）

二、缓冲流

1、概念

缓冲流是高效流或者高级流，前面学习的字节流算原始流
作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写性能

2、优化原理

字节缓冲输入流默认有8KB缓冲池，直接从缓冲池读取数据，性能较好。
字节缓冲输入流默认有8KB缓冲池，数据直接写入缓冲池中，提高写数据性能

3、体系图

4、字节缓冲流

1）BufferedInputStream字节缓冲输入流

提高字节输入流读取数据的性能

2）BufferedOutputStream字节缓存输出流

提高字节输出流读取数据的性能

import java.io.*;
import java.nio.charset.StandardCharsets;

public class ClassStructure {
    public static void main(String[] args) throws IOException {
        int read = 0;
        //创建一个读入数据的相对路径的流
        InputStream inputStream = new FileInputStream("data/access.log");
        //创建带有缓存的输入流
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        //创建一个数组
        byte[] by = new byte[1024];
        //判断是否还有数据
        while ((read = bis.read(by)) != -1) {
            //转换字符串
            String str = new String(by, 0, read);
            System.out.println(str);
        }
        //关闭写出
        bis.close();
        //关闭读入流
        inputStream.close();

        //创建一个输出数据的相对路径的流
        OutputStream outputStream = new FileOutputStream("data/access1.log");
        //创建带有缓存的输出流
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);
        //直接写入内容，设置编码格式
        bos.write("helloworld".getBytes(StandardCharsets.UTF_8));
        bos.close();
        outputStream.close();
    }
}


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

5、字符缓冲流

1）BufferedReader字符缓冲输入流

提高字符输入流读取数据的性能，可以按行读取数据

2）BufferedWriter字符缓冲输出流

提高字符输出流写取数据的性能，可以换行

import java.io.*;

public class ClassStructure {
    public static void main(String[] args) throws IOException {
        String msg = null;
        //创建一个字符输入流
        FileReader fr = new FileReader("data/access.log");
        //创建一个字符输入缓冲流
        BufferedReader br = new BufferedReader(fr);
        //判断是不是最后一行
        while ((msg = br.readLine()) != null) {
            System.out.println(msg);
        }
        //关闭输入缓冲流
        br.close();

        //创建一个字符输出流
        FileWriter fw = new FileWriter("data/access1.log");
        //创建一个字符输出缓冲流
        BufferedWriter bw = new BufferedWriter(fw);
        //字符写入的内容
        bw.write("china");
        //关闭字符缓冲流
        bw.close();
    }
}


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

三、转换流

文件和代码编码不一致，会出现乱码

1、InputStreamReader字符输入转换流

把原始的字节流按照指定编码转换成字符输入流

import java.io.*;

public class ClassStructure {
    public static void main(String[] args) throws IOException {
        int len = 0;
        //创建一个InputStreamReader对象，FileInputStream构造一个原始的字节流按照指定编码转换成字符输入流
        InputStreamReader gbk = new InputStreamReader(new FileInputStream("data/access1.log"),"GBK");

        //判断是不是最后一行
        while ((len = gbk.read()) != -1) {
            System.out.print((char)len);
        }
        System.out.println();
        //释放资源
        gbk.close();
        InputStreamReader utf = new InputStreamReader(new FileInputStream("data/access1.log"),"utf8");
        while ((len = utf.read()) != -1) {
            System.out.print((char)len);
        }
        utf.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2、OutputStreamWriter字符输出转换流

把字节输出流按照指定编码转换成字符输出流

import java.io.*;

public class ClassStructure {
    public static void main(String[] args) throws IOException {

        //字节输出流指定编码格式
        OutputStreamWriter gbk = new OutputStreamWriter(new FileOutputStream("data/access1.log"), "GBK");
        //写入内容
        gbk.write("china,我爱你!!!");
        //释放资源
        gbk.close();
        OutputStreamWriter gbk1 = new OutputStreamWriter(new FileOutputStream("data/access2.log"), "utf-8");
        gbk1.write("china,我爱你!!!");
        gbk1.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16