Java--IO流--字符流

前言

之前写过一篇关于IO流介绍的博客，也写了一篇字节流介绍的文章，这篇博客就给大家分享一下字符流的一些内容，按照国际惯例，首先上字符流的全家福，然后我将分享一下我们常用的字符流，比如：

字符流

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

字符输入流（Reader）

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

构造方法

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

FileReader类

java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
值得注意的是有如下两点：

• 字节与字符的对应规则，Windows系统的中文编码默认是GBK编码表，然而IDEA中默认的编码表示UTF-8
• 在字节缓冲区中，一个字节数组，用来临时存储字节数据

构造方法

• 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");
    }
}

接下来介绍如何使用字符流读取字符数据。

读取字符数据

• 读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用如下：

public class FRRead {
    public static void main(String[] args) throws IOException {
       // 使用文件名称创建流对象  
       FileReader fr = new FileRe
              FileReader fr = new FileReader("read.txt"); 
       // 定义变量，保存数据  
        int b ；
        // 循环读取
        while ((b = fr.read())!=‐1) {
            System.out.println((char)b);
        }
// 关闭资源        
        fr.close();
    }
}
输出结果：
孙
行
者
悟
空

值得注意的是，虽然读取了一个字符，但是会自动提升为int类型。

• 使用字符数组读取：read(char[ ] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 -1 ，代码使用如下：

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抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• public abstract void close()：关闭此输出流并释放与此流相关联的任何系统资源
• public abstract void flush()：刷新此输出流并强制任何缓冲的输出字符被写出
• public void write(int c)：写出一个字符
• public void write(char[ ] cbuf)：将b.length字符从指定的字符数组写出此输出流
• public abstract void write(char[ ] b, int off, int len)：从指定的字符数组写出len字符，从偏移量off开始输出到此输出流
• public void write(String str)：写出一个字符串

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田

值得注意的是虽然参数为int类型，四个字节，但是会保留一个字符的信息写出，其次就是未调用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方法来释放系统资源。

其他数据

• 字符数组：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();
   }
}

• 字符串：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); //黑马程序员
              fw.write(msg); //黑马程序员  
     
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。        
        fw.write(msg,2,2); // 程序  
       
        // 关闭资源
        fos.close();
    }
}

• 续写和换行：操作类是于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();
    }
}
输出结果:
唐僧
西游记

这方面需要注意的是，字符流只能操作文本文件，不能操作图片、视频等非文本文件，当我们单纯读或者写文本文件时，使用字符流，其他情况使用字节流。

字符缓冲流

构造方法

• public BufferedReader(Reader in)：创建一个新的缓冲输入流。
• public BufferedWriter(Writer out)：创建一个新的缓冲输入流。
  举例如下：

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

字符缓冲流的特有方法

字符缓冲流的基本方法与普通字符流调用方式一样，所以可以看看上面，下面介绍一下它们具备的特有的方法。

• BufferedReader：public String readLine( )：读取一行文字。
• BufferedWriter：public void newLine( )：写一行行分隔符，有系统属性定义符号。

readLine方法演示如下：

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建流对象  
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字        
        String line  = null;
       // 循环读取,读取到最后返回null  
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("‐‐‐‐‐‐");
        }
// 释放资源        
        br.close();
    }
}

newLine方法演示如下：

public class BufferedWriterDemo throws IOException {
    public static void main(String[] args) throws IOException  {
       // 创建流对象  
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));        
       // 写出数据  
        bw.write("唐僧");
       // 写出换行  
        bw.newLine();
        bw.write("西游");
        bw.newLine();
        bw.write("记");
        bw.newLine();
// 释放资源        
        bw.close();
    }
}
输出效果:
唐僧
西游

记

应用（文本排序）

1. 定位：
   首先我们要确定要解决的内容是什么，在那里，将其准确定位。
2. 分析：
   逐行读取文本信息
   解析文本信息到集合中
   遍历集合，按顺序，写出文本信息
3. 实现：

public class BufferedTest {
    public static void main(String[] args) throws IOException {
        // 创建map集合,保存文本数据,键为序号,值为文字
        HashMap<String, String> lineMap = new HashMap<>();
        // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("aim.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
        // 读取数据
        String line  = null;
        while ((line = br.readLine())!=null) {
            // 解析文本
            String[] split = line.split("\\.");
            // 保存到集合
            lineMap.put(split[0],split[1]);
        }
        // 释放资源
        br.close();
        // 遍历map集合
        for (int i = 1; i <= lineMap.size(); i++) {
            String key = String.valueOf(i);
            // 获取map中文本
            String value = lineMap.get(key);
           // 写出拼接文本  
            bw.write(key+"."+value);
           // 写出换行  
            bw.newLine();
        }
// 释放资源        
        bw.close();
    }
}

字符流是针对文本文件的，但是文本文件有各种字符编码，所以接下这篇博客给大家介绍字符转换流，期待您的阅读。

总结

字符流只是针对文本文件，如果遇到图片、视频、音乐等非文本文件格式的文件，就无法起到相依的读取作用，所以，在使用的时候，如果是文本文件，我们就使用字符流，其他情况都使用字节流。

end

谢谢您的阅读！