凉冰的手记
凉冰
2023-06-30
目录

字符流

# 字符流

# 字符集

# ASCII

  • 这个字符集只能存储 英文和数字,以及一些常用字符；不能存储中文
  • 最大到127，一个字节就可以存储；
  • 不足8位的，前面补0；计算机存储的最小单位是字节****，就是8个bit，需要8位才能存储。

# GBK

  • windows 系统默认就是 GBK 编码

  • GBK 编码 完全兼容 ASCII码
  • 英文在GBK字符集下的编码方式与ASCII字符集是一样的；都是补0

  • GBK 存储中文的时候
    • 汉字要用两个字节存储
      • --- 汉字太多了，一个字节存不下，三个字节太浪费了，两个刚刚好
    • 高位字节二进制一定以1开头，转换成十进制之后是一个负数
      • 就是为了和英文区分开；英文都是以0开头；中文都是以1开头

  • GBK字符集下 汉字的编码与解码
    • 高位 补1

  • 中文与英文在GBK字符集下的对比

  • 编码练习 --- 区分中英文

  • 总结
    • 中文占两个字节，二进制高位字节的第一位是1
    • 英文占一个字节，二进制第一位是0

# Unicode

  • Unicode字符集的编码方式

    • UTF-8

      • 1--4个可变字节

    • UTF-16

      • 用2--4个字节保存

    • UTF-32

      • 固定使用4个字节保存

  • UTF-8

  • 练习

  • 总结

    1. 一个英文 占 一个字节，二进制第一位是0，转换成十进制是正数
    2. 一个中文 占 三个字节，二进制第一位是1，第一个字节转换成十进制是负数

# 乱码

  • 读取数据时未读完整个汉字

  • 编码和解码的方式不统一

  • 如何解决？即如何不产生乱码

    • 不要用字节流读取文本文件
    • 编码，解码使用一个码表，同一种编码方式

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

# 字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

  • public void close() ：关闭此流并释放与此流相关联的任何系统资源。
  • public int read()： 从输入流读取一个字符。
  • public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

# 字符输入流-底层原理

  • 字符输入流在创建的时候，会创建一个缓冲区(在内存中)，大小为byte[8192]

  • 第一次调用read()方法时，会从文件读取 8192个字节的内容到缓存区

  • 后续读取数据的时候，会先在缓存区读，当缓冲区读到头时，会重新从文件加载数据到缓冲区。

    • 输入流与输出流交错
    /**
 * @ClassName FileWriter
 * @Date 2023/3/3 15:24
 * @Author diane
 * @Description
 *      字符输入流，，在关联文件的同时，会创建一个缓冲区，大小为 bytes[8192]
 *      字符输出流，，在创建输出流的时候，如果不指定append为true，会清空原文件内容
 * @Version 1.0
 */
public class CharStreamDemo {
    public static void main(String[] args) throws IOException {
        // 先读取一次，，， 会将内容装入缓冲区
        FileReader fr = new FileReader("D:\\tmp\\1.txt");
        fr.read();

        // 创建输出流对象，会清空原文件内容
        FileWriter fw = new FileWriter("D:\\tmp\\1.txt");

        // 创建输出流对象，虽然会清空文件，，但是输入流fr还可以从缓冲区读取到数据
        int ch;
        while ((ch = fr.read()) != -1) {
            System.out.print((char) ch);
        }


        fw.close();
        fr.close();

    }
}

  • 输入流 缓冲区 详解

    • 创建8194个字符的文件 a(8192)bc

    • 创建字符输入流，创建一个byte[8192]，limit字段为0

    • 第一次read,缓冲区载入8192个a，limit字段为 8192

    • 循环结束后，第二次read，缓冲区中的数据已经读完了，需要重新读取文件数据到缓冲区。

      • 覆盖写，不会清空原来的数据。 缓冲区:bca(8190)

      • limit字段，为2，即限制读取2个，就结束了

      • 不用担心，采用覆盖写的方式，当文件本该结束的时候，再读到'a'

    • 在去read，就会输出-1

    /**
 * @ClassName Demo
 * @Date 2023/3/3 15:59
 * @Author diane
 * @Description 读取数据超过 8192 的文件情况
 * @Version 1.0
 */
public class Demo {
  public static void main(String[] args) throws IOException {

    // 创建文件
    FileWriter fw = new FileWriter("D:\\tmp\\1.txt");

    for (int i = 0; i < 8192; i++) {
      fw.write('a');
    }
    fw.write('b');
    fw.write('c');

    fw.close();


    // 读取文件
    FileReader fr = new FileReader("D:\\tmp\\1.txt");
    for (int i = 0; i < 8192; i++) {
      System.out.println((char) fr.read());
    }
    // 缓冲区中的 数据读完了， 在次将文件数据读入缓冲区
    // 此时文件只剩下 bc
    // 读入缓冲区的时候，是覆盖写，不会删除原来的数据 ---- 缓冲区：bca(8190)
    System.out.println((char) fr.read()); // b
    System.out.println((char) fr.read()); // c

    // 这里读的时候 不会读取缓冲区的下一个字符 a
    // 因为文件真实数据已经结束了
    // 会有一个字段 limit = 2 来限制 可以在缓冲区中读取多少个字符
    System.out.println(fr.read());// -1
  }
}

# FileReader类

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

小贴士：

  1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

    idea中UTF-8

  2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

# 构造方法

  • FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
  • FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

  • 构造举例，代码如下：
public class FileReaderConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);
      
        // 使用文件名称创建流对象
        FileReader fr = new FileReader("b.txt");
    }
}

# 读取字符数据

  1. 读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：
    • 英文读取一个字节，汉字会读取多个字节-根据不同的编码方式来确定(UTF-8 三个字节；GBK-两个字节)
    • 方法的返回值 是 该字符在 字符集上的数字，为10进制；要想转换成字符的话，需要用char 强转
public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：
黑
马
程
序
员

小贴士：虽然读取了一个字符，但是会自动提升为int类型。--- 字符集上对应的十进制数字

  1. 使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ，代码使用演示：
    • read(chars) 读取数据，解码，强转，放到char数组中
public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
         char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：
黑马
程序
员序

获取有效的字符改进，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
        char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
    	// 关闭资源
        fr.close();
    }
}

输出结果：
黑马
程序
员

# 字符输出流【Writer】

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

  • void write(int c) 写入单个字符。
  • void write(char[] cbuf)写入字符数组。
  • abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
  • void write(String str)写入字符串。
  • void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
  • void flush()刷新该流的缓冲。
  • void close() 关闭此流，但要先刷新它。

# 字符输出流-底层原理

  • 字符输出流创建的时候，会在内存中创建一个byte[8192]的缓冲区。

  • 输出数据的时候，会先将数据写入缓冲区，后续在写入文件。

    • 当缓冲区满了，会自动写入文件。
    • 调用flush()方法，刷新缓冲区，会将缓存区数据写入文件
    • 调用close()方法，在断开连接前，会先刷新缓冲区，在关闭。
    /**
 * @ClassName Demo
 * @Date 2023/3/3 15:59
 * @Author diane
 * @Description 输出缓冲区
 *  输出数据的时候，会先将数据写入缓冲区，后续在写入文件。
 *      当缓冲区满了，会自动写入文件。
 *      调用flush()方法，刷新缓冲区，会将缓存区数据写入文件
 *      调用close()方法，在断开连接前，会先刷新缓冲区，在关闭。
 *
 *
 * @Version 1.0
 */
public class FileWriteBufferDemo {
  public static void main(String[] args) throws IOException {

    // 创建文件
    FileWriter fw = new FileWriter("D:\\tmp\\1.txt");

    for (int i = 0; i < 8192; i++) {
      fw.write('a');
    }
    // 缓冲区满了，会将缓冲区中的数据 写入缓冲区
    fw.write('b');
   	// 调用flush 方法，将缓冲区数据写入文件
    fw.flush();
    fw.write('c');

    fw.close();
  }
}

# FileWriter类

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

# 构造方法

  • FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
  • FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

  • 构造举例，代码如下：
public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");
    }
}

# 基本写出数据

写出字符：write(int b) 方法，每次可以写出一个字符数据，代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 写出数据
      	fw.write(97); // 写出第1个字符
      	fw.write('b'); // 写出第2个字符
      	fw.write('C'); // 写出第3个字符
      	fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
      
      	/*
        【注意】关闭资源时,与FileOutputStream不同。
      	 如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        */
        // fw.close();
    }
}
输出结果：
abC田

小贴士：

  1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
  2. 未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

# 关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

  • flush ：刷新缓冲区，流对象可以继续使用。
  • close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");
        // 写出数据，通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();
        fw.write('新'); // 继续写出第2个字符，写出成功
        fw.flush();
      
      	// 写出数据，通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }
}

小贴士：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

# 写出其他数据

  1. 写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串转换为字节数组
      	char[] chars = "黑马程序员".toCharArray();
      
      	// 写出字符数组
      	fw.write(chars); // 黑马程序员
        
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
        fw.write(b,2,2); // 程序
      
      	// 关闭资源
        fos.close();
    }
}
  1. 写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，代码使用演示：
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串
      	String msg = "黑马程序员";
      
      	// 写出字符数组
      	fw.write(msg); //黑马程序员
      
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
        fw.write(msg,2,2);	// 程序
      	
        // 关闭资源
        fos.close();
    }
}
  1. 续写和换行：操作类似于FileOutputStream。
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象，可以续写数据
        FileWriter fw = new FileWriter("fw.txt"，true);     
      	// 写出字符串
        fw.write("黑马");
      	// 写出换行
      	fw.write("\r\n");
      	// 写出字符串
  		fw.write("程序员");
      	// 关闭资源
        fw.close();
    }
}
输出结果:
黑马
程序员

小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流

#知识#Java
上次更新: 2023 07 3
字节流
IO异常处理

← IO异常处理→

最近更新
01
数据层解决方案
07-03
02
第三方技术整合
07-03
03
原理篇
07-03
更多文章>
Theme by Vdoing | Copyright © 2023-2023 by 凉冰
FIND YOU
G_E_M_ 邓紫棋