Java IO流之字符流

最新推荐文章于 2021-11-09 15:01:50 发布

skz980619

最新推荐文章于 2021-11-09 15:01:50 发布

阅读量80

点赞数

分类专栏： Java基础知识点总结

本文链接：https://blog.csdn.net/skz980619/article/details/119753601

版权

Java基础知识点总结专栏收录该内容

38 篇文章 0 订阅

订阅专栏

字符流

为什么会出现字符流

由于字节流操作中文不是特别方便，所以java就提供了字符流

字符流 = 字节流 + 编码表

FileInputStream fis = new FileInputStream("myCharStream\\a.txt");

int by;
while ((by = fis.read()) != -1) {
    System.out.println((char) by);
}

fis.close();
/*
    一个汉字存储：
        如果是GBK编码，占用两个字节
        如果是utf-8编码，占用三个字节
 */

输出：
在这里插入图片描述

用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？

汉字在存储的时候，无论是选择哪种编码存储，第一个字节都是负数

String s = "abc"; //[97, 98, 99]
String s = "中国"; //[-28, -72, -83, -27, -101, -67]
byte[] bys = s.getBytes(); 
byte[] bys = s.getBytes(StandardCharsets.UTF_8); //[-28, -72, -83, -27, -101, -67]
byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
System.out.println(Arrays.toString(bys));

编码表

基础知识：

计算机中存储的信息都是用二进制数表示的，我们在屏幕上看到的英文、汉字等字符都是二进制数转换之后的结果
按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。按照A规则存储，必须按照A编码解析，这样才能显示正确的文本，否则就会导致乱码现象
- 字符编码：就是一套自然语言的字符与二进制数之间的对应规则（A， 65）

字符集：

是一个系统支持的所有字符的集合包括各个国家的文字，标点符号、图形符号、数字等。
计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。
常见的字符集有ASCII字符集、GBK字符集、Unicode字符集等

Unicode字符集：

为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。它最多使用4个字节的数字来表达字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最常用的是UTF-8。

字符串中的编码解码问题

编码：

byte[] getBytes(): 使用平台默认的字符集将该String编码为一系列字节，将结果存储到新的字节数组中

//定义一个字符串
String s = "中国";
byte[] bys = s.getBytes();//[-28, -72, -83, -27, -101, -67]
System.out.println(Arrays.toString(bys));

byte[] getBytes(String charsetName): 使用指定的字符集将该String编码为一系列字节，将结果存储到字节数组中

//定义一个字符串
String s = "中国";
byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]
byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6
System.out.println(Arrays.toString(bys));

解码：

String(byte[] bytes): 通过使用平台默认的字符集解码指定的字节数组来构造新的String

//定义一个字符串
String s = "中国";
byte[] bys = s.getBytes();//[-28, -72, -83, -27, -101, -67]
String ss = new String(bys); //中国
System.out.println(ss);

String(byte[] bytes, String charsetName): 通过指定的字符集解码指定的字节数组来构造新的String。

//定义一个字符串
String s = "中国";
byte[] bys = s.getBytes();//[-28, -72, -83, -27, -101, -67]
String ss = new String(bys, "UTF-8"); //中国
String ss = new String(bys, "GBK"); //涓浗
System.out.println(ss);

字符流中的编码解码问题

字符流抽象基类

Reader: 字符输入流的抽象类
Writer: 字符输出流的抽象类

字符流中和编码解码问题相关的两个类：

InputStreamReader
OutputStreamReader

//FileOutputStream fos = new FileOutputStream("myCharStream\\osw.txt");
//OutputStreamWriter osw = new OutputStreamWriter(fos);

//OutputStreamWriter的第一种构造方法
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
//OutputStreamWriter的第二种构造方法
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"), "UTF-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"), "GBK");
osw.write("中国");
osw.close();

//FileInputStream fis = new FileInputStream("myCharStream\\osw.txt");
//InputStreamReader isr = new InputStreamReader(fis);
InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"));
InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"), "GBK");

//一次读取一个字符数据
int ch;
while ((ch = isr.read()) != -1) {
    System.out.print((char) ch); //中国
}
isr.close();

字符流写数据的5种方式

void write(int c): 写一个字符

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));

osw.write(97);
osw.flush();

void write(char[] cbuf): 写入一个字符数组

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
char[] chs = {'a', 'b', 'c', 'd', 'e'};
osw.write(chs);
osw.close();

void write(char[] cbuf, int off, int len): 写入字符数组的一部分

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));

osw.write(chs, 0, chs.length);
osw.write(chs, 1, 3);

osw.close();

void write(String str): 写一个字符串

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));

osw.write("abcde");

osw.close();

void write(String str, int off, int len): 写一个字符串的一部分

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));

osw.write("abcde", 0, "abcde".length());
osw.write("abcde", 1, 3);

osw.close();

flush()和close()的区别：

flush(): 刷新流，还可以继续写数据
close(): 关闭流，释放资源，但是在关闭之前会先刷新流，一旦关闭，就不能再写数据

字符流读数据的两种方式

int read(): 一次读一个数据

int read(char[] cbuf): 一次读一个字符数组的数据

 InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"));
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));

//一次读一个字符数据
int ch;
while ((ch = isr.read()) != -1) {
    System.out.print((char) ch);
}

//一次读一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len = isr.read(chs)) != -1) {
    System.out.print(new String(chs, 0, len));
}

//释放资源
isr.close();

案例—复制Java文件

需求：把模块目录下的"ConversionStreamDemo.java"复制到模块目录下的"Copy.java"

import java.io.*;

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\Copy.java"));

        //一次读写一个字符数据
        int ch;
        while ((ch = isr.read()) != -1) {
            osw.write(ch);
        }


        //一次读写一个字符数组
//        char[] chs = new char[1024];
//        int len;
//        while ((len = isr.read(chs)) != -1) {
//            osw.write(chs, 0, len);
//        }

        isr.close();
        osw.close();
    }
}

改进版：

需求：把模块目录下的"ConversionStreamDemo.java"复制到模块目录下的"Copy.java"

FileReader: 用于读取字符文件的便捷类
- FileReader(String fileName)
FileWriter: 用于写入字符文件的便捷类
- FileWriter(String fileName)

FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
FileWriter fw = new FileWriter("myCharStream\\Copy.java");

//一次读取一个字符数据
//        int ch;
//        while ((ch = fr.read()) != -1) {
//            fw.write(ch);
//        }

//一次读取一个字符数组
char[] chs = new char[1024];
int len;
while ((len = fr.read(chs)) != -1) {
    fw.write(chs, 0, len);
}

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

字符缓冲流

字符缓冲流：

BufferedWriter: 将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接收默认大小，默认值足够大，可用于大多数用途
BufferedReader: 从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小，默认值足够大，可用于大多数用途。

构造方法：

BufferedWriter(Writer out)
BufferedReader(Reader in)

//BufferedWriter(Writer out)
//FileWriter fw = new FileWriter("myCharStream\\bw.txt");
//BufferedWriter bw = new BufferedWriter(fw);
BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\\\bw.txt"));

bw.write("hello\n");
bw.write("word\n");

bw.close();

BufferedReader br = new BufferedReader(new FileReader("myCharStream\\bw.txt"));

//一次读一个字符数据
//int ch;
//while ((ch = br.read()) != -1) {
//System.out.print((char) ch);
//}

//一次读一个字符数组
char[] chs = new char[1024];
int len;
while ((len = br.read(chs)) != -1) {
    System.out.println(new String(chs, 0, len));
}

br.close();

案例—复制Java文件（字符缓冲流改进版）

BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));

//一次读取一个字符数据
//int ch;
//while ((ch = br.read()) != -1) {
//    bw.write(ch);
//}

//一次读取一个字符数组
char[] chs = new char[1024];
int len;
while ((len = br.read(chs)) != -1) {
    bw.write(chs, 0, len);
}

bw.close();
br.close();

字符缓冲流特有功能

BufferedWriter:

void newLine(): 写一行行分隔符，行分隔符字符串由系统属性定义

//创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\bw.txt"));

//写数据
for (int i = 0; i < 10; i++) {
    bw.write("hello" + i);
    //            bw.write("\n"); //只适用于windows系统，不好
    bw.newLine();
    bw.flush();
}

//释放资源
bw.close();

BufferedReader:

public String readLine(): 读一行文字，结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null，只读内容，不读换行的符号，要自己添加换行符

//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("myCharStream\\bw.txt"));

//读数据
//第一次读取数据
//String line = br.readLine();
//System.out.println(line);
//第二次读取数据
//line = br.readLine();
//System.out.println(line);
//再多读两次
//line = br.readLine();
//System.out.println(line); //null

String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}
br.close();

案例—复制Java文件（字符缓冲流特有功能改进版）

//创建字符缓冲流对象
BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));

//读写数据
String line;
while ((line = br.readLine()) != null) {
    bw.write(line);
    bw.newLine();
    bw.flush();
}

br.close();
bw.close();

IO流小结

在这里插入图片描述

skz980619

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java IO流之字符流

字符流为什么会出现字符流由于字节流操作中文不是特别方便，所以java就提供了字符流字符流 = 字节流 + 编码表FileInputStream fis = new FileInputStream("myCharStream\\a.txt");int by;while ((by = fis.read()) != -1) { System.out.println((char) by);}fis.close();/* 一个汉字存储：如果是GBK编码，占用
复制链接

扫一扫

专栏目录