[关闭]
@lemonguge 2015-07-01T08:13:16.000000Z 字数 12466 阅读 365

Java I/O系统（四）

I/O

笔者在这一篇将会对Java I/O系统的其他流类进行介绍，虽然可能并不常用，但是还是希望大家了解一下，同时这也是对笔者所掌握的知识进行温习。

合并流

在Java I/O系统中有一个流可以方便我们，将多个字节读取流和并成一个流（读取读取），将多个源合并成一个源，操作起来方便。这个流就是SequenceInputStream合并流，同样也是装饰器设计模式的一种体现。首先，我们看看怎么创建这个流。

  1. import java.io.BufferedReader;
  2. import java.io.FileInputStream;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.PrintStream;
  6. import java.io.SequenceInputStream;
  8. public class Sequence {
  10.     public static void main(String[] args) throws IOException {
  11.         Sequence1();
  12.     }
  13.     // 合并两个文件
  14.     public static void Sequence1() throws IOException {
  15.         FileInputStream fis1 = new FileInputStream("file1.txt");
  16.         FileInputStream fis2 = new FileInputStream("file2.txt");
  17.         SequenceInputStream sis = new SequenceInputStream(fis1, fis2);
  18.         InputStreamReader isr = new InputStreamReader(sis);
  19.         BufferedReader br = new BufferedReader(isr);
  20.         PrintStream ps = new PrintStream("file1&2.txt");
  21.         String line = null;
  22.         while ((line = br.readLine()) != null) {
  23.             ps.println(line);
  24.             ps.flush();
  25.         }
  26.         br.close();
  27.         ps.close();
  28.     }
  29. } ///~
  1. import java.io.BufferedReader;
  2. import java.io.FileInputStream;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintStream;
  7. import java.io.SequenceInputStream;
  8. import java.util.ArrayList;
  9. import java.util.Collections;
  10. import java.util.Enumeration;
  11. import java.util.List;
  13. public class Sequence {
  15.     public static void main(String[] args) throws IOException {
  16.         Sequence2();
  17.     }
  18.     // 合并多个个文件
  19.     public static void Sequence2() throws IOException {
  20.         FileInputStream fis1 = new FileInputStream("file1.txt");
  21.         FileInputStream fis2 = new FileInputStream("file2.txt");
  22.         FileInputStream fis3 = new FileInputStream("file3.txt");
  23.         List<FileInputStream> fisArr = new ArrayList<FileInputStream>();
  24.         fisArr.add(fis1);
  25.         fisArr.add(fis2);
  26.         fisArr.add(fis3);
  27.         // 使用集合工具类的方法生成枚举类型
  28.         Enumeration<FileInputStream> eum = Collections.enumeration(fisArr);
  29.         SequenceInputStream sis = new SequenceInputStream(eum);
  30.         BufferedReader br = new BufferedReader(new InputStreamReader(sis));
  31.         FileOutputStream fos = new FileOutputStream("file1&2&3.txt");
  32.         PrintWriter pw = new PrintWriter(fos, true); // 自动刷新
  33.         String line = null;
  34.         while ((line = br.readLine()) != null) {
  35.             pw.println(line);
  36.         }
  37.         br.close();
  38.         pw.close();
  39.     }
  40. } ///~

对象流

这种流可以用来操作对象，要操作对象的那个类必须实现Serializable接口，这接口是Java序列化的意思。什么是序列化呢，用于给被序列化的类加入ID号，用于判断类和对象是否是同一个版本。对象流可以将对象从堆内存中存到硬盘，使将对象持久化。

可以发现Serializable接口中没有任何需要实现的方法，该接口只是一个标记接口。虽然可以使用默认的序列化版本号，不过笔者推荐自定义序列号版本号，因为编译器的不同可能会导致反系列化时导致意外的InvalidClassException异常。

  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  8. class Person implements Serializable{
  9.     private static final long serialVersionUID = 1L;
  10.     private String name;
  11.     private int age;
  12.     public Person(String name, int age) {
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  16.     public String getName() { return name; }
  17.     public void setName(String name) { this.name = name; }
  18.     public int getAge() { return age; }
  19.     public void setAge(int age) { this.age = age; }
  20.     @Override
  21.     public String toString() { return name+":"+age; }
  23. }
  25. public class ObjectStream {
  27.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  28.         outputObj();
  29.         inputObj();
  30.     }
  31.     // 反序列化
  32.     public static void inputObj() throws IOException, ClassNotFoundException {
  33.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person&since1L.obj"));
  34.         Person _p = (Person) ois.readObject();
  35.         System.out.println(_p);
  36.         ois.close();
  37.     }
  38.     // 序列化
  39.     public static void outputObj() throws IOException {
  40.         Person p = new Person("小雨", 17);
  41.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person&since1L.obj"));
  42.         oos.writeObject(p);
  43.         oos.close();
  44.     }
  45. } /* Output:
  46. 小雨:17
  47. *///:~

当执行上面的文件时，可以在当前项目下发现有一个文件为“person&since1L.obj”。如果对Person类进行改变时，再来读取该文件，就会出现异常。

  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  8. class Person implements Serializable{
  9.     private static final long serialVersionUID = 2L; // 修改序列化版本号
  10.     private String name;
  11.     private int age;
  12.     public Person(String name, int age) {
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  16.     public String getName() { return name; }
  17.     public void setName(String name) { this.name = name; }
  18.     public int getAge() { return age; }
  19.     public void setAge(int age) { this.age = age; }
  20.     @Override
  21.     public String toString() { return name+":"+age; }
  23. }
  25. public class ObjectStream {
  27.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  28.         try {
  29.             inputObj();
  30.         } catch (InvalidClassException e) {
  31.             System.out.println(e.getMessage());
  32.         }
  33.     }
  35.     public static void inputObj() throws IOException, ClassNotFoundException {
  36.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person&since1L.obj"));
  37.         Person _p = (Person) ois.readObject();
  38.         System.out.println(_p);
  39.         ois.close();
  40.     }
  41. } /* Output:
  42. Person; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2
  43. *///:~

对于对象系列化，有一点需要注意的地方是：“静态的数据存储在方法区中不在堆中，系列化时不能保存该值。”如果我们想要非静态数据不被序列化，可以给成员变量前面加上transient关键字。

  1. import java.io.FileOutputStream;
  2. import java.io.IOException;
  3. import java.io.ObjectOutputStream;
  4. import java.io.Serializable;
  6. class Person implements Serializable{
  7.     private static final long serialVersionUID = 12345L;
  8.     private transient String name;
  9.     private static int age;
  10.     public Person(String name) {
  11.         this.name = name;
  12.     }
  13.     public String getName() { return name; }
  14.     public void setName(String name) { this.name = name; }
  15.     public static int getAge() { return age; }
  16.     public static void setAge(int age) { Person.age = age; }
  17.     @Override
  18.     public String toString() { return name+":"+age; }
  20. }
  22. public class ObjectStream {
  24.     public static void main(String[] args) throws IOException {
  25.         outputObj();
  26.     }
  27.     public static void outputObj() throws IOException {
  28.         Person.setAge(17);
  29.         Person p = new Person("小雨");
  30.         System.out.println(p);
  31.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.obj"));
  32.         oos.writeObject(p);
  33.         oos.close();
  34.     }
  35. } /* Output:
  36. 小雨:17
  37. *///:~

可以在当前项目下发现“person.obj”文件，此时我们对该文件进行反序列号。

  1. import java.io.FileInputStream;
  2. import java.io.IOException;
  3. import java.io.ObjectInputStream;
  4. import java.io.Serializable;
  6. class Person implements Serializable{
  7.     private static final long serialVersionUID = 12345L;
  8.     private transient String name;
  9.     private static int age;
  10.     public Person(String name) {
  11.         this.name = name;
  12.     }
  13.     public String getName() { return name; }
  14.     public void setName(String name) { this.name = name; }
  15.     public static int getAge() { return age; }
  16.     public static void setAge(int age) { Person.age = age; }
  17.     @Override
  18.     public String toString() { return name+":"+age; }
  20. }
  22. public class ObjectStream {
  24.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  25.         inputObj();
  26.     }
  27.     public static void inputObj() throws IOException, ClassNotFoundException {
  28.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.obj"));
  29.         Person _p = (Person) ois.readObject();
  30.         System.out.println(_p);
  31.         ois.close();
  32.     }
  33. } /* Output:
  34. null:0
  35. *///:~

操作基本数据类型流

之前介绍了操作对象的流，现在要接触新的流，用于操作基本数据类型。DataInputStream和DataOutputStream这两个流也是用来装饰其他流，下面会进行介绍：

  1. import java.io.DataOutputStream;
  2. import java.io.FileReader;
  3. import java.io.IOException;
  4. import java.io.PrintStream;
  6. public class DataStream {
  8.     public static void main(String[] args) throws IOException {
  9.         writeByte();
  10.         readDataFile();
  11.     }
  13.     public static void writeByte() throws IOException {
  14.         DataOutputStream dos = new DataOutputStream(new PrintStream("data.txt"));
  15.         // 0110-0001
  16.         dos.writeByte(97);
  17.         dos.write(97);
  18.         // 0000-0001-0110-0001
  19.         dos.writeByte(353);
  20.         dos.write(353);
  21.         dos.close();
  22.     }
  24.     public static void readDataFile() throws IOException {
  25.         FileReader fr = new FileReader("data.txt");
  26.         int ch = 0;
  27.         while ((ch = fr.read()) != -1) {
  28.             System.out.println((char) ch);
  29.         }
  30.         System.out.println("--end--");
  31.         fr.close();
  32.     }
  33. } /* Output:
  34. a
  35. a
  36. a
  37. a
  38. --end--
  39. *///:~

当前项目下的data.txt文件中显示的也是"aaaa"，writeByte()方法的效果如同write()，即写入指定参数的8个低位。实际上是有区别的，writeByte()（写入1-byte）方法将会先写入高位，只是后面的低位将其覆盖，write()是直接就写入低8位（写入1-byte）。不止是writeByte()方法，其他的writeInt()（写入4-byte）、writeChar()（写入2-byte）、writeShort()（写入2-byte）等等其他方法都是先写入高位。值得注意的是：writeByte()、writeChar()和writeShort()接受的都是int类型参数，writeBoolean()接受的是一个boolean布尔值。

  1. import java.io.DataOutputStream;
  2. import java.io.FileReader;
  3. import java.io.IOException;
  4. import java.io.PrintStream;
  5. // 写入字符
  6. public class DataStream {
  8.     public static void main(String[] args) throws IOException {
  9.         writeChar();
  10.         readDataFile();
  11.     }
  13.     public static void writeChar() throws IOException {
  14.         DataOutputStream dos = new DataOutputStream(new PrintStream("data.txt"));
  15.         // 0000-0000-0110-0001
  16.         dos.writeChar(97);
  17.         // 0000-0000-0110-0001-0110-0010-0110-0011
  18.         dos.writeChar(6382179);
  19.         dos.close();
  20.     }
  22.     public static void readDataFile() throws IOException {
  23.         FileReader fr = new FileReader("data.txt");
  24.         int ch = 0;
  25.         while ((ch = fr.read()) != -1) {
  26.             System.out.println((char) ch);
  27.         }
  28.         System.out.println("--end--");
  29.         fr.close();
  30.     }
  31. } /* Output:
  33. a
  34. b
  35. c
  36. --end--
  37. *///:~

当前项目下的data.txt文件中显示的是“愀换”两个字，这只是对字节查询了GBK编码表显示的结果。writeChar()将一个char值以2-byte值形式写入基础输出流中，先写入高字节。因为要先从高位写2-byte，实际写入6382179时的显示应该是这样的：高位2-byte为一个空格和"a"，接着低位覆盖写入了"b"和"c"。

  1. import java.io.DataOutputStream;
  2. import java.io.FileReader;
  3. import java.io.IOException;
  4. import java.io.PrintStream;
  5. // 写入字符串
  6. public class DataStream {
  8.     public static void main(String[] args) throws IOException {
  9.         writeChar();
  10.         readDataFile();
  11.     }
  13.     public static void writeString() throws FileNotFoundException, IOException {
  14.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
  15.         dos.writeBytes("abc");
  16.         dos.writeChars("abc");
  17.         dos.close();
  18.     }
  20.     public static void readDataFile() throws IOException {
  21.         FileReader fr = new FileReader("data.txt");
  22.         int ch = 0;
  23.         while ((ch = fr.read()) != -1) {
  24.             System.out.println((char) ch);
  25.         }
  26.         System.out.println("--end--");
  27.         fr.close();
  28.     }
  29. } /* Output:
  30. a
  31. b
  32. c
  34. a
  36. b
  38. c
  39. --end--
  40. *///:~

当前项目下的data.txt文件中显示的是"abc a b c"，至于中间的空格，因为writeChars()方法写入的是字符，即2-byte的数据，而读数据的时候中文以2-byte，而英文以1-byte来读再查询编码表，0对应的是空字符。这种现象在我们写int类型的基本数据时尤为明显。

  1. import java.io.DataOutputStream;
  2. import java.io.FileReader;
  3. import java.io.IOException;
  4. import java.io.PrintStream;
  5. // int类型写入4-byte
  6. public class DataStream {
  8.     public static void main(String[] args) throws IOException {
  9.         writeInt();
  10.         readDataFile();
  11.     }
  13.     public static void writeInt() throws FileNotFoundException, IOException {
  14.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
  15.         dos.writeInt(97);
  16.         dos.close();
  17.     }
  19.     public static void readDataFile() throws IOException {
  20.         FileReader fr = new FileReader("data.txt");
  21.         int ch = 0;
  22.         while ((ch = fr.read()) != -1) {
  23.             System.out.println((char) ch);
  24.         }
  25.         System.out.println("--end--");
  26.         fr.close();
  27.     }
  28. } /* Output:
  32. a
  33. --end--
  34. *///:~

当前项目下的data.txt文件中显示的是" a"，a前面有3个空格。对于DataOutputStream写入的基本数据数据，我们可以使用DataInputStream获取基本数据类型。

  1. import java.io.DataInputStream;
  2. import java.io.DataOutputStream;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. // int类型写入4-byte
  6. public class DataStream {
  7.     public static void main(String[] args) throws IOException {
  8.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
  9.         dos.write(97);
  10.         dos.writeByte(97);
  11.         dos.writeChar(97);
  12.         dos.writeInt(97);
  13.         dos.writeBoolean(true);
  14.         dos.close();
  15.         DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
  16.         System.out.print(dis.read());
  17.         System.out.print(dis.readByte());
  18.         System.out.print(dis.readChar());
  19.         System.out.print(dis.readInt());
  20.         System.out.print(dis.readBoolean());
  21.         dis.close();
  22.     }
  23. } /* Output:
  24. 9797a97true
  25. *///:~

对于DataOutputStream流中，有一个方法值得注意，void writeUTF(String str)以与机器无关方式使用UTF-8修改版编码将一个字符串写入基础输出流，所以使用转换率无法指定码表。（如果写到文本文件中看到的也是乱码）

  1. import java.io.DataInputStream;
  2. import java.io.DataOutputStream;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. // int类型写入4-byte
  6. public class DataStream {
  7.     public static void main(String[] args) throws IOException {
  8.         writeData();
  9.         readData();
  10.     }
  11.     public static void readData() throws IOException {
  12.         DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
  13.         String str = dis.readUTF();
  14.         System.out.println(str);
  15.     }
  17.     public static void writeData() throws IOException {
  18.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
  19.         dos.writeUTF("你好");// 使用了UTF-8修改版编码写入
  20.         dos.close();
  21.     }
  22. } /* Output:
  23. 你好
  24. *///:~

操作内存的流

操作内存的流有四个，内存字节输入输出流和内存字符输入输出流。因为这种类型的流只是操作内存，并不调用底层资源，所以并不需要调用close()方法，如果关闭该流后，还是可以调用此类中的各个方法，而不会产生任何IOException。

输入流的构造器都必须接受一个数组，内存字符输入流CharArrayReader的构造函数接受一个字符数组为其缓冲区数组，内存字节输入流ByteArrayInputStream的构造函数接受一个字节数组为其缓冲区数组。输入流的读方法都是从该缓存数组中进行读取的。

输出流的构造器可以有默认的，还可以指定大小的缓冲区容量，缓冲区会随着数据的不断写入而自动增长。可使用toByteArray()或toCharArray()和toString()获取数据，输出流都有一个writeTo()方法，将缓冲区的内容写入另一个流中。

  1. import java.io.ByteArrayInputStream;
  2. import java.io.ByteArrayOutputStream;
  4. public class Array {
  6.     public static void main(String[] args) {
  7.         ByteArrayInputStream bi = new ByteArrayInputStream("abc你好".getBytes());
  8.         ByteArrayOutputStream bo = new ByteArrayOutputStream();
  9.         int ch = 0;
  10.         while((ch=bi.read())!=-1){
  11.             bo.write(ch);
  12.         }
  13.         System.out.println(bo.toString()); // 获取内存缓冲区的数据
  14.     }
  15. } /* Output:
  16. abc你好
  17. *///:~

其中字符串缓冲字符流StringReader和StringWriter的使用和其非常类型，只不过不是缓冲数组，而会字符串缓冲。下面进行介绍一下：

  1. import java.io.IOException;
  2. import java.io.StringReader;
  3. import java.io.StringWriter;
  5. public class StringIO {
  6.     public static void main(String[] args) throws IOException {
  7.         StringReader sr = new StringReader("abc你好");
  8.         StringWriter sw = new StringWriter();
  9.         char[] chs = new char[4];
  10.         int length = 0;
  11.         while((length=sr.read(chs))!=-1){
  12.             sw.write(chs, 0, length);
  13.         }
  14.         System.out.println(sw.toString());
  15.     }
  16. } /* Output:
  17. abc你好
  18. *///:~
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注