java I/O系统（3）：I/O流典型使用方式

桃扇骨 2023-05-22 22:39 1阅读 0赞

尽管可以通过不同的方式组合I/O流类，但我们可能也就只用到其中的几种组合。下面的例子可以作为典型的I/O用法的基本参考。在这些示例中，异常处理都被简化为将异常传递给控制台，但是这只是在小型示例和工具中才适用。在代码中，你需要考虑更加复杂的错误处理方式。

### 一、缓冲输入文件 ###

如果想要打开一个文件用于字符输入，可以使用以String或File对象作为文件名的FileInputReader。为了提高速度，我们希望对那个文件进行缓冲，那么我们将所产生的引用传给一个BufferedReader构造器。由于BufferedReader也提供readLine()方法，所以这是我们的最终对象和进行读取的接口。当readLine()将返回null时，你就达到了文件的末尾。

import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    
    public class BufferedInputFile {
    	public static String read(String filename) throws IOException {
    		BufferedReader in = new BufferedReader(new FileReader(filename));
    		String s;
    		StringBuilder sb = new StringBuilder();
    		while ((s = in.readLine()) != null) {
    			sb.append(s + "\n");
    		}
    		in.close();
    		return sb.toString();
    	}
    
    	public static void main(String[] args) throws IOException {
    		System.out.println(read("src\\main\\java\\io\\BufferedInputFile.java"));
    	}
    }

字符串sb用来累积文件的全部内容（包括必须添加的换行符，因为readLine()已经将它们删掉）。最后，调用close()关闭文件。

### 二、从内存输入 ###

在下面的示例中，从BufferedInputFile.read()读入的String结果被用来创建一个StringReader。然后调用read()每次读取一个字符，并把它发送到控制台。

import java.io.IOException;
    import java.io.StringReader;
    
    public class MemoryInput {
    	public static void main(String[] args) throws IOException {
    		StringReader in = new StringReader(BufferedInputFile.read("src\\main\\java\\io\\MemoryInput.java"));
    		int c;
    		while ((c = in.read()) != -1) {
    			System.out.print((char) c);
    		}
    	}
    }

注意read()是以int形式返回下一字节，因此必须类型转换为char才能正确打印。

### 三、格式化的内存输入 ###

要读取格式化数据，可以使用DataInputStream，它是一个面向字节的I/O类（不是面向字符的）。因此我们必须使用InputStream类而不是Reader类。当然，我们可以用InputStream以字节的形式读取任何数据（例如一个文件），不过，在这里使用的是字符串。

import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    import java.io.EOFException;
    import java.io.IOException;
    
    public class FormattedMemoryInput {
    	public static void main(String[] args) throws IOException {
    		try {
    			DataInputStream in = new DataInputStream(new ByteArrayInputStream(
    					BufferedInputFile.read("src\\main\\java\\io\\FormattedMemoryInput.java").getBytes()));
    			while (true) {
    				System.out.print((char) in.readByte());
    			}
    		} catch (EOFException e) {
    			System.err.println("End of Stream");
    		}
    	}
    }

必须为ByteArrayInputStream提供字节数组，为了产生该数组String包含了一个可以实现此项工作的getBytes()方法。所产生的ByteArrayInputStream是一个适合传递给DataInputStream的InputStream。

如果我们从DataInputStream用readByte()一次一个字节的读取字符，那么任何字节的值都是合法的结果，因此返回值不能用来检查输入是否结束。EOFException这个异常主要用于数据输入流来表示流的结束。相反，我们可以使用available()方法查看还有多少可供读取的字符。下面这个例子演示了怎样一次一个字节的读取文件：

import java.io.BufferedInputStream;
    import java.io.DataInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class TestEOF {
    	public static void main(String[] args) throws IOException {
    		DataInputStream in = new DataInputStream(
    				new BufferedInputStream(new FileInputStream("src\\main\\java\\io\\TestEOF.java")));
    		while (in.available() != 0) {
    			System.out.print((char) in.readByte());
    		}
    	}
    }

注意，available()的工作方式会随着所读取的媒介类型的不同而有所不同；字面意思就是“在没有阻塞的情况下所能读取的字节数”。对于文件，这意味整个文件；但是对于不同类型的流，可能就不是这样的，因此要谨慎使用。

我们也可以通过捕获异常来检查输入的末尾。但是，使用异常进行流控制，被认为是对异常特性的错误使用。

### 四、基本的文件输出 ###

FileWriter对象可以向文件写入数据。首先，创建一个与指定文件连接的FileWriter。实际上，我们通常会用BufferedWriter将其包装起来用以缓冲输出（尝试移除此包装来感受对性能的影响——缓冲往往能显著地增加I/O操作的性能）。在本例中，为了提供格式化机制，它被装饰成了PrintWriter。按照这种方式创建的数据文件可作为普通文本文件读取。

import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.io.StringReader;
    
    public class BasicFileOutput {
    	static String file = "src\\main\\java\\io\\BasicFileOutput.out";
    
    	public static void main(String[] args) throws IOException {
    		BufferedReader in = new BufferedReader(
    				new StringReader(BufferedInputFile.read("src\\main\\java\\io\\BasicFileOutput.java")));
    		PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(file)));
    		int lineCount = 1;
    		String s;
    		while ((s = in.readLine()) != null) {
    			out.println(lineCount++ + ": " + s);
    		}
    		out.close();
    		System.out.println(BufferedInputFile.read(file));
    	}
    }

当文本行被写入文件时，行号就会增加。注意并未用到LineNumberInputStream，因为这个类没有多大帮助，所以我们没必要用它。从本例中可以看出，记录自己的行号很容易。

一旦读完输入数据流，readLine()会返回null。我们可以看到要为out显示调用colse()。如果我们不为所有的输出文件调用close()，就会发现缓冲区内部不会被刷新清空，那么它们也就不完整。

**（1）文本文件输出的快捷方式**

java SE5在PrintWriter中添加了一个辅助构造器，使得你不必在每次希望创建文本文件并向其中写入时，都去执行所有的装饰工作。下面是用这种快捷方式重写的BasicFileOutput.java：

import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.io.StringReader;
    
    public class FileOutputShortcut {
    	static String file = "src\\main\\java\\io\\FileOutputShortcut.out";
    
    	public static void main(String[] args) throws IOException {
    		BufferedReader in = new BufferedReader(
    				new StringReader(BufferedInputFile.read("src\\main\\java\\io\\FileOutputShortcut.java")));
    		PrintWriter out = new PrintWriter(file);
    		int lineCount = 1;
    		String s;
    		while ((s = in.readLine()) != null) {
    			out.println(lineCount++ + ": " + s);
    		}
    		out.close();
    		System.out.println(BufferedInputFile.read(file));
    	}
    }

你仍旧是在进行缓存，只是不必自己去实现。遗憾的是，其他常见的写入任务都没有快捷方式，因此典型的I/O仍旧包含大量的冗余文本。接下来将使用本章稍后进行定义的TextFile工具简化了这些常见任务。

### 五、存储和恢复数据 ###

PrintWriter可以对数据进行格式化，以便人们的阅读。但是为了输出可供另一个“流”恢复的数据，我们需要用DataOutputStream写入数据，并用DataInputStream恢复数据。当然，这些流可以是任何形式，但是在下面的示例中使用的是一个文件，并且对于读和写都进行了缓冲处理。注意，DataOutputStream和DataInputStream是面向字节的，因此要使用InputStream和OutputStream。

import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class StoringAndRecoveringData {
    	public static void main(String[] args) throws IOException {
    		String file = "src\\main\\java\\io\\Data.txt";
    		DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
    		out.writeDouble(3.14159);
    		out.writeUTF("That was pi");
    		out.writeDouble(1.4143);
    		out.writeUTF("Square root of 2");
    		out.close();
    		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
    		System.out.println(in.readDouble());
    		System.out.println(in.readUTF());
    		System.out.println(in.readDouble());
    		System.out.println(in.readUTF());
    	}
    }

如果我们使用DataOutputStream写入数据，java保证我们可以使用DataInputStream准确的读取数据——无论读和写数据的平台多么不同。这一点很有价值，因为我们都知道，人们曾经花费了大量的时间去处理特定于平台的数据问题。只要两个平台上都有java，这种问题就不会再发生。

当我们使用DataOutputStream时，写字符串并且让DataInputStream能够恢复它的唯一可靠做法就是使用UTF-8编码，在这个示例中是用WriteUTF()和readUTF()来实现的。UTF-8是一种多字节格式，其编码长度根据实际使用的字符集会有所变化。如果我们使用的只是ASCII或者几乎都是ASCII字符（只占7位），那么就显得极其浪费空间和带宽，所以UTF-8将ASCII字符编码成单一字节的形式，而非ASCII字符则编码成两到三个字节的形式。另外，字符串的长度存储在UTF-8字符串的前两个字节中。但是，writeUTF()和readUTF()使用的是适合于java的UTF-8变体（JDK文档中有这些方法的详尽描述），因此如果我们用一个非java程序读取用writeUTF()所写的字符串时，必须编写一些特殊的代码才能正确读取字符串。

有了writeUTF()和readUTF()，我们就可以用DataOutputStream把字符串和其他数据类型相混合，我们知道字符串完全可以作为Unicode来存储，并且可以很容易的使用DataInputStream来恢复它。

writeDouble()将double类型的数字存储到流中，并用相应的readDouble()恢复它（对于其他的数据类型，也有类似方法用于读写）。但是为了保证所有的读方法都能够正常工作，我们必须知道流中数据项所在的确切位置，因为极有可能将保存的double数据作为一个简单的字节序列、char或其他类型读入。因此，我们必须：要么为文件中的数据采用固定的格式；要么将额外的信息保存到文件中，以便能够对其进行解析以确定数据的存放位置。注意，对象序列化和XML（本章稍后都会介绍）可能是更容易的存储和读取复杂数据结构的方式。

### 六、读写随机访问文件 ###

使用RandomAccessFile，类似于组合使用了DataInputStream和DataOutputStream（因为它实现了相同的接口：DataInput和DataOutput）。另外我们可以看到，利用seek()可以在文件中到处移动，并修改文件中的某个值。

在使用RandomAccessFile时，你必须知道文件排版，这样才能正确的操作它。RandomAccessFile拥有读取基本类型和UTF-8字符串的各种具体方法。下面是示例：

import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class UsingRandomAccessFile {
    	static String file = "src\\main\\java\\io\\rtest.dat";
    
    	static void display() throws IOException {
    		RandomAccessFile rf = new RandomAccessFile(file, "r");
    		for (int i = 0; i < 7; i++) {
    			System.out.println("Value " + i + rf.readDouble());
    		}
    		System.out.println(rf.readUTF());
    		rf.close();
    	}
    
    	public static void main(String[] args) throws IOException {
    		RandomAccessFile rf = new RandomAccessFile(file, "rw");
    		for (int i = 0; i < 7; i++) {
    			rf.writeDouble(i * 1.414);
    		}
    		rf.writeUTF("The end of the file");
    		rf.close();
    		display();
    		rf = new RandomAccessFile(file, "rw");
    		rf.seek(5 * 8);
    		rf.writeDouble(47.0001);
    		display();
    	}
    }

display()方法打开了一个文件，并以double值的形式显示了其中的七个元素。在main()方法中，首选创建了文件，然后打开并修改了它。因为double总是8字节长，所以为了用seek()查找第5个双精度值，你只需用5\*8来产生查找位置。

正如先前所指，RandomAccessFile除了实现DataInput和DataOutput接口之外，有效的与I/O继承层次结构的其他部分实现了分离。因为它不支持装饰，所以不能将其与InputStream及OutputStream子类的任何部分组合起来。我们必须假定RandomAccessFile已经被正确的缓冲，因为我们不能为它添加这样的功能。

可以自行选择的是第二个构造器参数：我们可指定以“只读”（r）方式或“读写”（rw）方式打开一个RandomAccessFile文件。

你可能会考虑使用“内存映射文件”来代替RandomAccessFile。

### 七、管道流 ###

PipedInputStream、PipedOutputStream、PipedReader及PipedWriter在本章只是简单得提到。但这并不表明它们没有什么用处，它们的价值只有在我们开始理解多线程之后才会显现，因为管道流用于任务之间的通信。这些在并发章节会用一个示例进行讲述。

**如果本文对您有很大的帮助，还请点赞关注一下。**