1、File
不同的操作系统对于档案系统路径的设定各有差别，例如在Windows中，一个路径的表示法可能是：
"c:\\Windows\\Fonts\\"
而在Linux下的路径设定可能是：
"/home/justin/"
Windows的路径指定是使用UNC（Universal Naming Convention）路径名，以\\开始表示磁盘根目录，如果没有以\\开始表示相对路径，c是可选的磁盘指定，后面跟随着 : 字符。而UNIX-Like系统的路径指定以 / 开始表示绝对路径，不以 / 开始表示相对路径。
因而在程序中设定路径时会有系统相依性的问题，File类别提供一个抽象的、与系统独立的路径表示，您给它一个路径字符串，它会将它转换为与系统无关的抽象路径表示，这个路径可以指向一个档案、目录或是URI，您可以用以下四种方式来建构File的实例：
File(File parent, String child) File(String pathname) File(String parent, String child) File(URI uri)
一个File的实例被建立时，它就不能再被改变内容；File类别除了用来表示一个档案或目录的抽象表示之外，它还提供了不少相关操作方法，您可以用它来对档案系统作一些查询与设定的动作。
来看个简单的程序：
FileDemo.java
package onlyfun.caterpillar;
import java.io.*;
import java.util.*;
public class FileDemo {
public static void main(String[] args) {
try {
File file = new File(args[0]);
if(file.isFile()) { // 是否为档案
System.out.println(args[0] + " 档案");
System.out.print(
file.canRead() ? "可读 " : "不可读 ");
System.out.print(
file.canWrite() ? "可写 " : "不可写 ");
System.out.println(
file.length() + "字节");
}
else {
// 列出所有的档案及目录
File[] files = file.listFiles();
ArrayList fileList =
new ArrayList();
for(int i = 0; i < files.length; i++) {
// 先列出目录
if(files[i].isDirectory()) { //是否为目录
// 取得路径名
System.out.println("[" +
files[i].getPath() + "]");
}
else {
// 档案先存入fileList，待会再列出
fileList.add(files[i]);
}
}
// 列出档案
for(File f: fileList) {
System.out.println(f.toString());
}
System.out.println();
}
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(
"using: java FileDemo pathname");
}
}
}
执行结果：
java onlyfun.caterpillar.FileDemo C:\ [C:\WINDOWS] [C:\Documents and Settings] [C:\Program Files] [C:\System Volume Information] [C:\Recycled] C:\A3N_A3L.10 C:\bootfont.bin C:\ntldr C:\NTDETECT.COM C:\boot.ini C:\CONFIG.SYS C:\AUTOEXEC.BAT C:\IO.SYS C:\MSDOS.SYS C:\Finish.log C:\pagefile.sys C:\VIRTPART.DAT
9、RandomAccessFile
档案存取通常是「循序的」，每在档案中存取一次，读取档案的位置就会相对于目前的位置前进，然而有时候您必须对档案的某个区段进行读取或写入的动作，也就是进行「随机存取」（Random access），也就是说存取档案的位置要能在档案中随意的移动，这时您可以使用RandomAccessFile，使用seek()方法来指定档案存取的位置，指定的单位是字节，藉由它您就可以对档案进行随机存取的动作。
为了方便，通常在随机存取档案时会固定每组资料的长度，例如一组学生个人数据，Java中并没有像C/C++中可以直接写入一个固定长度结构（Structure）的方法，所以在固定每组长度的方面您必须自行设计。
下面这个程序示范了如何使用RandomAccessFile来写入档案，并随机读出一笔您所想读出的资料：
Student.java
package onlyfun.caterpillar;
public class Student {
private String name; // 固定 15 字符
private int score;
public Student() {
setName("noname");
}
public Student(String name, int score) {
setName(name);
this.score = score;
}
public void setName(String name) {
StringBuilder builder = null;
if(name != null)
builder = new StringBuilder(name);
else
builder = new StringBuilder(15);
builder.setLength(15);
this.name = builder.toString();
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
// 每笔数据固定写入34字节
public static int size() {
return 34;
}
}
RandomAccessFileDemo.java
package onlyfun.caterpillar;
import java.io.*;
import java.util.*;
public class RandomAccessFileDemo {
public static void main(String[] args) {
Student[] students = {
new Student("Justin", 90),
new Student("momor", 95),
new Student("Bush", 88),
new Student("caterpillar", 84)};
try {
File file = new File(args[0]);
// 建立RandomAccessFile实例并以读写模式开启档案
RandomAccessFile randomAccessFile =
new RandomAccessFile(file, "rw");
for(int i = 0; i < students.length; i++) {
randomAccessFile.writeChars(students[i].getName());
randomAccessFile.writeInt(students[i].getScore());
}
Scanner scanner = new Scanner(System.in);
System.out.print("读取第几笔数据？");
int num = scanner.nextInt();
randomAccessFile.seek((num-1) * Student.size());
Student student = new Student();
student.setName(readName(randomAccessFile));
student.setScore(randomAccessFile.readInt());
System.out.println("姓名：" + student.getName());
System.out.println("分数：" + student.getScore());
randomAccessFile.close();
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println("请指定文件名称");
}
catch(IOException e) {
e.printStackTrace();
}
}
private static String readName(
RandomAccessFile randomAccessfile)
throws IOException {
char[] name = new char[15];
for(int i = 0; i < name.length; i++)
name[i] = randomAccessfile.readChar();
return new String(name).replace('\0', ' ');
}
}
在实例化一个RandomAccessFile对象时，要设定档案开启的方式，设定"r"表示只供读取，设定"rw"表示可读可写；为了让每组数据长度固 定，在写入name时，我们使用 StringBuilder 并设定其长度固定为15个字符，而读回name时则直接读回15个字符，然后再去掉空格符传回。
10、InputStream与OutputStream
计算机中的数据都是以0与1的方式来储存，如果您要在两个装置之间进行数据的存取，当然也是以0与1位的方式来进行，实际上数据的流动是透过电路，而上面 的数据则是电流，而在程序上来说，将数据目的地与来源之间抽象化为一个串流（Stream），而当中流动的则是位数据。
01010101 Stream -->
来源地 ===================== 目的地
在Java中有两个类别用来作串流的抽象表示：InputStream与OutputStream。
InputStream是所有表示位输入串流的类别之父类别，它是一个抽象类别，子类会重新定义它当中所定义的方法， InputStream用于从装置来源地读取数据的抽象表示，例如System中的标准输入串流 in 对象就是一个 InputStream，在程序开始之后，这个串流对象就会开启，以从标准输入装置中读取数据，这个装置通常是键盘或是其它使用者定义的装置。
OutputStream是所有表示位输出串流的类别之父类别，它是一个抽象类别，子类会重新定义它当中所定义的方法， OutputStream是用于将数据写入目的地的抽象表示，例如System中的标准输出串流对象 out ，out 的类型是PrintStream， 这个类别是OutputStream的子类别（FilterOutputStream继承OutputStream， PrintStream再继承FilterOutputStream），在程序开始之后，这个串流对象就会开启，您可以将数据透过它来写入目的地装置，这 个装置通常是屏幕或其它使用者定义的装置。
下面程序可以读取键盘输入串流，并将资料以10进位方式显示在屏幕上：
StreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class StreamDemo {
public static void main(String[] args) {
try {
System.out.print("输入字符: ");
System.out.println("输入字符十进制表示: " +
System.in.read());
System.out.println("换行字符十进制表示: " +
System.in.read());
}
catch(IOException e) {
e.printStackTrace();
}
}
}
执行结果：
输入字符: A? 输入字符十进制表示: 65 换行字符十进制表示: 10
字符A输入后被标准输入串流读取，A的位表示以十进制来看就是65，这是A字符的编码（查查ASCII编码表就知道了），在这边要注意的是read()只读取一个字节的数据，而当输入A并按Enter键时，实际上在串流中会有A的位数据与换行字符的位数据，换行字符的位数据以十进制来表示的话就是10。
操作系统之间的换行字符各不相同，Windows 为"\r\n"，Linux 为'\n'，而 Mac 为'\r'。
11、BufferedInputStream、 BufferedOutputStream
在介绍 FileInputStream、 FileOutputStream的 例子中，您使用了一个数组来作为数据读入的缓冲区，以档案存取为例的话，您知道磁盘存取的速度是远低于内存中的数据存取速度，为了减少对磁盘的存 ，您一次读入一定长度的数据，如上一个主题范例中的1024字节，而写入时也是一次写入一定长度的数据，这可以增加数据存取的效率。
BufferedInputStream与BufferedOutputStream可以为InputStream类的对象增加缓冲区功能，使用它们，您无需自行设计缓冲区。
BufferedInputStream的数据成员buf是个位数组，预设为2048字节大小，当读取数据来源时，例如档案， BufferedInputStream会尽量将buf填满，当使用read()方法时，实际上是先读取buf中的数据，而不是直接对数据来源作读取，当buf中的数据不足时，BufferedInputStream才会再从数据来源中提取数据。
BufferedOutputStream的数据成员buf是个位数组，预设为512个字节，当写入数据时，会先将资料存至buf中，当buf已满时才会一次将数据写至目的地，而不是每次写入都对目的地作写入。
将上一个主题的范例作个改写，这次不用自行设定缓冲区并进行判断了，使用BufferedInputStream、 BufferedOutputStream让程序看来简单一些，也比较有效率：
BufferedStreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class BufferedStreamDemo {
public static void main(String[] args) {
try {
byte[] data = new byte[1];
File srcFile = new File(args[0]);
File desFile = new File(args[1]);
BufferedInputStream bufferedInputStream =
new BufferedInputStream(
new FileInputStream(srcFile));
BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(
new FileOutputStream(desFile));
System.out.println("复制档案：" +
srcFile.length() + "字节");
while(bufferedInputStream.read(data) != -1) {
bufferedOutputStream.write(data);
}
// 将缓冲区中的数据全部写出
bufferedOutputStream.flush();
// 关闭串流
bufferedInputStream.close();
bufferedOutputStream.close();
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(
"using: java UseFileStream src des");
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
}
}
为了确保缓冲区中的数据一定被写出，建议最后执行flush()将缓冲区中的数据全部写出目的串流中。
BufferedInputStream、BufferedOutputStream并没有改变来源InputStream或目的 OutputStream的行为，读入或写出时的动作还是InputStream、OutputStream负责， BufferedInputStream、BufferedOutputStream只是在这之前动态的为它们加上一些功能（像是缓冲区功能），在这边是 以档案存取串流为例，实际上您可以在其它串流对象上加上BufferedInputStream、BufferedOutputStream功能。
12、FileInputStream、 FileOutputStream
FileInputStream是InputStream的子类，由名称上就可以知道， FileInputStream主要就是从指定的档案中读取数据至目的地。
FileOutputStream是OutputStream的子类，顾名思义，FileInputStream主要就是从来源地写入数据至指定的档案中。
标准输入输出串流对象在程序一开始就会开启，但只有当您建立一个FileInputStream或FileOutputStream的实例时，实际的串流才会开启，而不使用串流时，也必须自行关闭串流，以释放与串流相依的系统资源。
下面这个程序可以复制档案，程序先从来源档案读取数据至一个位缓冲区中，然后再将位数组的数据写入目的档案：
FileStreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class FileStreamDemo {
public static void main(String[] args) {
try {
byte[] buffer = new byte[1024];
FileInputStream fileInputStream =
new FileInputStream(new File(args[0]));
FileOutputStream fileOutputStream =
new FileOutputStream(new File(args[1]));
System.out.println("复制档案：" +
fileInputStream.available() + "字节");
while(true) { // 从来源档案读取数据至缓冲区
if(fileInputStream.available() < 1024) {
int remain;
while((remain = fileInputStream.read())
!= -1) {
fileOutputStream.write(remain);
}
break;
}
else {
fileInputStream.read(buffer);
// 将数组数据写入目的档案
fileOutputStream.write(buffer);
}
}
// 关闭串流
fileInputStream.close();
fileOutputStream.close();
System.out.println("复制完成");
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(
"using: java FileStreamDemo src des");
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
}
}
这个程序示范了两个 read() 方法，一个可以读入指定长度的数据至数组，一个一次可以读入一个字节，每次读取之后，读取的指标都会往前进，您使用available()方法获得还有多少字节可以读取；除了使用File来建立FileInputStream、FileOutputStream的实例之外，您也可以直接使用字符串指定路径来建立。
不使用串流时，记得使用close()方法自行关闭串流，以释放与串流相依的系统资源。
13、ObjectInputStream、ObjectOutputStream
在Java这样支持对象导向的程序中撰写程序，很多数据都是以对象的方式存在，在程序运行过后，您会希望将这些数据加以储存，以供下次执行程序时使用，这时您可以使用ObjectInputStream、ObjectOutputStream来进行这项工作。
要被储存的对象必须实作Serializable接口，说是实作，其实Serializable中并没有规范任何必须实作的方法，所以这边所谓实作的意义，其实像是对对象贴上一个标志，代表该对象是可以序列化的（Serializable）。
一个实作的例子如下所示：
Student.java
package onlyfun.caterpillar;
import java.io.*;
public class Student implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int score;
public Student() {
name = "N/A";
}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public void setName(String name) {
this.name = name;
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
public void showData() {
System.out.println("name: " + name);
System.out.println("score: " + score);
}
}
您要注意到serialVersionUID，这代表了可序列化对象的版本， 如果您没有提供这个版本讯息，则会自动依类名称、实现的接口、成员等讯息来产生，如果是自动产生的，则下次您更改了Student类，则自动产生的 serialVersionUID也会跟着变更，当反序列化时两个serialVersionUID不相同的话，就会丢出 InvalidClassException，如果您想要维持版本讯息的一致，则要显式宣告serialVersionUID。
ObjectInputStream、ObjectOutputStream为InputStream、OutputStream加上了可以让使用者写入 对象、读出对象的功能，在写入对象时，我们使用writeObject()方法，读出对象时我们使用readObject()方法，被读出的对象都是以 Object的型态传回，您必须将之转换为对象原来的型态，才能正确的操作被读回的对象，下面这个程序示范了如何简单的储存对象至档案中，并将之再度读 回：
ObjectStreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
import java.util.*;
public class ObjectStreamDemo {
public static void writeObjectsToFile(
Object[] objs, String filename) {
File file = new File(filename);
try {
ObjectOutputStream objOutputStream =
new ObjectOutputStream(
new FileOutputStream(file));
for(Object obj : objs) {
objOutputStream.writeObject(obj);
}
objOutputStream.close();
}
catch(IOException e) {
e.printStackTrace();
}
}
public static Object[] readObjectsFromFile(
String filename)
throws FileNotFoundException {
File file = new File(filename);
if(!file.exists())
throw new FileNotFoundException();
List list = new ArrayList();
try {
FileInputStream fileInputStream =
new FileInputStream(file);
ObjectInputStream objInputStream =
new ObjectInputStream(fileInputStream);
while(fileInputStream.available() > 0) {
list.add(objInputStream.readObject());
}
objInputStream.close();
}
catch(ClassNotFoundException e) {
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
return list.toArray();
}
public static void appendObjectsToFile(
Object[] objs, String filename)
throws FileNotFoundException {
File file = new File(filename);
if(!file.exists())
throw new FileNotFoundException();
try {
ObjectOutputStream objOutputStream =
new ObjectOutputStream(
new FileOutputStream(file, true)) {
protected void writeStreamHeader()
throws IOException {}
};?
for(Object obj : objs) {
objOutputStream.writeObject(obj);
}
objOutputStream.close();
}
catch(IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Student[] students = {new Student("caterpillar", 90),
new Student("justin", 85)};
// 写入新档
writeObjectsToFile(students, "data.dat");
try {
// 读取档案数据
Object[] objs = readObjectsFromFile("data.dat");
for(Object obj : objs) {
((Student) obj).showData();
}
System.out.println();
students = new Student[2];
students[0] = new Student("momor", 100);
students[1] = new Student("becky", 100);
// 附加至档案
appendObjectsToFile(students, "data.dat");
// 读取档案数据
objs = readObjectsFromFile("data.dat");
for(Object obj : objs) {
((Student) obj).showData();
}
}
catch(FileNotFoundException e) {
e.printStackTrace();
}
}
}
对象被写出时，会写入对象的类别型态、类别署名（Class signature），static与被标志为transient的成员则不会被写入。
在这边注意到以附加的形式写入数据至档案时，在试图将对象附加至一个先前已写入对象的档案时，由于ObjectOutputStream在 写入数据时，还会加上一个特别的标示头，而读取档案时会检查这个标示头，如果一个档案中被多次附加对象，那么该档案中会有多个标示头，如此读取检查时就会 发现不一致，这会丢出StreamCorrupedException，为此，您重新定义ObjectOutputStream的writeStreamHeader()方法，如果是以附加的方式来写入对象，就不写入标示头：
ObjectOutputStream objOutputStream =
new ObjectOutputStream(
new FileOutputStream(file, true)) {
protected void writeStreamHeader()
throws IOException {}
};
将对象写出或读入并不仅限于档案存取，您也可以用于网络的数据传送，例如传送整个对象数据或是影像档案。
14、DataInputStream、DataOutputStream
DataInputStream、DataOutputStream可提供一些对Java基本数据型态写入的方法，像是读写int、double、 boolean等的方法，由于Java的数据型态大小是规定好的，在写入或读出这些基本数据型态时，就不用担心不同平台间资料大小不同的问题。
这边还是举档案存取来进行说明，有时候您只是要储存一个对象的成员数据，而不是整个对象的信息，成员数据的型态假设都是Java的基本数据型态，您不必要 使用Object输入、输出相关串流对象，而可以使用DataInputStream、DataOutputStream来写入或读出数据，下面这个程序 是个简单的示范：
Student.java
package onlyfun.caterpillar;
public class Student?{
private String name;
private int score;
public Student() {
name = "N/A";
}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public void setName(String name) {
this.name = name;
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
public void showData() {
System.out.println("name: " + name);
System.out.println("score: " + score);
}
}
DataStreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class DataStreamDemo {
public static void main(String[] args) {
Student[] students = {new Student("Justin", 90),
new Student("momor", 95),
new Student("Bush", 88)};
try {
DataOutputStream dataOutputStream =
new DataOutputStream(
new FileOutputStream("data.dat"));
for(Student student : students) {
dataOutputStream.writeUTF(student.getName());
dataOutputStream.writeInt(student.getScore());
}
dataOutputStream.flush();
dataOutputStream.close();
DataInputStream dataInputStream =
new DataInputStream(
new FileInputStream("data.dat"));
for(int i = 0; i < students.length; i++) {
String name = dataInputStream.readUTF();
int score = dataInputStream.readInt();
students[i] = new Student(name, score);
students[i].showData();
}
dataInputStream.close();
}
catch(IOException e) {
e.printStackTrace();
}
}
}
这个程序在写入档案时，只提取对象的成员数据，而在读出时将这些数据读出，并将读回的数据设定给一个实例，是对象数据还原的一种方式。
15、SequenceInputStream
您将一个档案分割为数个档案，接下来要将之再度组合还原为原来的档案，最基本的作法是使用数个 FileInputStream来开启分割后的档案，然后一个一个档案的读取，并连续写入至同一个FileOutputStream中，在这中间，您必须 要自行判断每一个分割档案的读取是否完毕，如果完毕就换读取下一个档案。
如果您使用SequenceInputStream就不用这么麻烦，SequenceInputStream可以看作是数个 InputStream对象的组合，当一个InputStream对象的内容读取完毕后，它就会取出下一个InputStream对象，直到所有的 InputStream对象都读取完毕为止。
下面这个程序是SequenceInputStream的使用示范，它可以将指定的档案进行分割，也可以将分割后的档案还原为一个档案：
SequenceStreamDemo.java
package onlyfun.caterpillar;
import java.util.*;
import java.io.*;
public class SequenceStreamDemo {
public static void main(String[] args) {
try {
// args[0]: 指定分割（s）或连接（c）
switch (args[0].charAt(1)) {
case 's':
// args[1]: 每个分割档案的大小
int size = Integer.parseInt(args[1]);
// args[2]: 指定要被分割的文件名称
seperate(args[2], size);
break;
case 'c':
// args[1]: 指定要被组合的档案个数
int number = Integer.parseInt(args[1]);
// args[2]: 组合后的文件名称
concatenate(args[2], number);
break;
}
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(
"Using: java UseSequenceStream [-s/-c]" +
" (size/number) filename");
System.out.println("-s: 分割档案\n-c: 组合档案");
}
catch(IOException e) {
e.printStackTrace();
}
}
// 分割档案
public static void seperate(String filename, int size)
throws IOException {
FileInputStream fileInputStream =
new FileInputStream(new File(filename));
BufferedInputStream bufInputStream =
new BufferedInputStream(fileInputStream);
byte[] data = new byte[1];
int count = 0;?
// 从原档案大小及指定分割的大小
// 决定要分割为几个档案
if(fileInputStream.available() % size == 0)
count = fileInputStream.available() / size;
else
count = fileInputStream.available() / size + 1;
// 开始进行分割
for(int i = 0; i < count; i++) {
int num = 0;
// 分割的档案加上底线与编号
File file = new File(filename + "_" + (i + 1));
BufferedOutputStream bufOutputStream =
new BufferedOutputStream(
new FileOutputStream(file));
while(bufInputStream.read(data) != -1) {
bufOutputStream.write(data);
num++;
if(num == size) { // 分割出一个档案
bufOutputStream.flush();
bufOutputStream.close();
break;
}
}
if(num < size) {
bufOutputStream.flush();
bufOutputStream.close();
}
}
System.out.println("分割为" + count + "个档案");
}
// 连接档案
public static void concatenate(String filename,
int number) throws IOException {
// 收集档案用的List
List list =
new ArrayList();
for(int i = 0; i < number; i++) {
// 文件名必须为底线加上编号
File file = new File(filename + "_" + (i+1));
list.add(i, new FileInputStream(file));
}
final Iterator iterator = list.iterator();
// SequenceInputStream 需要一个Enumeration对象来建构
Enumeration enumation =
new Enumeration() {
public boolean hasMoreElements() {
return iterator.hasNext();
}
public InputStream nextElement() {
return iterator.next();
}
};
// 建立SequenceInputStream
// 并使用BufferedInputStream
BufferedInputStream bufInputStream =
new BufferedInputStream(
new SequenceInputStream(enumation),
8192);
BufferedOutputStream bufOutputStream =
new BufferedOutputStream(
new FileOutputStream(filename), 8192);
byte[] data = new byte[1];
// 读取所有档案数据并写入目的地档案
while(bufInputStream.read(data) != -1)
bufOutputStream.write(data);
bufInputStream.close();
bufOutputStream.flush();
bufOutputStream.close();
System.out.println("组合" + number + "个档案 OK!!");
}
}
分割档案时的范例如下：
java onlyfun.caterpillar.SequenceStreamDemo -s 1048576 test.zip 分割为6个档案
组合档案时的范例如下：
java onlyfun.caterpillar.SequenceStreamDemo -c 6 test.zip 组合6个档案 OK!!
16、PrintStream
之前所介绍过的Stream输出对象，都是直接将内存中的数据写出至目的地（例如一个档案），举个例子来说，如果您将 int 整数 1 使用之前介绍的Stream对象输出至档案，则档案中所储存的是 int 整数 1 在内存中的值，例如：
FileStream.java
package onlyfun.caterpillar;
import java.io.*;
public class FileStreamDemo {
public static void main(String[] args)
throws IOException {
FileOutputStream file =
new FileOutputStream(
new File("test.txt"));
file.write(1);
file.close();
}
}
由于您使用write()方法，这会将 1 在内存中的值之低字节0000001写入档案中，所以如果您使用文字编辑软件（像vi或UltraEdit）观看test.txt的16进位表示，其结果会显示 01（16进位表示）。
有时候您所想要储存的结果是转换为字符之后的结果，例如若程序的执行结果是3.14159，您会希望使用字符来储存3.14159，也就是俗称的储存为纯文本文件，如此当您使用简单的纯文字编辑器观看时，就可以直接看到程序执行的结果。
例如您若想使用纯文本文件看到test.txt的显示结果是1，则必须先将内存中的整数1，也就是二进制00000000 00000000 00000000 00000001转换为对应的字符编码，也就是0x31（十进制表示49）并加以储存。
使用PrintStream可以自动为您进行字符转换的动作，它会使用操作系统的预设编码来处理对应的字符转换动作，直接使用下面这个例子来作示范：
PrintStreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class PrintStreamDemo {
public static void main(String[] args)
throws FileNotFoundException {
PrintStream printStream = new PrintStream(
new FileOutputStream(
new File("pi.txt")));
printStream.print("PI = ");
printStream.println(Math.PI);
printStream.close();
}
}
执行程序之后使用纯文字编辑器开启pi.txt，其内容会是PI = 3.141592653589793，print()或println()接受int、char、String、double等等数据型态， println()会在输出之后加上换行字符，而print()则不会。
注意在档案储存上实际并没有二进制档案或是纯文本文件的分别，所有的档案所储存的都是二进制的数据，您俗称的纯文本文件，其实正确的说，是指储存的结果是经过字符转换，例如将 int 整数 1转换为字符 '1' 的编码结果并加以储存。
17、Reader、Writer
Reader、Writer支持Unicode标准字符集（Character set）（字节串流则只支持ISO-Latin-1 8-bit），在处理串流时，会根据系统预设的字符编码来进行字符转换，它们是抽象类别，真正您会使用其子类别，子类别通常会重新定义相关的方法。
在 PushbackInputStream 中，您读入一个含BIG5中文字及ASCII字符的文本文件，这边改写一下这个例子，使用Reader的子类别 InputStreamReader来转换读入的两个字节为汉字字符，并显示在屏幕上：
ReaderWriterDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class ReaderDemo {
public static void main(String[] args) {
try {
PushbackInputStream pushbackInputStream =
new PushbackInputStream(
new FileInputStream(args[0]));
byte[] array = new byte[2];
ByteArrayInputStream byteArrayStream =
new ByteArrayInputStream(array);
// reader会从已读的位数组中取出数据
InputStreamReader reader =
new InputStreamReader(byteArrayStream);
int tmp = 0;
int count = 0;
while((count = pushbackInputStream.read(array))
!= -1) {
// 两个字节转换为整数
tmp = (short)((array[0] << 8) |
(array[1] & 0xff));
tmp = tmp & 0xFFFF;
// 判断是否为BIG5，如果是则显示BIG5中文字
if(tmp >= 0xA440 && tmp < 0xFFFF) {
System.out.println("BIG5: " +
(char)reader.read());
// 重置ArrayInputStream的读取光标
// 下次reader才会再重头读取数据
byteArrayStream.reset();
}
else {
// 将第二个字节推回串流
pushbackInputStream.unread(array, 1, 1);
// 显示ASCII范围的字符
System.out.println("ASCII: " +
(char)array[0]);
}
}
pushbackInputStream.close();
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println("请指定文件名称");
}
catch(IOException e) {
e.printStackTrace();
}
}
}
假设的文本文件中有以下的文字："这T是e一s个t测试" ，执行结果会是：
BIG5: 这 ASCII: T BIG5: 是 ASCII: e BIG5: 一 ASCII: s BIG5: 个 ASCII: t BIG5: 测 BIG5: 试 ASCII: ! EOF?
InputStreamReader可以用字节串流中取出字节数据，并进行字符处理动作，关于Reader、Writer相关子类别，之后会于各相关主题进行介绍。
其余未看：
ByteArrayInputStream、ByteArrayOutputStream；
CharArrayReader、CharArrayWriter；
PushbackReader；
