java的io（2）----字符流总结

JAVA输入输出（IO）之字符流

字符输入流

java.io.Reader用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

方法摘要

返回值	方法名	说明
abstract void	close()	关闭该流并释放与之关联的所有资源。
int	read()	读取单个字符
int	read(char[] cbuf)	将字符读入数组
abstract int	read(char[] cbuf, int off, int len)	将字符读入数组的某一部分
int	read(CharBuffer target)	试图将字符读入指定的字符缓冲区

同样的，我们还是以操作文件为例，java.io.FileReader是用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在FileInputStream 上构造一个 InputStreamReader。

import java.io.FileReader;
import java.io.IOException;

public class FileReadWrite
{
   public static void main(String[] args)
   {
      FileReader reader = null;
      try
      {
         // 选用指定文件路径的构造方法
         reader = new FileReader("test.txt");
         int data = -1;
         // 从此输入流中读取一个数据字节，如果已到达文件末尾，则返回 -1
         while ((data = reader.read()) != -1)
         {
            // 准备的文件为文本文件，且内容为阿拉伯数字，所以直接强制转换为字符输出
            System.out.print((char) data);
         }
      }
      catch (IOException e)
      {
         // 异常处理
         e.printStackTrace();
      }
      finally
      {
         try
         {
            if (reader != null)
            {
               // 关闭输入流
               reader.close();
            }
         }
         catch (IOException e)
         {
         }
      }
   }
} 
 
 
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

这是直接使用FileReader的效果，我们可以看到和字节输入流基本一样，一般我们很少这样写，而是使用字符缓冲流java.io.BufferedReader。从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileReadWrite
{
   public static void main(String[] args)
   {
      BufferedReader reader = null;
      try
      {
         // 选用指定文件路径的构造方法
         reader = new BufferedReader(new FileReader("test.txt"));
         String line = null;
         // 从此输入流中读取一行
         while ((line = reader.readLine()) != null)
         {
            System.out.print(line);
         }
      }
      catch (IOException e)
      {
         // 异常处理
         e.printStackTrace();
      }
      finally
      {
         try
         {
            if (reader != null)
            {
               // 关闭输入流
               reader.close();
            }
         }
         catch (IOException e)
         {
         }
      }
   }
}
 
 
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

使用缓冲流，我们可以直接读取一行。

字符输出流

写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

方法概要

返回值	方法名	说明
abstract void	close()	关闭此流，但要先刷新它。
abstract void	flush()	刷新该流的缓冲
void	write(char[] cbuf)	写入字符数组
abstract void	write(char[] cbuf, int off, int len)	写入字符数组的某一部分
void	write(int c)	写入单个字符
void	write(String str)	写入字符串
void	write(String str, int off, int len)	写入字符串的某一部分

与FileReader对应的也有一个java.io.FilterWriter，用于写入已过滤的字符流的抽象类。抽象类 FilterWriter 自身提供了一些将所有请求传递给所包含的流的默认方法。FilterWriter 的子类应重写这些方法中的一些方法，并且还可以提供一些额外的方法和字段。

import java.io.FileWriter;
import java.io.IOException;

public class FileReadWrite
{
   public static void main(String[] args)
   {
      FileWriter writer = null;
      try
      {
         // 选用指定文件路径的构造方法
         writer = new FileWriter("test.txt");
         writer.write("hello");
         writer.flush();
      }
      catch (IOException e)
      {
         // 异常处理
         e.printStackTrace();
      }
      finally
      {
         try
         {
            if (writer != null)
            {
               // 关闭输入流
               writer.close();
            }
         }
         catch (IOException e)
         {
         }
      }
   }
}
 
 
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

上面的例子中使用的是FilterWriter向文件中写入数据，各位也可以试一下缓冲输出流java.io.BufferedWriter完成这个操作。