IO流 - java

字符集

ASCLL 码 （美国信息交换标准代码） 最高位为0 每个字符一个字节

GBK （汉字内码扩展规范） 汉字两个字节， 英文一个字节

Unicode

UTF-32 每个字符 4字节

UTF-8 （变长字符编码）汉字3字节， 字符1字节

怎么区分用几个字节存储

3字节 1110xxxx 10xxxxxx 10xxxxxx

2字节 110xxxx 10xxxxxx

1字节 0xxxxxxx

IO流

按方向分

  • 输入流
  • 输出流

按内容分

  • 字节流

    数据转移更好

    • 输入 - InputStream
    • 输出 - OutputStream

  • 字符流

    读写文本内容 更好

    • 输入 - Reader
    • 输出 - Writer
字节输入 字节输出 字符输入 字符输出
抽象类 InputStream OutputStream Reader Writer
原始流 FileInputStream FileOutputStream FileReader FileWriter
缓存流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
转换流 InputStreamReader OutputStreamWriter
打印流 PrintStrem PrintWriter
数据流 DataInputStream DataOutputStream
序列化流 ObjectInputStream ObjectOutputStream

字节流

  • 文件字节输入流

    以内存为基准，可以把磁盘中数据以字节的形式读到内存中

    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
    //与文件相连
    InputStream is = new FileInputStream("a.txt");//File file 或 String pathname

    //开始读取
    int b1 = is.read(); // 读取一个字节 无数据返回-1

    int b;
    while((b = isread()) != -1){
      System.out.print((char) b);
    }


      
    //读取多个字节

    byte[] buffer = new byte[3];

    int len = is.read(buffer);
    String rs = new String(buffer);

    while((len = isread(buffer)) != -1){
      //读多少 输出多少
      String rs = new String(buffer, 0, len);
      System.out.print(rs);
    }

    //一次读取整个文件

    File f = new File("a.txt");
    long size = f.length();
    byte[] buffer = new byte[(int) size];

    int len = is.read(buffer);
    String rs = new String(buffer);


    // 第二种方法
    buffer = is.readAllBytes();

    // 关闭
    is.close();

  • 文件字节输出流

    以内存为基准，可以把内存中数据以字节的形式输出到文件中

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    OutputStream os = new FileOutputStream("a.txt");
    // 追加数据
    OutputStream os = new FileOutputStream("a.txt", true);

    //开始写一个字节
    os.write('b'); 

    //多个
    byte[] buffer = "我".getBytes();
    os.write(buffer);

    os.write(buffer, start, len);



    os.close();

字符流

  • 字符输入流

    以内存为基准，把文件中的数据以字符的形式读入内存中去。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    try(
    		Reader fr = new FileReader("1.txt");
    ){
      
      //单次字符
      int c;
      while((c = fr.read()) != -1){
        	System.out.print((char) c);
      }
      //多个字符
      char[] buffer = new char[3];
      int len;
      while((len = fr.read(buffer) != -1)){
        System.out.print(new String(buffer, 0, len));
      }
      
      
    } 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
    try(
    		Writer fw = new FileWriter("1.txt");
    ){
      
      //开始写一个字符
    	fw.write('b'); 
      
      //开始写字符串
    	fw.write('bsss'); 
    	
    //多个
    char[] buffer = {"我", "ni"};
    fw.write(buffer);

    fw.write(buffer, start, len);
      
      //刷新流
      fw.flush();
      
      
    } catch(Exception e){
      	e.printStackTrace();
    }

缓冲流

对原始流进行包装，提高原始流读写数据的性能，自带8K的缓冲池

对于字符缓存输入流，增加了readLine()方法

对于字符缓存输出流，增加了newLine()方法 进行换行

转换流

当代码编码与被读取的文本编码不同时，使用字符流读取文本会出现乱码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
try(
  //读取原始GBK的字节流
		InputStream is = new FileInputStream("1.txt");
  Reader isr = new InputStreamReader(is, "GBK");
  BufferedReader br = new BufferedReader(isr);
){
  
  
  }
  
  
} catch(Exception e){
  	e.printStackTrace();
}

打印流

更方便更高效的打印数据出去，能实现打印啥出去就是啥。

可以用于out的重定向

数据流

允许把数据和其类型一并写出去

序列化流

可以吧java对象进行序列化，把java对象存入文件中去。

对象实现序列化需要实现序列化接口

修饰符 transient 使成员变量不参与序列化