I/O系统

1、File类

　　File即能代表一个特定文件的名称，又能代表一个目录下的一组文件的名称。

（1）目录列表器

　　调用不带参数的list()方法，可以获得此File对象包含的全部列表。在list()方法中加上FilenameFilter参数，可以获得此File对象包含的受限列表。

　　FilenameFilter接口主要定义了accept()方法，提供给list()来回调accept()。list()方法会为此目录对象下的每个文件名调用accept()，来判断该文件是否包含在内。accept()会使用一个正则表达式的matcher对象，来查看此正则表达式regex是否匹配这个文件的名字，并返回布尔值表示。

 1 public class Test {
 2     public static void main(String[] args) {
 3         File path = new File(".");
 4         String[] list;
 5         if(args.length == 0)
 6             list = path.list();
 7         else
 8             list = path.list(new FilenameFilter() {
 9                 private Pattern pattern = Pattern.compile(args[0]);
10                 public boolean accept(File dir, String name) {
11                     return pattern.matcher(name).matches();
12                 }
13             });
14         Arrays.sort(list, String.CASE_INSENSITIVE_ORDER);
15         for(String dirItem : list)
16             System.out.println(dirItem);
17     }
18 }

（2）目录实用工具

　　Directory工具类可以通过使用local()方法来产生由本地目录中的文件构成的File对象数组，或者通过使用walk()方法产生给定目录下的由整个目录树中所有文件构成的List<File>。

　　local()方法使用被称为listFile()的File.list()的变体来产生File数组。walk()方法将开始目录的名字转换为File对象，然后调用recurseDirs()，该方法将递归地遍历目录，并在每次递归中都收集更多的信息。

src/net/mindView/utils/Directory.java · sumAll/Java编程思想 - 码云 - 开源中国 (gitee.com)

2、输入和输出

　　“流”代表任何有能力产出数据的数据源对象或者是有能力接受数据的接收端对象。

　　通过继承，任何自InputStream或Reader派生而来的类都含有名为read()的基本方法，用于读取单个字节或者字节数组。任何自OutputStream或Writer派生而来的类都含有名为write()的基本方法，用于写单个字节或者字节数组。

（1）InputStream类型

　　InputStream的作用是用来表示那些从不同数据源产生输入的类。

（2）OutputStream类型

3、添加属性和有用的接口

装饰器模式(Decorator Pattern)，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式比生成子类更灵活。 ----《大话设计模式》

　　FilterInputStream和FilterOutputStream是用来提供装饰器类接口以控制特定输入流（InputStream）和输出流（OutputStream）的两个类。

（1）FilterInputStream类型

（2）FilterOutputStream类型

4、Reader和Writer

　　Reader和Writer提供兼容Unicode与面向字符的I/O功能。设计Reader和Writer继承层次结构主要是为了国际化，为了在所有的I/O操作中都支持Unicode。

5、RandomAccessFile

　　RandomAccessFile不是InputStream或者OutputStream继承层次结构中的一部分。它实现了DataInput和DataOutput接口。它支持搜寻方法，并且只适用于由大小已知的记录组成的文件。第二个参数用来指示我们只是“随机读”（r）还是“既读又写”（rw）。它并不支持写文件。

6、I/O流的典型使用方式

（1）缓冲输入文件

　　BufferedReader可以对文件进行缓冲，提高写入速度。

 1 public class BufferedInputFile {
 2     public static  String
 3     read(String fileName) throws IOException{
 4         BufferedReader in = new BufferedReader(new FileReader(fileName));
 5         String s;
 6         StringBuilder sb = new StringBuilder();
 7         while((s = in.readLine())!=null){
 8             sb.append(s + "\n");
 9         }
10         in.close();
11         return sb.toString();
12     }
13 }

（2）从内存输入

1 public class MemoryInput {
2     public static void main(String[] args) throws IOException {
3         StringReader in = new StringReader(BufferedInputFile.read("MemoryInput.java"));
4         int c;
5         while((c = in.read()) != -1)
6             System.out.println((char) c);
7     }
8 }

（3）格式化的内存输入

　　通过DataInputStream读取格式化数据，它是一个面向字节的I/O类（不是面向字符的）。因此我们必须使用InputStream类而不是Reader类。

 1 public class Test {
 2     public static void main(String[] args) throws IOException {
 3         //创建方式1
 4         DataInputStream in = new DataInputStream(
 5                 new BufferedInputStream(
 6                         new FileInputStream("TestEOF.java"))
 7         );
 8         //创建方式2
 9         DataInputStream in2 = new DataInputStream(
10                 new ByteArrayInputStream(
11     BufferedInputFile.read("TestEOF").getBytes()
12                 )
13         );
14         //输出方式1
15         while(in.available() != 0){
16             System.out.println((char)in.readByte());
17         }
18         //输出方式2
19         try{
20             while (true){
21                 System.out.println((char)in2.readByte());
22             }
23         }catch (EOFException e){
24             System.out.println("End of stream");
25         }
26     }
27 }

（4）基本的文件输出

　　FileWriter对象可以向文件写入数据。

 1 public class FileOutput {
 2     static String file = "FileOutput.out";
 3     public static void main(String[] args) throws IOException {
 4        BufferedReader in = new BufferedReader(
 5                new StringReader(
 6         BufferedInputFile.read("FileOutput.java"))
 7        );
 8        PrintWriter out = new PrintWriter(file);
 9        int lineCount = 1;
10        String s;
11        while((s = in.readLine()) != null){
12            out.println(lineCount++ + "：" + s);
13        }
14        out.close();
15         System.out.println(BufferedInputFile.read(file));
16     }
17 }

（5）存储和恢复数据

　　当我们使用DataOutputStream时，写字符串并且让DataInputStream能够恢复它的唯一可靠的做法就是使用UTF-8编码，在这个示例中是用writeUTF()和readUTF()来实现的。UTF-8是一种多字节格式，其编码长度根据实际使用的字符集会有所变化。字符串长度存储在UTF-8字符串的前两个字节中。

 1 public class Test {
 2     public static void main(String[] args) throws IOException {
 3        DataOutputStream out = new DataOutputStream(
 4                new BufferedOutputStream(
 5                        new FileOutputStream("Data.txt"))
 6        );
 7        out.writeDouble(3.14159);
 8        out.writeUTF("That was pi");
 9        out.writeDouble(1.52363);
10        out.close();
11        DataInputStream in = new DataInputStream(
12                new BufferedInputStream(
13                        new FileInputStream("Data.txt"))
14        );
15         System.out.println(in.readDouble());
16         System.out.println(in.readUTF());
17         System.out.println(in.readDouble());
18     }
19 }

（6）读写随机访问文件

　　在使用RandomAccessFile时，你必须知道文件排版，这样才能正确地操作它。seek()方法通过字节查找位置，例如有6个double数据，需要定位到第5个double数据的位置，可以使用seek(5*8)，8是double的字节长。

 1 public class UsingRandomAccessFile {
 2     static String file = "rtest.dat";
 3     static void display() throws IOException{
 4         RandomAccessFile rf = new RandomAccessFile(file,"r");
 5         for(int i=0;i<7;i++){
 6             System.out.println("Value " + i + ":" + rf.readDouble());
 7         }
 8         System.out.println(rf.readUTF());
 9         rf.close();
10     }
11     public static void main(String[] args) throws IOException {
12        RandomAccessFile rf = new RandomAccessFile(file,"rw");
13        for(int i=0;i<7;i++){
14            rf.writeDouble(i*1.326);
15        }
16        rf.writeUTF("The end of the file");
17        rf.close();
18        display();
19        rf = new RandomAccessFile(file,"rw");
20        rf.seek(5*8);
21        rf.writeDouble(62.001);
22        rf.close();
23        display();
24     }
25 }

7、标准I/O

　　标准I/O的意义在于：我们可以很容易地把程序串联起来，一个程序的标准输出可以成为另一程序的标准输入。

（1）从标准输入中读取

　　按照标准I/O模型，Java提供了System.in、System.out和System.err。

1 public class Test {
2     public static void main(String[] args) throws IOException {
3         BufferedReader stdin = new BufferedReader(
4                 new InputStreamReader(System.in));
5         String s;
6         while((s = stdin.readLine()) != null && s.length() != 0)
7             System.out.println(s.toUpperCase());
8     }
9 }

（2）将System.out转换成PrintWriter

　　System.out是一个PrintStream，而PrintStream是一个OutputStream。PrintWriter有一个可以接受OutputStream作为参数的构造器。因此，只要需要，就可以使用那个构造器把System.out转换成PrintWriter。

1 public class Test {
2     public static void main(String[] args) throws IOException {
3        PrintWriter out = new PrintWriter(System.out,true);
4        out.println("Hello,world");
5     }
6 }

（3）标准I/O重定向

　　Java的System类提供了一些简单的静态方法调用，以允许我们对标准输入、输出和错误I/O流进行重定向：

　　　　①setIn(InputStream)

　　　　②setOut(PrintStream)

　　　　③setErr(PrintStream)

 1 public class Redirecting {
 2     public static void main(String[] args) throws IOException {
 3         PrintStream console = System.out;
 4         BufferedInputStream in = new BufferedInputStream(
 5                 new FileInputStream("Redirecting.java")
 6         );
 7         PrintStream out= new PrintStream(
 8                 new BufferedOutputStream(
 9                         new FileOutputStream("test.out"))
10         );
11         System.setIn(in);
12         System.setOut(out);
13         System.setErr(out);
14         BufferedReader br = new BufferedReader(
15                 new InputStreamReader(System.in)
16         );
17         String s;
18         while((s = br.readLine()) != null){
19             System.out.println(s);
20         }
21         out.close();
22         System.setOut(console);
23     }
24 }

8、新I/O

　　JDK 1.4的java.nio.*包中引入了新的javaI/O类库，其目的在于提高速度。速度的提高来自于所使用的结构更接近于操作系统执行I/O的方式：通道和缓冲器。唯一直接与通道交互的缓冲器是ByteBuffer，也就是说可以存储未加工字节的缓冲器。

 1 public class ChannelCopy {
 2     private static final int BSIZE = 1024;
 3     public static void main(String[] args) throws IOException {
 4        if(args.length !=2)
 5            System.exit(1);
 6         FileChannel
 7                 in = new FileInputStream(args[0]).getChannel(),
 8                 out = new FileOutputStream(args[1]).getChannel();
 9         ByteBuffer buffer = ByteBuffer.allocate(BSIZE);//表示只读访问
10         //方式1
11         while (in.read(buffer) != -1){
12             buffer.flip();//为写做准备
13             out.write(buffer);
14             buffer.clear();//为读做准备
15         }
16         //方式2
17         in.transferTo(0,in.size(),out);
18         //or
19         //out.transferFrom(in,0,in.size());
20     }
21 }

（1）转换数据

　　使用原始的方式是每次只读取一个字节的数据，然后将每个byte类型强制转换成char类型。由于ByteBuffer可以看作是具有asCharBuffer()方法的CharBuffer，因此可以直接转换成CharBuffer再输入输出。

 1 public class BufferToText {
 2     private static final int BSIZE = 1024;
 3     public static void main(String[] args) throws IOException {
 4         FileChannel fc = 
 5                 new FileOutputStream("data2.txt").getChannel();
 6         fc.write(ByteBuffer.wrap("Some text".getBytes()));
 7         fc.close();
 8         fc = new FileInputStream("data2.txt").getChannel();
 9         ByteBuffer buff = ByteBuffer.allocate(BSIZE);
10         fc.read(buff);buff.flip();
11         buff.rewind();
12         //方式1
13         String encoding = System.getProperty("file.encoding");//产生代表默认字符集名称的字符串
14         System.out.println(Charset.forName(encoding).decode(buff));//用于产生Charset对象，对字符串进行解码
15         
16         //方式2
17         fc = new FileOutputStream("data2.txt").getChannel();
18         fc.write(ByteBuffer.wrap("Some text".getBytes("UTF-16BE")));
19         fc.close();
20         fc = new FileInputStream("data2.txt").getChannel();
21         buff.clear();fc.read(buff);buff.flip();
22         System.out.println(buff.asCharBuffer());
23         
24         //方式3
25         fc = new FileOutputStream("data2.txt").getChannel();
26         buff = ByteBuffer.allocate(24);//分配了24个字节，9个字符只需18个字节，分配的比需要的多
27         buff.asCharBuffer().put("Some text");
28         fc.write(buff);
29         fc.close();
30         fc = new FileInputStream("data2.txt").getChannel();
31         buff.clear();fc.read(buff);buff.flip();
32         System.out.println(buff.asCharBuffer());
33     }
34 }

（2）获取基本类型

 1 public class Test {
 2     private static final int BSIZE = 1024;
 3     public static void main(String[] args) throws IOException {
 4         ByteBuffer bb = ByteBuffer.allocate(BSIZE);
 5         
 6         bb.rewind();
 7         bb.asCharBuffer().put("Howdy");
 8         char c = bb.getChar();
 9         
10         bb.rewind();
11         bb.asShortBuffer().put((short)693);
12         short b = bb.getShort();
13         
14         bb.rewind();
15         bb.asIntBuffer().put(6);
16         int j = bb.getInt();
17     }
18 }

（3）视图缓冲器

　　视图缓冲器可以让我们通过某个特定的基本数据类型的视窗查看其底层的ByteBuffer。ByteBuffer依然是实际存储数据的地方，但对视图的任何修改都会映射成为对ByteBuffer中数据的修改。

　　可以在一个ByteBuffer上建立不同的视图缓冲器。

1 ByteBuffer bb = ByteBuffer.wrap(new byte[]{0,0,0,0,0,0,0,'a'});
2 CharBuffer cb = ((ByteBuffer)bb.rewind()).asCharBuffer();
3 ShortBuffer sb = ((ByteBuffer)bb.rewind()).asShortBuffer();
4 IntBuffer ib = ((ByteBuffer)bb.rewind()).asIntBuffer();
5 LongBuffer lb = ((ByteBuffer)bb.rewind()).asLongBuffer();
6 FloatBuffer fb = ((ByteBuffer)bb.rewind()).asFloatBuffer();
7 DoubleBuffer db = ((ByteBuffer)bb.rewind()).asDoubleBuffer();

　　字节存放次序有两种方式：“big endian”（高位优先，将最重要的字节存放在地址最低的存储器单元）和“little endian”（低位优先，将最重要的字节放在地址最高的存储器单元）。ByteBuffer默认是以高位优先的形式存储数据的，但可以通过带有参数ByteOrder.BIG_ENDIAN或ByteOrder.LITTLE_ENDIAN的order()方法改变ByteBuffer的字节排序方式。

　　例如：0000,0000,0110,0001

　　　　高位优先形式得到97（0000,0000,0110,0001）

　　　　低位优先形式得到24832（0110,0001,0000,0000）

（4）用缓冲器操纵数据

　　把一个字节数组写到文件中去，那么就应该使用ByteBuffer.wrap()方法把字节数组包装起来，然后用getChannel()方法在FileOutputStream上打开一个通道，接着将来自于ByteBuffer的数据写到FileChannel中。

　　ByteBuffer是将数据移进移出通道的唯一方式。不能把基本类型的缓冲器转换成ByteBuffer。

（5）缓冲器的细节

（6）内存映射文件

　　内存映射文件允许我们创建和修改那些因为太大而不能放入内存的文件。

 1 public class LargeMappedFiles {
 2     private static final int BSIZE = 1024;
 3     public static void main(String[] args) throws IOException {
 4         int length = 0x8FFFFFF;//128M
 5         MappedByteBuffer out =
 6                 new RandomAccessFile("test.dat","rw").getChannel().
 7                         map(FileChannel.MapMode.READ_WRITE,0,length);
 8         for(int i=0;i<length;i++)
 9             out.put((byte) 'x');
10         System.out.println("Finished writing");
11         for(int i=length/2;i<length/2+6;i++)
12             System.out.print((char)out.get(i));
13     }
14 }

（7）文件加锁

　　文件加锁机制允许我们同步访问某个作为共享资源的文件。文件锁对其他操作系统进程是可见的，因为java的文件加锁直接映射到了本地操作系统的加锁工具。

 1 public class Test {
 2     private static final int BSIZE = 1024;
 3     public static void main(String[] args) throws IOException, InterruptedException {
 4         FileOutputStream fos = new FileOutputStream("file.txt");
 5         FileLock fl = fos.getChannel().tryLock();//只能在通道上获得锁
 6         if(fl != null){
 7             System.out.println("Locked File");
 8             TimeUnit.MILLISECONDS.sleep(100);
 9             fl.release();
10             System.out.println("Released Lock");
11         }
12         fos.close();
13     }
14 }

　　可以使用如下方法对文件的一部分上锁：

　　　　　    tryLock(long position, long size, boolean shared)

　　　　或者

　　　　　　lock(long position, long size, boolean shared)

　　　　其中，加锁的区域由size-position决定，第三个参数指定是否是共享锁。

9、压缩

　　Java I/O类库中的类支持读写压缩格式的数据流。压缩类库是按字节方式处理的。

（1）用GZIP进行简单压缩

 1 class GZIPcompress{
 2     public static void main(String[] args) throws IOException {
 3         BufferedReader in= new BufferedReader(new FileReader(args[0]));
 4         BufferedOutputStream out = new BufferedOutputStream(
 5                 new GZIPOutputStream(
 6                         new FileOutputStream("test.gz"))
 7         );
 8         System.out.println("Writing file");
 9         int c;
10         while((c=in.read()) != -1){
11             out.write(c);
12         }
13         System.out.println("Reading file");
14         BufferedReader in2 = new BufferedReader(
15                 new InputStreamReader(
16                         new GZIPInputStream(
17                                 new FileInputStream("test.gz")))
18         );
19         String s;
20         while((s=in2.readLine()) != null){
21             System.out.println(s);
22         }
23     }
24 }

（2）用Zip进行多文件保存

　　通过Checksum类来计算和校验文件的校验和的方法，有两种类型：Adler32（它快一些）和CRC32（慢一些，但更准确）。

 1 class Zipcompress{
 2     public static void main(String[] args) throws IOException {
 3         //保存
 4         FileOutputStream f = new FileOutputStream("test.zip");
 5         CheckedOutputStream csum = new CheckedOutputStream(f,new Adler32());
 6         ZipOutputStream zos = new ZipOutputStream(csum);
 7         BufferedOutputStream out =
 8                 new BufferedOutputStream(zos);
 9         for (String arg : args){
10             BufferedReader in =
11                     new BufferedReader(new FileReader(arg));
12             zos.putNextEntry(new ZipEntry(arg));//开始编写新的 ZIP 文件条目，并将流定位到条目数据的开头
13             int c;
14             while((c = in.read()) != -1){
15                 out.write(c);
16             }
17             in.close();
18             out.flush();//将缓冲区中的数据强制写出
19         }
20         out.close();
21         
22         //读取
23         FileInputStream fi = new FileInputStream("test.zip");
24         CheckedInputStream csumi = new CheckedInputStream(fi,new Adler32());
25         ZipInputStream in2 = new ZipInputStream(csumi);
26         BufferedInputStream bis = new BufferedInputStream(in2);
27         ZipEntry ze;
28         while((ze = in2.getNextEntry()) != null){
29             int x;
30             while ((x=bis.read()) != -1)
31                 System.out.write(x);
32         }
33     }
34 }

10、对象序列化

　　Java的对象序列化将那些实现了Serializable接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象。利用它可以实现轻量级持久性（持久性意味着一个对象的生存周期并不取决于程序是否正在执行；它可以生存于程序的调用之间）。

1 Thing1 t1 = new Thing1(1);//实现了Serializable接口
2 ObjectOutputStream out = new ObjectOutputStream(
3                 new FileOutputStream("thing1.out"));
4 out.writeObject(t1);
5         out.close();
6 ObjectInputStream in = new ObjectInputStream(
7                 new FileInputStream("thing1.out"));
8  Thing1 t2 = (Thing1)in.readObject();

（1）序列化的控制

　　如果不希望对象的某一部分被序列化，或者一个对象被还原以后，某子对象需要重新创建，从而不必将该对象序列化。在这种特殊情况下，可通过实现　　　　Externalizable接口—代替实现Serializable接口—来对序列化过程进行控制。

　　Externalizable接口添加了两个方法：writeExternal()和readExternal()，会在序列化和反序列化还原的过程中被自动调用。

　　在反序列化还原的过程中，所有普通的默认构造器都会被调用，因此构造器必须是public。

（2）transient（瞬时）关键字

　　对于实现了Serializable接口的对象，可以用transient（瞬时）关键字逐个字段地关闭序列化，它的意思是“不用麻烦你保存或恢复数据—我自己会处理的”。

1 private transient String password;

（3）Externalizable的替代方法

　　可以在实现Serializable接口的类中添加名为writeObject()和readObject()的方法。此时会自动调用这两个方法，而不是默认的序列化机制。

　　在下面的例子中，非transient字段由defaultWriteObject()方法保存，而transient字段必须在程序中明确保存和恢复。

 1 class SerialCtl implements Serializable{
 2     private String a;
 3     private transient String b;
 4     public SerialCtl(String aa,String bb){
 5         a = "Not transient：" + aa;
 6         b = "Transient：" + bb;
 7     }
 8 ​
 9     @Override
10     public String toString() {
11         return a + "\n" + b;
12     }
13 ​
14     private void writeObject(ObjectOutputStream stream) throws IOException{
15         stream.defaultWriteObject();
16         stream.writeObject(b);
17     }
18     private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
19         stream.defaultReadObject();
20         b = (String) stream.readObject();
21     }
22 ​
23     public static void main(String[] args) throws IOException, ClassNotFoundException {
24         SerialCtl sc = new SerialCtl("Test1","Test2");
25         System.out.println("Before：\n" + sc);
26         ByteArrayOutputStream buf = new ByteArrayOutputStream();
27         ObjectOutputStream o = new ObjectOutputStream(buf);
28         o.writeObject(sc);
29         ObjectInputStream in = new ObjectInputStream(
30                 new ByteArrayInputStream(buf.toByteArray())
31         );
32         SerialCtl sc2 = (SerialCtl) in.readObject();
33         System.out.println("After：\n" + sc2);
34     }
35 }
36 ​
37 /*Output：
38 Before：
39 Not transient：Test1
40 Transient：Test2
41 After：
42 Not transient：Test1
43 Transient：Test2
44 */

 参考于《Java编程思想》，第525~589页