java IO流【常用流对象二】

常用流对象

4 转换流

• InputstreamReader/OutputstreamWriter用来实现将字节流转化成字符流。
• 比如：
  • System.in是字节流对象，代表键盘的输入，如果我们想按行接收用户的输入时，就必须用到缓冲字符流BufferedReader特有的方法readLine()，但是经过观察会发现在创建BufferedReader的构造方法的参数必须是一个Reader对象，这时候我们的转换流InputStreamReader就派上用场了。
  • System.out也是字节流对象，代表输出到显示器，按行读取用户的输入后，并且要将读取的一行字符串直接显示到控制台，就需要用到字符流的write(Stringstr方法，所以我们要使用OutputstreamWriter将字节流转化为字符流。

4.1 通过转换流实现键盘输入屏幕输出

package IO流;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/**
 * @author 缘友一世
 * date 2022/10/21-16:23
 */
public class ConvertStream {
    public static void main(String[] args) {
        BufferedReader bufferedReader=null;
        BufferedWriter bufferedWriter=null;
        try {
            bufferedReader=new BufferedReader(new InputStreamReader(System.in));
            bufferedWriter=new BufferedWriter(new OutputStreamWriter(System.out));
            while (true) {
                bufferedWriter.write("请输入：");
                bufferedWriter.flush();
                String input= bufferedReader.readLine();
                if("exit".equals(input)) {
                    break;
                }
                bufferedWriter.write("你输入的是："+input);
                bufferedWriter.newLine();
                bufferedWriter.flush();
            }


        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedReader!=null) {
                    bufferedReader.close();
                }
                if(bufferedWriter!=null) {
                    bufferedWriter.close();
                }
            }catch (Exception 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

4.2 通过字节流读取文本并添加行号

package IO流;

import java.io.*;

/**
 * @author 缘友一世
 * date 2022/10/21-17:13
 */
public class LineNumberDemo2 {
    public static void main(String[] args) {
        BufferedReader bufferedReader=null;
        BufferedWriter bufferedWriter=null;
        try {
            bufferedReader=new BufferedReader(new InputStreamReader(new FileInputStream("basic grammar/src/IO流/write.txt")));
            //bufferedReader=new BufferedReader(new InputStreamReader(new FileInputStream("basic grammar/src/IO流/")));
            //BufferedReader：将字符流放到字符流缓冲区
            //InputStreamReader：将字节流转化为字符流
            //FileInputStream：字节流
            bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("basic grammar/src/IO流/write.txt",true)));
            String temp="";
            int i=1;
            while((temp=bufferedReader.readLine())!=null) {
                bufferedWriter.write(i+":"+temp);
                bufferedWriter.newLine();
                i++;
            }
            bufferedWriter.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedReader!=null) {
                    bufferedReader.close();
                }
                if(bufferedWriter!=null) {
                    bufferedWriter.close();
                }
            }catch (Exception 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

5 字符输出流【PrintWriter】

• 在java的IO流中专门提供了用于字符输出的流对象PrintWriter。
• 该对象具有自动行刷新缓冲字符输出流，特点是可以按行写出字符串，并且可通过printin();方法实现自动转换。

package IO流;

import java.io.*;

/**
 * @author 缘友一世
 * date 2022/10/21-17:53
 */
//PrintWriter的使用
public class LineNumberDemo3 {
    public static void main(String[] args) {
        BufferedReader bufferedReader=null;
        PrintWriter printWriter=null;//自带换行和刷新
        try {
            bufferedReader=new BufferedReader(new InputStreamReader(new FileInputStream("basic grammar/src/IO流/write.txt")));
            printWriter=new PrintWriter("basic grammar/src/IO流/write2.txt");
            String temp="";
            int lineNumber=1;
            while ((temp=bufferedReader.readLine())!=null) {
                printWriter.println(lineNumber+"："+temp);
                lineNumber++;
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedReader!=null) {
                    bufferedReader.close();
                }
                if(printWriter!=null) {
                    printWriter.close();
                }
            }catch (Exception 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

• java中的IO流k的组合是非常灵活的，输入时只考虑输入的处理过程，输出时只考虑输出的处理过程。
• 如上面的例子，输入时，采用字符流的方式处理，将文件的内容读到缓存里；输出时，采用字节流输出。

6 字节数组流

• ByteArraylnputStream和ByteArrayOutputStream经常用在需要流和数组之间转化的情况！

6.0 getBytes()知识补充

• Java对字符的编码

6.1 字节数组输入流

• Filelnputstream是把文件当做数据源。ByteArrayinputstream则是把内存中的字节数组对象“当做数据源。

package IO流;

import java.io.ByteArrayInputStream;

/**
 * @author 缘友一世
 * date 2022/10/21-21:39
 */
public class ByteArrayInputDemo {
    public static void main(String[] args) {
        //A ByteArrayInputStream包含一个内部缓冲区，其中包含可以从流中读取的字节。 内部计数器跟踪read方法要提供的下一个字节。
        // 关闭ByteArrayInputStream没有任何效果。 在关闭流之后，可以调用此类中的方法，而不生成IOException。
        ByteArrayInputStream bis=null;
        byte[] arr="abcdef".getBytes();
        StringBuilder sb=new StringBuilder();
        try {
            //该构造方法中的参数是一个字节数组，该字节数组就是数据源
            bis=new ByteArrayInputStream(arr);
            int temp;
            //从该输入流读取下一个数据字节。
            while ((temp=bis.read())!=-1) {
                sb.append((char)temp);
            }
            System.out.println(sb);//返回表示此顺序中的数据的字符串。
        }finally {
            try {
                if(bis != null) {
                    bis.close();
                }
            }catch (Exception 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

6.2 字节数组输出流

• ByteArrayOutputStream对象是将流中的数据写到字节数组中。

package IO流;

import java.io.ByteArrayOutputStream;

/**
 * @author 缘友一世
 * date 2022/10/21-21:56
 */
public class ByteArrayOutputDemo {
    public static void main(String[] args) {
        ByteArrayOutputStream bos=null;
        try {
            //StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是StringBuilder对象中的内容是可变的
            StringBuilder sb=new StringBuilder();
            bos=new ByteArrayOutputStream();
            bos.write('q');
            bos.write('p');
            bos.write('m');
            bos.write('n');
            byte[] arr=bos.toByteArray();
            for (byte b : arr) {
                sb.append((char)b);
            }
            System.out.println(sb);
        }finally {
            try {
                if(bos!=null) {
                    bos.close();
                }
            }catch (Exception 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

7 数据流

• 数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式。
• 从底层输入输出流中操作Java基本数据类型与字符串类型。
• DatalnputStream和DataOutputStream提供了可以存取与机器无关的所有Java基础类型数据【int、double、string】的方法。

7.1 数据流

package IO流;

import java.io.*;

/**
 * @author 缘友一世
 * date 2022/10/21-22:32
 */
public class DataOutputDemo {
    public static void main(String[] args) throws IOException {
        //数据流是一个处理流，但是最后还是要使用节点流对数据进行读写
        //BufferedOutputStream字节的缓冲流对象
        DataOutputStream dos=new DataOutputStream(new BufferedOutputStream(new FileOutputStream("basic grammar/src/IO流/data.txt")));
        dos.writeChar('a');
        dos.writeDouble(Math.random());
        dos.writeUTF("hello world");
        dos.flush();
        dos.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

以字节的方式写入不同类型的数据，然后编码和解码，就会出现乱码

• 编码：把字符按照指定字符集编码成字节
• 解码：把字节按照指定字符集解码成字符
• 字符在计算机中的存储与读取：
  • 存储：字符 --> 码值 --> 二进制 --> 存储
  • 读取：二进制 --> 码值 --> 字符 --> 显示

更深入详细的内容参看大佬的博客:【精炼易懂】字符集、编码、乱码问题、ASCII、GBK、Unicode、UTF-8详解+实例说明

7.2 数据输入流

package IO流;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;

/**
 * @author 缘友一世
 * date 2022/10/21-23:07
 */
public class DataInputDemo {
    public static void main(String[] args) {
        DataInputStream dis=null;
        try {
            dis= new DataInputStream(new BufferedInputStream(new FileInputStream("basic grammar/src/IO流/data.txt")));
            //直接读取数据，注意：读取的顺序与写入的顺序一直，否则不饿能正确读取数据
            System.out.println(dis.readChar());
            System.out.println(dis.readDouble());
            System.out.println(dis.readUTF());
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(dis!=null) {
                    dis.close();
                }
            }catch (Exception 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