输入输出流

·1·
  输入输出流
输入输出是指应用程序与外部设备及其他计算机进行数据交流的操作，如读写硬盘数据、向显示器
输出数据、通过网络读取其他节点的数据等。任何一种编程语言必须拥有输入输出的处理方式，Java 语
言也不例外。 Java 语言的输入输出数据是以流的形式出现的，并且 Java 提供了大量的类来对流进行操作，
从而实现了输入输出功能。
Java 语言的输入输出功能是十分强大而灵活的，美中不足的是看上去输入输出的代码并不是很简
洁，因为你往往需要包装许多不同的对象。在 Java 类库中，I/O 部分的内容是很庞大的，因为它涉及的
领域很广泛：标准输入输出、文件的操作、网络上的数据流、字符串流、对象流等。本文的目的是为大
家对流做一个简要的介绍。
20.2.1   流的概念
所谓流是指同一台计算机或网络中不同计算机之间有序运动着的数据序列， Java 把这些不同来源和
目标的数据都统一抽象为数据流。流序列中的数据可以是没有进行加工的原始数据（二进制字节数据），
也可以是经过编码的符合某种格式规定的数据，Java 中提供了不同的流类对它们进行处理。
20.2.2   输入流与输出流
一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以
是 Internet 上的某个 URL。流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户
可以从输入流中读取信息，但不能写它。相反，对输出流，只能往输入流写，而不能读它。 
2
1．输入流
在 Java 中，程序可以打开一个输入流，输入流的信息源可以位于文件、内存或网络套接字(socket)
等地方，信息源的类型可以是包括对象、字符、图像、声音在内的任何类型。一旦打开输入流后，程序
就可从输入流串行地读数据。从输入流读数据的一般过程如下面的图 20.1 所示。
数据源 数据流 程序 从流中读取数据
图 20.1    输入流读取数据
2．输出流
类似地，程序也能通过打开一个输出流并顺序地写入数据来将信息送至目的端。输出流写数据的一
般过程如下面的图 20.2 所示。
目的端 数据流 程序向流中写入数据
图 20.2    输出流写入数据
20.2.3   字节流与字符流
Java 流包括字节流和字符流，字节流通过 IO 设备以字节数据的方式读入，而字符流则是通过字节
流读入数据转化成字符“流”的形式由用户驱使。
字节流是一种低级别的 I/O 流，大多用在最原始的 I/O 上，更多的时候建议首选使用字符流。
Java 平台使用 Unicode 编码存储字符值。字符流 I/O 自动地在这种内部格式和本地字符集间进行转
换。
20.3  字节流
程序使用字节流来执行 8 位字节的输入和输出。如下面的字节流类层次结构图所示，所有的字节流
处理类都继承自 InputStream 和 OutputStream。
图 20.3   字节输入流结构图 
·3·
图 20.4   字节输出流结构图
20.3.1   InputStream 类与 OutputStream 类
在 Java  I/O 流中，所有对字节流进行处理的类，都继承自 InputStream 类和 OutputStream 类，这是
两个抽象类。
1．InputStream 类
InputStream 类是个抽象类，作为字节输入流的直接或间接的父类，它定义了许多有用的、所有子类
必须的方法，包括读取、移动指针、标记、复位、关闭等方法。下面介绍了这些方法，需要注意的是，
这些方法大多可能抛出 IOException 异常。
  int read( )；读取一个字节，返回值为所读的字节。
  int read( byte b[ ] )；读取多个字节，放置到字节数组 b 中，通常读取的字节数量为 b 的长度，返
回值为实际读取的字节的数量。
  int read( byte b[ ], int off, int len )；读取 len 个字节，放置到以下标 off 开始字节数组 b 中，返回
值为实际读取的字节的数量。
  int available( )；返回值为流中尚未读取的字节的数量。
  long skip( long n )；读指针跳过 n 个字节不读，返回值为实际跳过的字节数量。
  close( )；流操作完毕后必须关闭。
  void mark( int readlimit )；记录当前读指针所在位置，readlimit 表示读指针读出 readlimit 个字节
后所标记的指针位置才失效。
  void reset( )；把读指针重新指向用 mark 方法所记录的位置。
  boolean markSupported( )；当前的流是否支持读指针的记录功能。
2．OutputStream 类
OutputStream 类也是抽象类，作为字节输出流的直接或间接的父类，当程序需要向外部设备输出数
据时，需要创建 OutputStream 的某一个子类的对象来完成。以下介绍该类的常用方法，与 InputStream
类似，这些方法也可能抛出 IOException 异常。 
  void write( int b )；往流中写一个字节 b。
  void write( byte b[ ] )；往流中写一个字节数组 b。
  void write( byte b[ ], int off, int len )；把字节数组 b 中从下标 off 开始，长度为 len 的字节写入流
中。
  flush( )；把缓存中所有内容强制输出到流中。
  close( )；流操作完毕后必须关闭。 
4
20.3.2   文件输入流 FileInputStream 类与文件输出流 FileOutputStream 类
FileInputStream 类和 FileOutputStream 类中，第一个类的源端和第二个类的目的端都是磁盘文件，
它们的构造方法允许通过文件的路径名来构造相应的流。如： 
  FileInputStream infile = new FileInputStream("myfile.dat")；
  FileOutputStream outfile = new FileOutputStream("results.dat")；
注意：构造 FileInputStream 对象时,  对应的文件必须存在并且是可读的，而构造 FileOutputStream
对象时，如输出文件已存在，则必须是可覆盖的。 
1．FileInputStream 类
如果用户的文件读取需求比较简单，那么用户可以使用 FileInputStream 类，该类是从 InputStream
中派生出来的简单输入类，该类的所有方法都是从 InputStream 类继承来的。
【例 20.2】使用文件输入流读取文件。
import java.io.FileInputStream;
import java.io.IOException;
public class ReadFileDemo {
public static void main(String[] args) {
try {
FileInputStream in = new FileInputStream("TestFile.txt");     //  创建文件输入流对象
int n = 512;                                               //  设定读取的字节数
byte buffer[] = new byte[n];                               //  读取输入流
//读取 n 个字节，放置到以下标 0 开始字节数组 buffer 中，返回值为实际读取的字节的数量
while ((in.read(buffer, 0, n) != -1) && (n > 0)) {  
System.out.print(new String(buffer));
}
System.out.println();
in.close();                                              //  关闭输入流
} catch (IOException ioe) {
System.out.println(ioe);
} catch (Exception e) {
System.out.println(e);
}
}
}
本例以 FileInputStream 的 read(buffer)方法，每次从源程序文件 TestFile.txt 中读取 512 个字节，存储
在缓冲区 buffer 中，再将以 buffer 中的值构造的字符串 new String(buffer)显示在屏幕上。
说明：使用文件输入流构造器建立通往文件的输入流时，可能会出现错误(也被称为异常。例如，
要打开的文件可能不存在。当出现 I/O 错误时，Java 生成一个出错信号，它使用一个 IOException 对象
来表示这个出错信号。程序必须使用一个 try-catch 块检测并处理这异常。
2．FileOutputStream 类 
FileOutputStream 提供了基本的文件写入能力。除了从 OutputStream 类继承来的方法以外，
FileOutputStream 类还有两个构造器：
  FileOutputStream(String name)。
  FileOutputStream(File file)。
第一个构造器使用给定的文件名 name 创建一个 FileOutputStream 对象。第二个构造器使用 File 对
·5·
象创建 FileOutputStream 对象。该类可以使用 write 方法把字节发送给输出流。
下例用 System.in.read(buffer)从键盘输入一行字符，存储在缓冲区 buffer 中，再以 FileOutputStream
的 write(buffer)方法，将 buffer 中内容写入文件 WriteFile.txt 中。
【例 20.3】使用文件输出流写入文件
import java.io.FileOutputStream;
import java.io.IOException;
public class WriteFileDemo{
public static void main(String[] args) {
try {
System.out.print("输入要保存文件的内容：");
int count, n = 512;
byte[] buffer = new byte[n];              //定义存放读入信息的字节数组
count = System.in.read(buffer);                             //  读取标准输入流
FileOutputStream os = new FileOutputStream("WriteFile.txt");   //  创建文件输出流对象
os.write(buffer, 0, count);      //把字节数组 buffer 中从下标 0 开始，长度为 count 的字节写入流中
os.close();                                                 //  关闭输出流
System.out.println("已保存到 WriteFile.txt!");
} catch (IOException ioe) {                //捕获 IOException 异常
System.out.println(ioe);                //输出异常信息
} catch (Exception e) {                  //捕获其他异常
System.out.println(e);                //输出其他异常信息
}
}
}
在这个程序中，使用“System.on.read(buffer);”语句时，程序会暂停，等待用户输入内容。用户输
入的内容会保存在字节数组 buffer 中，并返回读入的内容的长度保存到变量 count 中。因为对文件的读
写有可能发生 IO 异常，所以在程序中要处理 IOException 异常。编译并运行此程序，会在同一目录下，
会提示输入要保存文件的内容。输入一段话，按回车确认，这时会在目录下生成一个名为 WriteFile.txt
的文本文件。打开这个文本文件，会看到刚刚输入的这段话。
3．同时使用 FileInputStream 类和 FileOutputStream 类 
下面的示例程序中，同时使用 FileInputStream 类读取一个文件和 FileOutputStream 类写入另一个文
件，实现文件拷贝的功能。
【例 20.4】实现拷贝文件功能。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyBytesExample {
public static void main(String[] args) throws IOException {
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("xanadu.txt");
out = new FileOutputStream("outagain.txt"); 
6
int c;
while ((c = in.read()) != -1) {  //读字节
out.write(c);    //写字节
}
} finally {
if (in != null) {
in.close();    //关闭输入流
}
if (out != null) {
out.close();    //关闭输出流
}
}
}
}
这个程序简单地通过循环读取输入流和写入输出流，每次一个字节，如下图所示：
或者可以使用 try-with-resources 语句，自动关闭输入输出流。将上面的代码改写如下：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyBytesExample {
public static void main(String[] args){
//使用 try-with-resources 语句，自动关闭输入输出流
try(FileInputStream in = new FileInputStream("xanadu.txt");
FileOutputStream out = new FileOutputStream("outagain.txt")) {
int c;
while ((c = in.read()) != -1) {
out.write(c); 
·7·
}
} catch (FileNotFoundException ex) {
System.out.println("无法找到文件");
} catch (IOException ex) {
System.out.println("IO 异常");
} 
}
}
20.3.3   缓存输入流 BufferedInputStream 与缓存输出流 BufferedOutputStream
从字节流的 stream 类层次结构图看出，BufferedInputStream 类为 FilterInputStream 的子类, 而
FilterInputStream 又是 InputStream 的子类。从类名中，可以了解这个类主要在流的输入过程中提供了缓
存 的 功 能 。 也 可 以 从 其 构 造 函 数 中 进 一 步 的 了 解 到 其 是 跟 其 他 流 类 一 起 搭 配 使 用 的 。
BufferedOutputStream 类跟 BufferedInputStream 类一样，不同的是一个用于读数据一个是写数据而已。
java.io.BufferedInputStream 与 java.io.BufferedOutputStream 可以为 InputStream、OutputStream 类的
对象增加缓冲区功能，构建 BufferedInputStream 实例时，需要给定一个 InputStream 类型的实例，实现
BufferedInputStream 时，实际上最后是实现 InputStream 实例。同样地，在构建 BufferedOutputStream 时，
也需要给定一个 OutputStream 实例，实现 BufferedOutputStream 时，实际上最后是实现 OutputStream 实
例。
【例 20.4】使用缓存输入、输出流读写文件。
import java.io.*;
public class BufferedStreamDemo {
public static void main(String[] args) {
try {           
FileInputStream in = new FileInputStream("D:/b.txt");               //  来源文件
FileOutputStream out = new FileOutputStream("C:/a.txt");             //  目的文件
BufferedInputStream bufferedIn = new BufferedInputStream(in);    //缓冲输入流
BufferedOutputStream bufferedOut = new BufferedOutputStream(out);  //缓冲输出流
byte[] data = new byte[1];                  //接收数据的字节数组
while (bufferedIn.read(data) != -1) {
bufferedOut.write(data);                                       //将缓冲区中的数据全部写出
}    
bufferedOut.flush();                          //刷新缓冲输出流
bufferedIn.close();                                                //关闭输入流
bufferedOut.close();                    //关闭输入流
} catch (ArrayIndexOutOfBoundsException e) {            //捕获数组越界异常
e.printStackTrace();
} catch (IOException e) {                    //捕获 IO 异常
e.printStackTrace();
}
}
}
在这个程序中，构建了一个文件输入流对象 in 和一个文件输出流对象 out。同时为了提高数据的批
量输入输出速度，对 in 和 out 分别加上缓冲输入流和缓冲输出流，然后通过缓冲输入流和输出流对数据
进行读写。因为读入的数据是保存在字节数组 data 中的，所以在进行文件读写时，有可能发生数组下标
8
越界的异常，因此需要在程序中处理 ArrayIndexOutOfBoundsException 异常和 IOException 异常。
说明：为了确保缓冲区中的数据一定被写出至目的地，建议最后执行 flush()将缓冲区中的数据全
部写出目的流中。
20.4   字符流
字符流主要是用于支持 Unicode 的文字内容，在大多数应用程序中，使用字符流 I/O 并不比字节流
I/O 更复杂。绝大多数在字节流中所提供的类，都可在此找到对应的类。其中输入流 Reader 抽象类帮助
用户在 Unicode 流内获得字符数据；而 Writer 类则是实现了输出。可以利用 Reader 类来读取由 Writer
写入的流。
对于字符流，其输入输出流类的层次结构如图 20.4 和 20.5 所示。
图 20.4   字符输入流结构图
图 20.4   字符输出流结构图
从图中可以看出，Reader 类是所有字符输入流的祖先，而 Writer 类是所有字符输出流的祖先。
20.4.1   Reader 类和 Writer 类
前面说过，在 JDK1.1 之前，java.io 包中的流只有普通的字节流（以 byte 为基本处理单位的流），
这种流对于以 16 位的 Unicode 码表示的字符流处理很不方便。从 JDK1.1 开始，java.io 包中加入了专门
用于字符流处理的类，它们是以 Reader 和 Writer 为基础派生的一系列类。 和 InputStream 和 OutputStream
类一样，Reader 和 Writer 也是抽象类，只提供了一系列用于字符流处理的接口。它们的方法与类
InputStream 和 OutputStream 类似，只不过其中的参数换成字符或字符数组 
·9·
20.4.2  字符文件读写器 FileReader 类和 FileWriter 类
FileReader 类和 FileWriter 类分别是 Reader 和 Writer 的子类，其构造方法分别是：
  FileReader(String filename)；
  FileReader(File f)；
  FileWriter(String filename)；
  FileWriter(File f)。
前面的 FileInputStream 使用字节读取文件，字节流不能直接操作 Unicode 字符，所以 Java 提供了字
符流。由于汉字在文件中占用 2 个字节，如果使用字节流，读取不当会出现乱码现象，采用字符流就可
以避免这个现象，因为在 Unicode 字符中，一个汉字被看做一个字符。
1．FileReader 类
FileReader 类用于读取文件，每次读取文件中第一个未读取过的字符，并以 ASCII 码或者 UTF-8 码
的形式输入到程序中。创建 FileReader 类对象的格式为：
FileReader fr=new FileReader(filename);
其中文件名必须是文件的完整路径和文件名，如果程序和该文件保存在同一目录下，则可以只用文
件名而不需要其路径。
FileReader 类中的 read()方法用来读取字符并返回一个相应的 int 类型数据。当读到文件的结尾处时，
则返回数值-1。在完成文件数据的读取后需要使用 close()方法关闭打开的文件。
【例 20.5】读取文件 student.txt 的内容显示在屏幕上。
import java.io.*;
public class FileReadDemo{
public static void main(String[] args) throws IOException{
FileReader fr=new FileReader("student.txt");            //创建一个 FileReader 类型的对象
int c=fr.read();                                      //从文件中读取字符并存入 c 变量中
while(c!=-1){                                         //判断文件内容是否结束
System.out.print((char)c);            //输出读取的字符到控制台
c = fr.read();                //读取下一个字符
}
fr.close();                    //关闭文件阅读器
}
}
在这个程序中，构建了一个文件阅读器 FileReader 的对象实例 fr，通过 while 循环语句调用其 read()
方法依次读取一个字符，并判断是否到了文件结束处。如果没有到文件结尾，则将读取的整数强制类型
转换为 char 类型，并输出到控制台中。在程序最后，要关闭流。
说明：在声明 main()方法时，添加了 throws  IOException 用来处理输入和输出文件时发生的异常。
当然，也可以使用 try 和 catch 语句来处理异常。但是如果不需要异常的具体处理办法，则可以只用 throws
关键字。
2．FileWriter 类
FileWriter 类用于将数据写入文件，创建 FileWriter 类对象的格式为：
FileWriter fr=new FileWriter (filename);
其中，文件名必须是文件的完整路径和文件名，如果程序和该文件保存在同一目录下，则可以只用
文件名而不需要其路径。如果该文件名不存在，则系统会自动创建该文件。FileWriter 类中的 write()方
法可以将字符或者字符串吸入文件中。当完成数据写入操作后，使用 close()方法关闭文件。 
10
【例 20.6】创建一个文件 student.txt 并写入一些字符串。
import java.io.*;
public class FileWriteDemo{
public static void main(String[] args) throws IOException{
FileWriter fw = new FileWriter("student.txt");     //创建一个 FileWriter 类型的对象
fw.write("This is my ");                       //向文件中写入字符串
fw.write("stu");
fw.write("dent");
fw.write('.');                               //向文件中写入字符
fw.write("txt");
fw.write("    这是我的文件。");
fw.close();                                //关闭流
}
}
在这个程序中，构建了一个文件写入器 FileWriter 的对象实例 fw，调用其 write()方法向文本文件
student.txt 中写入各种文本。在这个程序中，没有在代码中捕获异常，而是在 main()方法头部使用 throws
关键字抛出 IOException 异常，将异常交给虚拟机来处理。
3．同时使用 FileReader 类和 FileWriter 类 
下面的示例程序中，同时使用 FileReader 类读取一个文件和 FileWriter 类写入另一个文件，实现文
件拷贝的功能。
【例 20.4】实现拷贝字符文件功能。
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyCharacters {
public static void main(String[] args) throws IOException {
FileReader inputStream = null;
FileWriter outputStream = null;
try {
inputStream = new FileReader("xanadu.txt");
outputStream = new FileWriter("characteroutput.txt");
int c;
while ((c = inputStream.read()) != -1) {
outputStream.write(c);
}
} finally {
if (inputStream != null) {
inputStream.close();     //关闭字符输入流
} 
·11·
if (outputStream != null) {
outputStream.close();    //关闭字符输出流
}
}
}
}
或者可以使用 try-with-resources 语句，自动关闭输入输出流。将上面的代码改写如下：
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CopyCharacters {
public static void main(String[] args) {
//使用 try-with-resources 语句，自动关闭输入输出流
try(FileReader inputStream = new FileReader("xanadu.txt");
FileWriter outputStream = new FileWriter("characteroutput.txt")){           
int c;
while ((c = inputStream.read()) != -1) {
outputStream.write(c);
}
} catch (FileNotFoundException ex) {
System.out.println("找不到要拷贝的文件");
} catch (IOException ex) {
System.out.println("IO 异常");
} 
}
}
20.4.3   带缓存的字符文件读写器 BufferedReader 类和 BufferedWriter 类
一般情况下，为了提高字符文件读写效率，通常需要为文件读写器添加一个缓冲读写器，分别为
BufferedReader 类和 BufferedWriter 类。
1．BufferedReader 类
假如上面例子使用的文件 Student.txt 是一个学生名单，每个姓名占一行。如果我们想读取名字，那
么每次必须读取一行，但 FileReader 类没有提供这种方法，所以我们必须把这个流(对象)再接到另外一
个流上，从后一个流中读取名单。Java 提供了名为 BufferedReader 的类，主要是用来实现读取文件中的
一个段落，其格式为：
BufferedReader br = new BufferedReader(new FileReader(filename))；
也可分开写成： 
FileReader tofile=new FileWriter(filename);
BufferedReader br=new BufferedWriter(tofile)； 
12
在声明了 BufferedReader 类的对象后，就可以调用其 readLine()方法来读取文件中的数据。当读取
到回车符(\n)时，表示本次读取结束，将所读取到的内容以字符串数据的形式输入到程序中，下次读取
从回车符后面的数据开始。当所有的内容都读取完后，返回值为 null。在完成文件数据的读取后需要使
用 close()方法关闭打开的文件。
【例 20.7】用 BufferedReader 类来读取文件 Student.txt 中的内容并显示在屏幕上。
import java.io.*;
public class BufferedReaderDemo{
public static void main(String[] args) throws IOException{
FileReader fr = new FileReader("student.txt");
BufferedReader br = new BufferedReader(new FileReader("student.txt"));
String   s = br.readLine();                     //创建变量 s 用于存储从文件中读取的第一行数据
while(s! = null){                            //判断 s 变量是否接收到数据
System.out.print(s+"\n");
S = br.readLine();                    //读取下一行数据并存储到 s 中
}
br.close();                                //关闭流
}
}
因为使用 BufferedReader 类读取文件时，回车符号(\n)不会作为数据输入到程序中，所以需要在打
印添加该符号来保持输出内容与文件中的内容完全一样。同样，我们也可以用 BufferedReader 类来实现
从键盘读取字符或字符串
【例 20.8】用 BufferedReader 类来实现从键盘读取字符。
import java.io.*;
class KeyboardDemo1{
public static void main(String[] args) throws IOException{
char a;        //声明一个 char 类型的变量
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
a = (char) br.read();       //从输入流 br 中读取字符并存入字符变量 a 中
System.out.println(a);
}
}
【例 20.9】用 BufferedReader 类来实现从键盘读取字符串。
import java.io.*;
public class KeyboardDemo2{
public static void main(String args[]) throws IOException{
·13·
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String a; 
System.out.print("请输入任一字符串：");
a = in.readLine();         //从输入流 br 中读取字符串并存入字符串变量 a 中
System.out.println("你输入的字符串是："+a);
in.close();
}
}
在这两个程序示例中，演示了 BufferedReader 的两个方法：read()和 readLine()。其中 read()方法一
次读取一个字符，而 readLine()方法一次可以读取一行字符。
说明：InputStreamReader 类起到将字节流转换为字符流的功能。
2．BufferedWriter 类
类似地，可以将 BufferedWriter 流和 FileWriter 流连接在一起，然后使用 BufferedWriter 流将数据写
到目的地，创建 BufferedWriter 类对象的格式为。例如：
BufferedWriter br = new BufferedWriter (newFileWriter (filename))；
也可象下面这样分开写：
FileWriter   fromfile=new FileWriter(filename);
BufferedWriter bw=new BufferedWriter(fromfile)；
在声明 BufferedWriter 类的对象后，调用其 newLine()方法来写入一个回车符号。因为不同的操作系
统平台，其回车符号的表达方式不同，所以，可以使用 newLine()方法来直接产生系统声明的回车符号，
而不必在意其具体的表达方式。例如，下面的程序创建一个文件 student.txt 并写入字符串和回车符号。
【例 20.10】创建一个文件 student.txt 并用 BufferedWriter 流将字符串和回车符号写入其中。
import java.io.*;
public class BufferedWriterDemo{
public static void main(String[] args) throws IOException{
BufferedWriter bw=new BufferedWriter(new FileWriter("student.txt"));
bw.write("This is my student.txt");          //向文件中写入字符串
bw.newLine();                            //换行
bw.write("这是我的文件。");        //向文件中写入内容
bw.close();              //关闭流
}
}
说明：要将字符流转换为字节流，可以使用 OutputStreamWriter 类，如下所示：
Writer out = new BufferedWriter(new OutputStreamWriter(System.out));
20.4.4  打印流 PrintStream 类和 PrintWriter 类
要想输入和输出各种数值类型，通常使用打印输入流 PrintStream 和 PrintWriter。其中 PrintStream
操纵的是字节，而 PrintWriter 操纵的是字符。
1．PrintStream 类
PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。与其他输出流
不同，PrintStream 永远不会抛出 IOException；另外，为了自动刷新，可以创建一个 PrintStream；这意
味着可在写入 byte 数组之后自动调用 flush()方法，可调用其中一个 println()方法，或写入一个换行符或
14
字节('\n')。PrintStream 是向标准输出设备的输出流，可直接输出各种类型的数据。其构造函数为：
public PrintStream(OutputStream out)                      //创建无 flush 的标准输出流。
public PrintStream(OutputStream out,boolean autoFlush)      //创建标准输出流。
【例 20.11】随机产生 10 个数，使用 PrintStream 流将它们放入 random.txt 文件中。
import java.io.*;
import java.util.*;
class PrintStreamDemo{
public static void main(String[] aa) throws Exception{
PrintStream out = new PrintStream(new FileOutputStream("random.txt"));
Random r = new Random();                   //  生成一个 random 类对象 r
int a;
for(int i=0;i<10;i++){
a = r.nextInt(100);                  //生成 0-99 之间的一个随机数并存入变量 a 中
out.print(a+"\t");
}
out.close();                                    //关闭流
}
}
在这个程序示例中，使用 java.util.Random 类生成 0-99 之间的随机数，并使用打印输出流 PrintStream
对象将它们写入到 random.txt 文本文件中。
2．PrintWriter
向标准输出设备的输出流，可直接用来输出各种类型的数据。对 BufferedReader 类，该类的 readLine()
方法能一次从流中读入一行，但对于 BufferedWriter 类，就没有一次写一行的方法，所以若要向流中一
次写一行，可用 PrintWriter 类将原来的流改造成新的打印流，PrintWriter 类有一个方法 println()，能一
次输出一行。例如：
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("D:\javacode\test.txt")));
out.println("Hello World!");
out.close();
向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。此类中的
方法不会抛出 I/O 异常。