Java I/O 操作详解-优快云博客

本文链接：https://blog.youkuaiyun.com/partner4java/article/details/7438991

本文深入探讨 Java 中的输入输出(I/O)操作，包括 File 类的使用、目录的检查与创建、各种 I/O 流的介绍及使用方法。通过多个示例程序，详细讲解如何读写文件、处理字符与字节流、存储与恢复数据等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

对程序语言的设计者来说，创建一个好的输入输出(I/O)系统是一项艰难的任务。

File类

File类这个名称一般会误解以为是代表的一个文件，其实还能代表一个目录下的一组文件的名称，代表一个文件集时可以对此结合调用list()方法，这个方法会返回一个字符数组。

---------
文档：
list
public String[] list()返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。
如果此抽象路径名并不表示一个目录，则此方法将返回 null。否则，为目录中的每个文件或目录返回一个字符串数组。表示目录本身及其父目录的名称不包括在结果中。每个字符串是一个文件名，而不是一条完整路径。

不保证所得数组中的相同字符串将以特定顺序出现，特别是不保证它们按字母顺序出现。

返回：
由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。如果目录为空，则数组也将为空。如果抽象路径名不表示一个目录，或者发生 I/O 错误，则返回 null。
抛出：
SecurityException - 如果存在安全管理器，且其 SecurityManager.checkRead(java.lang.String) 方法拒绝对目录进行读取访问
---------

1、目录列表器
demo1：
获取list对象包含的全部列表：

package cn.partner4java.io;

import java.io.File;

/**
 * 获取list对象包含的全部列表
 * @author partner4java
 *
 */
public class DirList1 {

	public static void main(String[] args) {
		File file = new File(".");
		String[] names = file.list();
		for(String name:names){
			System.out.println(name);
		}
//		后台打印：
//		.classpath
//		.project
//		.settings
//		.svn
//		bin
//		readme.txt
//		src

	}

}

demo2：
获取一个受限列表，例如，只得到扩展名为.txt的文件，那么我们就要用到“目录过滤器”。
public interface FilenameFilter：
实现此接口的类实例可用于过滤器文件名。
Abstract Window Toolkit 的文件对话框组件使用这些实例过滤 File 类的 list 方法中的目录清单。

package cn.partner4java.io;

import java.io.File;
import java.io.FilenameFilter;
import java.util.regex.Pattern;

/**
 * 目录过滤器
 * @author partner4java
 *
 */
public class DirFilter implements FilenameFilter {
	private Pattern pattern;
	public DirFilter(String regex) {
		pattern = Pattern.compile(regex);
	}
	//回调--策略模式
	@Override
	public boolean accept(File dir, String name) {
		return pattern.matcher(name).matches();
	}

}

package cn.partner4java.io;

import java.io.File;
import java.util.Arrays;

/**
 * 只得到扩展名为.txt的文件
 * @author partner4java
 *
 */
public class DirList2 {

	public static void main(String[] args) {
		File file = new File("./src");
		String[] names = file.list(new DirFilter("^.+\\.txt$"));
		//按字母对结果进行排序
		Arrays.sort(names,String.CASE_INSENSITIVE_ORDER);
		for(String name:names){
			System.out.println(name);
		}
//		后台打印：
//		0前言.txt
//		1File类.txt

	}

}

demo3：
整合demo2匿名内部类方式

package cn.partner4java.io;

import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
import java.util.regex.Pattern;

/**
 * 代码简化--匿名内部类<br/>
 * 或者可以把filter简单到list()方法里面。<br/>
 * 这样可以使代码聚拢，但是会变得不易阅读。
 * @author partner4java
 *
 */
public class DirList3 {

	public static void main(String[] args) {
		File file = new File("./src");
		String[] names = file.list(filter("^.+\\.txt$"));
		//按字母对结果进行排序
		Arrays.sort(names,String.CASE_INSENSITIVE_ORDER);
		for(String name:names){
			System.out.println(name);
		}
//		后台打印：
//		0前言.txt
//		1File类.txt

	}

	private static FilenameFilter filter(final String regex) {
		return new FilenameFilter() {
			private Pattern pattern = Pattern.compile(regex);
			@Override
			public boolean accept(File dir, String name) {
				return pattern.matcher(name).matches();
			}
		};
	}

}

2、目录实用工具

//: net/mindview/util/Directory.java
package cn.partner4java.io;

import java.util.regex.*;
import java.io.*;
import java.util.*;

/**
 * 帮你产生文件集
 * @author partner4java
 *
 */
public final class Directory {
	/**
	 * 使用被成为listFile()的File.list()的变体来产生File数组。
	 * 还使用了FilenameFilter。
	 * 如果需要list而不是数组，可以通过Arrays.asList()自己对结果进行转换。
	 * @param dir
	 * @param regex
	 * @return
	 */
	public static File[] local(File dir, final String regex) {
		return dir.listFiles(new FilenameFilter() {
			private Pattern pattern = Pattern.compile(regex);

			public boolean accept(File dir, String name) {
				return pattern.matcher(new File(name).getName()).matches();
			}
		});
	}

	public static File[] local(String path, final String regex) { // Overloaded
		return local(new File(path), regex);
	}

	// A two-tuple for returning a pair of objects:
	public static class TreeInfo implements Iterable<File> {
		public List<File> files = new ArrayList<File>();
		public List<File> dirs = new ArrayList<File>();

		// The default iterable element is the file list:
		public Iterator<File> iterator() {
			return files.iterator();
		}

		void addAll(TreeInfo other) {
			files.addAll(other.files);
			dirs.addAll(other.dirs);
		}

		public String toString() {
			return "dirs: " + PPrint.pformat(dirs) + "\n\nfiles: "
					+ PPrint.pformat(files);
		}
	}

	/**
	 * 将开始目录的名字转换为File对象，然后调用resourceDirs()，该方法将递归的便利目录，
	 * 并在每次递归中都收集更多的信息。
	 * 为了区分普通文件和目录，返回值实际上是一个对象“元组”----一个list持有所有普通文件，另一个持有目录。
	 * @param start
	 * @param regex
	 * @return
	 */
	public static TreeInfo walk(String start, String regex) { // Begin recursion
		return recurseDirs(new File(start), regex);
	}

	public static TreeInfo walk(File start, String regex) { // Overloaded
		return recurseDirs(start, regex);
	}

	public static TreeInfo walk(File start) { // Everything
		return recurseDirs(start, ".*");
	}

	public static TreeInfo walk(String start) {
		return recurseDirs(new File(start), ".*");
	}

	static TreeInfo recurseDirs(File startDir, String regex) {
		TreeInfo result = new TreeInfo();
		for (File item : startDir.listFiles()) {
			if (item.isDirectory()) {
				result.dirs.add(item);
				result.addAll(recurseDirs(item, regex));
			} else // Regular file
			if (item.getName().matches(regex))
				result.files.add(item);
		}
		return result;
	}

	// Simple validation test:
	public static void main(String[] args) {
		if (args.length == 0)
			System.out.println(walk("."));
		else
			for (String arg : args)
				System.out.println(walk(arg));
	}
} // /:~


//: net/mindview/util/ProcessFiles.java
package cn.partner4java.io;

import java.io.*;

/**
 * 在目录中穿行
 * @author partner4java
 *
 */
public class ProcessFiles {
	public interface Strategy {
		void process(File file);
	}

	private Strategy strategy;
	private String ext;

	public ProcessFiles(Strategy strategy, String ext) {
		this.strategy = strategy;
		this.ext = ext;
	}

	public void start(String[] args) {
		try {
			if (args.length == 0)
				processDirectoryTree(new File("."));
			else
				for (String arg : args) {
					File fileArg = new File(arg);
					if (fileArg.isDirectory())
						processDirectoryTree(fileArg);
					else {
						// Allow user to leave off extension:
						if (!arg.endsWith("." + ext))
							arg += "." + ext;
						strategy.process(new File(arg).getCanonicalFile());
					}
				}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	public void processDirectoryTree(File root) throws IOException {
		for (File file : Directory.walk(root.getAbsolutePath(), ".*\\." + ext))
			strategy.process(file.getCanonicalFile());
	}

	// Demonstration of how to use it:
	public static void main(String[] args) {
		new ProcessFiles(new ProcessFiles.Strategy() {
			public void process(File file) {
				System.out.println(file);
			}
		}, "java").start(args);
	}
} /* (Execute to see output) */// :~

3、目录的检查及创建
File不仅仅是代表存在的文件或者目录，也可以用File对象创建不存在的目录或整个目录。
我们还可以查看文件的特性（如：大小，最后修改日期，读/写），检查某个File对象代表的是一个文件还是一个目录，并可以删除文件。

package cn.partner4java.io;

//: io/MakeDirectories.java
// Demonstrates the use of the File class to
// create directories and manipulate files.
// {Args: MakeDirectoriesTest}
import java.io.*;

public class MakeDirectories {
	private static void usage() {
		System.err.println("Usage:MakeDirectories path1 ...\n"
				+ "Creates each path\n"
				+ "Usage:MakeDirectories -d path1 ...\n"
				+ "Deletes each path\n"
				+ "Usage:MakeDirectories -r path1 path2\n"
				+ "Renames from path1 to path2");
		System.exit(1);
	}

	private static void fileData(File f) {
		System.out.println("Absolute path: " + f.getAbsolutePath()
				+ "\n Can read: " + f.canRead() + "\n Can write: "
				+ f.canWrite() + "\n getName: " + f.getName()
				+ "\n getParent: " + f.getParent() + "\n getPath: "
				+ f.getPath() + "\n length: " + f.length()
				+ "\n lastModified: " + f.lastModified());
		if (f.isFile())
			System.out.println("It's a file");
		else if (f.isDirectory())
			System.out.println("It's a directory");
	}

	public static void main(String[] args) {
		if (args.length < 1)
			usage();
		if (args[0].equals("-r")) {
			if (args.length != 3)
				usage();
			File old = new File(args[1]), rname = new File(args[2]);
			old.renameTo(rname);
			fileData(old);
			fileData(rname);
			return; // Exit main
		}
		int count = 0;
		boolean del = false;
		if (args[0].equals("-d")) {
			count++;
			del = true;
		}
		count--;
		while (++count < args.length) {
			File f = new File(args[count]);
			if (f.exists()) {
				System.out.println(f + " exists");
				if (del) {
					System.out.println("deleting..." + f);
					f.delete();
				}
			} else { // Doesn't exist
				if (!del) {
					f.mkdirs();
					System.out.println("created " + f);
				}
			}
			fileData(f);
		}
	}
} /*
 * Output: (80% match) created MakeDirectoriesTest Absolute path:
 * d:\aaa-TIJ4\code\io\MakeDirectoriesTest Can read: true Can write: true
 * getName: MakeDirectoriesTest getParent: null getPath: MakeDirectoriesTest
 * length: 0 lastModified: 1101690308831 It's a directory
 */// :~

输入和输出

编程语言的I/O类库中常用这个流这个抽象概念，他代表任何有能力产出数据的数据源对象或有能力接收数据的接收端对象。“流”屏蔽了实际的的I/O设备中处理数据的细节。

Java类库中I/O类分为输入和输出两部分。
通过继承，任何字InputStream或Reader派生而来的类都包含名为read()的基本方法，用于读取单个字节或者字节数组。
同样，任何自OutputStream或Writer派生而来的类都包含write()基本方法，用于写单个字节或者字节数组。
但是让人迷惑的主要原因在于：创建单一的结果流，却需要创建多个对象。

在Java1.0中，类库的设计者首先限定与输入有关的所有类都应该从InputStream继承，而与输出相关的类都应该从OutputStream继承。

1、InputStream类型
用于表示那些从不同数据源产生输入的类。
这些数据源包括：
·字节数组
·String对象
·文件
·“管道”，工作方式与实际管道相似，即，从一端输入，从另一端输出。
·一个由其他种类的流组成的序列，以便我们可以把他们合并到一个流内。
·其他数据源，如Internet连接等。

=================================
InputStream类型
-----------------------------------------------------------------------------------
类功能构造器参数（如何使用）
ByteArrayInputStream 允许将内存的缓存区当做InputStream使用缓冲区，字节将从中取出作为一种数据源：将其与FilterInputStream对象相连接以提供有用的接口
StringBufferInputStream 将String转换成InputStream 字符串。底层实现实际使用StringBuffer 作为一种数据源：将其与FilterInputStream对象相连接以提供有用接口
FileInputStream 用于从文件中读取数据字符串，表示文件名、文件或FileDescriptor对象作为一种数据源：将其与FilterInputStream对象相连以提供有用的接口
PipedInputStream 产生用于写入相关的PipedOutPutStream的数据。 PipedOutPutStream 作为多线程中数据源：将其与FilterInputStream对象相连以提供有用的接口
SequenceInputStream 将多个InputStream对象抓换成单一的InputStream 两个InputStream对象或一个容纳InputStream对象的容器Enumeration作为一种数据源：将其与FilterInputStream对象相连以提供有用的接口
FilterInputStream 抽象类，作为“装饰器”的解耦。其中，“装饰器”为其他的InputStream提供有用的功能。

2、OutPutStream类型
该类别的类决定了输出所要去往的目标。
================================
OutPutStream类型
-----------------------------------------------------------------------------------
类功能构造器参数（如何使用）
ByterArrayOutputStream 在内存中创建缓冲区。所有送往“流”的数据都将放到此缓冲区中。缓冲区初始化尺寸（可选）用于指定数据的目的地：将其与FilterOutputStream对象相连以提供有用的接口
FileOutputStream 用于将文件写入至文件字符串，标识文件名、文件或FileDescriptor对象指定数据的目的地：将其与FilterOutputStream对象相连以提供有用接口
PipedOutputStream 任何写入其中的信息都讲作为相关PipedInputStream的输出。 PipedOutputStream 指定用于多线程的数据的目的地：将其与FilterOutputStream对象相连以提供有用的接口
FilterOutputStream 抽象类，作为“装饰器”接口。其中“装饰器”为其他OutputStream提供有用的功能。

添加属性和有用的接口

1)通过FilterInputStream从InputStream读取数据
表FilterInputStream类型（常用子类）
-----------------------------------------------------------------------------------
类功能构造器参数（如何使用）
DataInputStream 与DataOutputStream搭配使用，因此我们可按照可一直方式从流读取基本数据类型（int,char,long等） InputStream包含用于读取基本数据类型的全部接口
BufferedInputStream 使用他可以防止每次读取时都的进行实际写操作。代表“使用缓冲区” InputStream，可以指定缓冲区的大小本质上不提供接口，只不过是向进程中添加缓冲区所必需的。与接口对象搭配
LineNumberInputStream 跟踪输入流的行号；可调用getLineNumber()和setLineNumber(int) InputStream 仅增加了行号，因此可能与接口对象搭配使用。
PushbackInputStream 具有“能弹出一个字节的缓冲区”。因此可以将独到的最后一个字节回退 InputStream 通常作为编辑器的扫描器，之所以包含在内是因为Java编译器的需要，我们可能永远不会用到

2)通过FilterOutputStream想OutputStream写入
表FilterOutputStream类型（常用子类）
-----------------------------------------------------------------------------------
类功能构造器参数（如何使用）
DataOutputStream 与DataInputStream搭配使用，因此可以按照可移植方式向流中写入基本类型 OutputStream 包含用于写入基本类型数据的全部接口
PrintStream 用于产生格式化输出。其中DataOutputStream处理数据存储，PrintStream处理显示 OutputStream，可以用boolean值指示是否每次转换时清楚缓冲区应该是对OutputStream对象的“final”封装，可能经常使用到他
BufferedOutputStream 使用它以避免每次发送数据时都要进行实际的写操作。代表“使用缓冲区”。可以调用flush()清空缓冲区 OutputStream，可以指定缓冲区大小本质上并不提供接口，只不过向进程中添加缓冲区所必需的。与接口对象搭配

Reader和Writer

Java 1.1对基本的I/O流类库进行了重大修改。
Reader和Writer提供兼容Unicode与面向字符的I/O功能。
另外：
1)Java 1.1向InputStream和OutputStream继承层次结构中添加了一些新类，所以显然这两个类是不会被取代的。
2)有时我们必须来自“字节”层次结构中的类和“字符”层次结构中的类结合起来使用。为了实现这个目的，要用到“适配器”类：
InputStreamReader可以把InputStream转换为Reader，而OutputStreamWriter可以把OutputStream抓换为Writer。

1、数据的来源和去处
几乎所以原始的Java I/O流类都有相应的Reader和Writer类来提供天然的Unicode操作。
然而在某些场合，面向字节的InputStream和OutputStream才是正确的解决方案；特别是，java.util.zip类库就是面向字节而不是面向字符。
因此，最明智的做法是尽量尝试使用Reader和Writer，一旦程序代码无法成功编译，我们就会发现不的不使用面向字节的类库。
===================================================
来源与去处：Java 1.0类相应的Java1.1类
----------------------------------------------------------------------
InputStream Reader 适配器：InputStreamReader
OutputStream Writer 适配器：OutputStreamWriter
FileInputStream FileReader
FileOutputStream FileWriter
ByteArrayInputStream CharArrayReader
ByteArrayOutputStream CharArrayWriter
PipedInputStream PipedReader
PipedOutputStream PipedWriter

2、更改流的行为
无论我们何时readLine()，都不应该使用DataInputStream，而应该使用BufferedReader。除了这一点，DataInputStream仍是I/O类库的首选成员。

自我独立的类：RandomAccessFile

RandomAccessFile适用于由大小已经的记录组成的文件，所以我们可以使用seek()将记录从一处转移到另一处，然后读取或者修改记录。

IO流的典型使用方式

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

package cn.partner4java.demo;

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

/**
 * 缓冲输入文件
 * 如果想打开一个文件用于字符输入，可以使用String或File对象作为文件名的FileInputStream。
 * 为了提高速度，我们希望对那个文件进行缓冲，那么我们将所产生的引用传递给一个BufferedReader构造器。
 * 由于BufferedReader也提供readLine()方法，所以这是我们的最终对象和进行读取的接口。
 * 当readLine()将返回null时，你就达到了文件的结尾。
 * @author partner4java
 *
 */
public class BufferedInputFile {
	public static String read(String filename) throws IOException{
		BufferedReader in = new BufferedReader(new FileReader(filename));
		String s;
		StringBuffer sb = new StringBuffer();
		while((s = in.readLine())!= null){
			sb.append(s + "\n");
		}
		in.close();
		return sb.toString();
	}
	
	public static void main(String[] args) throws IOException {
		System.out.print(read("./src/cn/partner4java/demo/BufferedInputFile.java"));
	}
}

2、从内存输入
从BufferedInputFile.read()读入的String结果被用来创建一个StringReader。
然后调用read()每次读取一个字符，并把它发送到控制台。
demo:

package cn.partner4java.demo;

import java.io.IOException;
import java.io.StringReader;

/**
 * 从内存输入
 * 从BufferedInputFile.read()读入的String结果被用来创建一个StringReader。
 * 然后调用read()每次读取一个字符，并把它发送到控制台。
 * @author partner4java
 *
 */
public class MemoryInput {

	public static void main(String[] args) throws IOException {
		StringReader in = new StringReader(BufferedInputFile.read("./src/cn/partner4java/demo/BufferedInputFile.java"));
		int c;
		while((c = in.read()) != -1){
			System.out.print((char)c);
		}
	}

}

3、格式化的内存输入
demo:

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

4、基本的文件输出
FileWriter对象可以向文件写入数据。首先，创建一个与指定文件连接的FileWriter。实际上，我们通常会用BufferedWriter将其包装起来用以缓冲输出。为了提供格式化机制，又被装配成了PrintWriter。
demo:

public class BasicFileOutput {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new FileReader(
				"./src/cn/partner4java/demo/BasicFileOutput.java"));
		PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
				"./src/cn/partner4java/demo/BasicFileOutput.out")));
		int lineCount = 1;
		String s;
		while ((s = in.readLine()) != null) {
			out.println(lineCount++ + ":" + s);
		}
		out.close();
	}
}

文本文件输出的快捷方式
内部还是使用了缓存。
demo:

public class FileOutputShortcut {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new FileReader(
				"./src/cn/partner4java/demo/FileOutputShortcut.java"));
		PrintWriter out = new PrintWriter(public class StoringAndRecoveringData {
	
	public static void main(String[] args) throws IOException {
		DataOutputStream out = new DataOutputStream(new BufferedOutputStream(
				new FileOutputStream("./src/cn/partner4java/demo/dataout.out")));
		out.writeDouble(2.12121);
		out.writeUTF("世界和平");
		out.writeDouble(12.13241);
		out.writeUTF("天下太平");
		out.close();
		DataInputStream in = new DataInputStream(new BufferedInputStream(
				new FileInputStream("./src/cn/partner4java/demo/dataout.out")));
		System.out.println(in.readDouble());
		System.out.println(in.readUTF());
		System.out.println(in.readDouble());
		System.out.println(in.readUTF());
	}

}

"./src/cn/partner4java/demo/FileOutputShortcut.out");int lineCount = 1;String s;while ((s = in.readLine()) != null) {out.println(lineCount++ + ":" + s);}out.close();}}

5、存储和恢复数据
为了输出可供另一个“流”恢复的数据，我们需要用DataOutputStream写入数据，并用DataInputStream恢复数据。

public class StoringAndRecoveringData {
	
	public static void main(String[] args) throws IOException {
		DataOutputStream out = new DataOutputStream(new BufferedOutputStream(
				new FileOutputStream("./src/cn/partner4java/demo/dataout.out")));
		out.writeDouble(2.12121);
		out.writeUTF("世界和平");
		out.writeDouble(12.13241);
		out.writeUTF("天下太平");
		out.close();
		DataInputStream in = new DataInputStream(new BufferedInputStream(
				new FileInputStream("./src/cn/partner4java/demo/dataout.out")));
		System.out.println(in.readDouble());
		System.out.println(in.readUTF());
		System.out.println(in.readDouble());
		System.out.println(in.readUTF());
	}

}

6、读取随机访问文件
demo:

public class UsingRandomAccessFile {
	static String file = "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);
		rf.close();
		display();
	}
}

7、管道流
PipedInputStream、PipedOutputStream、PipedReader和PipedWriter，主要价值在于多线程通信的应用。

文件读写的实用工具

一个很常见的程序化任务就是读取文件到内存，修改，然后再写出。
因此在我们的类库中，添加一些常用的帮助类就非常有意义。

简化对文件读取的操作
demo：
public class TextFile extends ArrayList<String> {
	// Read a file as a single string:
	public static String read(String fileName) {
		StringBuilder sb = new StringBuilder();
		try {
			BufferedReader in = new BufferedReader(new FileReader(new File(
					fileName).getAbsoluteFile()));
			try {
				String s;
				while ((s = in.readLine()) != null) {
					sb.append(s);
					sb.append("\n");
				}
			} finally {
				in.close();
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
		return sb.toString();
	}

	// Write a single file in one method call:
	public static void write(String fileName, String text) {
		try {
			PrintWriter out = new PrintWriter(
					new File(fileName).getAbsoluteFile());
			try {
				out.print(text);
			} finally {
				out.close();
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	// Read a file, split by any regular expression:
	public TextFile(String fileName, String splitter) {
		super(Arrays.asList(read(fileName).split(splitter)));
		// Regular expression split() often leaves an empty
		// String at the first position:
		if (get(0).equals(""))
			remove(0);
	}

	// Normally read by lines:
	public TextFile(String fileName) {
		this(fileName, "\n");
	}

	public void write(String fileName) {
		try {
			PrintWriter out = new PrintWriter(
					new File(fileName).getAbsoluteFile());
			try {
				for (String item : this)
					out.println(item);
			} finally {
				out.close();
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	// Simple test:
	public static void main(String[] args) {
		String file = read("TextFile.java");
		write("test.txt", file);
		TextFile text = new TextFile("test.txt");
		text.write("test2.txt");
		// Break into unique sorted list of words:
		TreeSet<String> words = new TreeSet<String>(new TextFile(
				"TextFile.java", "\\W+"));
		// Display the capitalized words:
		System.out.println(words.headSet("a"));
	}
}/* Output:
[0, ArrayList, Arrays, Break, BufferedReader, BufferedWriter, Clean, Display, File, FileReader, FileWriter, IOException, Normally, Output, PrintWriter, Read, Regular, RuntimeException, Simple, Static, String, StringBuilder, System, TextFile, Tools, TreeSet, W, Write]
*///:~


读取二进制文件：
demo：
public class BinaryFile {
	public static byte[] read(File bFile) throws IOException {
		BufferedInputStream bf = new BufferedInputStream(new FileInputStream(
				bFile));
		try {
			byte[] data = new byte[bf.available()];
			bf.read(data);
			return data;
		} finally {
			bf.close();
		}
	}

	public static byte[] read(String bFile) throws IOException {
		return read(new File(bFile).getAbsoluteFile());
	}
}

Java IO系统（上）