IO IO是指Input/Output，即输入和输出。以内存为中心：
Input指从外部读入数据到内存，例如，把文件从磁盘读取到内存，从网络读取数据到内存等等。
Output指把数据从内存输出到外部，例如，把数据从内存写入到文件，把数据从内存输出到网络等等。
为什么要把数据读到内存才能处理这些数据？因为代码是在内存中运行的，数据也必须读到内存，最终的表示方式无非是byte数组，字符串等，都必须存放在内存里。
IO流以byte（字节）为最小单位，因此也称为字节流。例如，我们要从磁盘读入一个文件，包含6个字节，就相当于读入了6个字节的数据：1 2 3 4 5 6 7 8 9 10 11 12 13 ╔════════════╗ ║ Memory ║ ╚════════════╝ ▲ │0x48 │0x65 │0x6c │0x6c │0x6f │0x21 ╔═══════════╗ ║ Hard Disk ║ ╚═══════════╝
1 2 3 4 5 6 7 8 9 10 11 12 13 ╔════════════╗ ║ Memory ║ ╚════════════╝ │0x21 │0x6f │0x6c │0x6c │0x65 │0x48 ▼ ╔═══════════╗ ║ Hard Disk ║ ╚═══════════╝
Reader / Writer 如果我们需要读写的是字符，并且字符不全是单字节表示的ASCII字符，那么，按照char来读写显然更方便，这种流称为字符流。Hi你好这4个字符用Writer字符流写入文件，并且使用UTF-8编码，得到的最终文件内容是8个字节，英文字符H和i各占一个字节，中文字符你好各占3个字节：1 2 3 4 0x48 0x69 0xe4bda0 0xe5a5bd
byte[]数组，但是我们可以自己把二进制byte[]数组按照某种编码转换为字符串。究竟使用Reader还是InputStream，要取决于具体的使用场景。如果数据源不是文本，就只能使用InputStream，如果数据源是文本，使用Reader更方便一些。Writer和OutputStream是类似的。
同步和异步 同步IO是指，读写IO时代码必须等待数据返回后才继续执行后续代码，它的优点是代码编写简单，缺点是CPU执行效率低。
小结
IO流是一种流式的数据输入/输出模型：
二进制数据以byte为最小单位在InputStream/OutputStream中单向流动；
字符数据以char为最小单位在Reader/Writer中单向流动。
Java标准库的java.io包提供了同步IO功能：
字节流接口：InputStream/OutputStream；
字符流接口：Reader/Writer。
File对象 在计算机系统中，文件是非常重要的存储方式。Java的标准库java.io提供了File对象来操作文件和目录。1 2 3 4 5 6 7 import java.io.*;public class Main { public static void main (String[] args) { File f = new File ("C:\\Windows\\notepad.exe" ); System.out.println(f); } }
1 File f = new File ("C:\\Windows\\notepad.exe" );
1 File f = new File ("/usr/bin/javac" );
1 2 3 4 File f1 = new File ("sub\\javac" ); File f3 = new File (".\\sub\\javac" ); File f3 = new File ("..\\sub\\javac" );
.表示当前目录，..表示上级目录。1 2 3 4 5 6 7 8 9 import java.io.*;public class Main { public static void main (String[] args) throws IOException { File f = new File (".." ); System.out.println(f.getPath()); System.out.println(f.getAbsolutePath()); System.out.println(f.getCanonicalPath()); } }
C:\Windows\System32\..\notepad.exe，而规范路径就是把.和..转换成标准的绝对路径后的路径：C:\Windows\notepad.exe。1 System.out.println(File.separator);
文件和目录 File对象既可以表示文件，也可以表示目录。特别要注意的是，构造一个File对象，即使传入的文件或目录不存在，代码也不会出错，因为构造一个File对象，并不会导致任何磁盘操作。只有当我们调用File对象的某些方法的时候，才真正进行磁盘操作。
例如，调用isFile()，判断该File对象是否是一个已存在的文件，调用isDirectory()，判断该File对象是否是一个已存在的目录：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 import java.io.*;public class Main { public static void main (String[] args) throws IOException { File f1 = new File ("C:\\Windows" ); File f2 = new File ("C:\\Windows\\notepad.exe" ); File f3 = new File ("C:\\Windows\\nothing" ); System.out.println(f1.isFile()); System.out.println(f1.isDirectory()); System.out.println(f2.isFile()); System.out.println(f2.isDirectory()); System.out.println(f3.isFile()); System.out.println(f3.isDirectory()); } }
boolean canRead()：是否可读；
boolean canWrite()：是否可写；
boolean canExecute()：是否可执行；
long length()：文件字节大小。
对目录而言，是否可执行表示能否列出它包含的文件和子目录。
创建和删除文件 当File对象表示一个文件时，可以通过createNewFile()创建一个新文件，用delete()删除该文件：1 2 3 4 5 6 7 8 File file = new File ("/path/to/file" );if (file.createNewFile()) { if (file.delete()) { } }
createTempFile()来创建一个临时文件，以及deleteOnExit()在JVM退出时自动删除该文件。1 2 3 4 5 6 7 8 9 10 import java.io.*;public class Main { public static void main (String[] args) throws IOException { File f = File.createTempFile("tmp-" , ".txt" ); f.deleteOnExit(); System.out.println(f.isFile()); System.out.println(f.getAbsolutePath()); } }
遍历文件和目录 当File对象表示一个目录时，可以使用list()和listFiles()列出目录下的文件和子目录名。listFiles()提供了一系列重载方法，可以过滤不想要的文件和目录：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 import java.io.*;public class Main { public static void main (String[] args) throws IOException { File f = new File ("C:\\Windows" ); File[] fs1 = f.listFiles(); printFiles(fs1); File[] fs2 = f.listFiles(new FilenameFilter () { public boolean accept (File dir, String name) { return name.endsWith(".exe" ); } }); printFiles(fs2); } static void printFiles (File[] files) { System.out.println("==========" ); if (files != null ) { for (File f : files) { System.out.println(f); } } System.out.println("==========" ); } }
list() : 获取该目录下的所有文件listFiles(): 获取该目录下所有文件的绝对路径
和文件操作类似，File对象如果表示一个目录，可以通过以下方法创建和删除目录：
boolean mkdir()：创建当前File对象表示的目录；
boolean mkdirs()：创建当前File对象表示的目录，并在必要时将不存在的父目录也创建出来；
boolean delete()：删除当前File对象表示的目录，当前目录必须为空才能删除成功。
Path Java标准库还提供了一个Path对象，它位于java.nio.file包。Path对象和File对象类似，但操作更加简单：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 import java.io.*;import java.nio.file.*;public class Main { public static void main (String[] args) throws IOException { Path p1 = Paths.get("." , "project" , "study" ); System.out.println(p1); Path p2 = p1.toAbsolutePath(); System.out.println(p2); Path p3 = p2.normalize(); System.out.println(p3); File f = p3.toFile(); System.out.println(f); for (Path p : Paths.get(".." ).toAbsolutePath()) { System.out.println(" " + p); } } }
小结 Java标准库的java.io.File对象表示一个文件或者目录：
创建File对象本身不涉及IO操作；
可以获取路径／绝对路径／规范路径：getPath()/getAbsolutePath()/getCanonicalPath()；
可以获取目录的文件和子目录：list()/listFiles()；
可以创建或删除文件和目录。
InputStream就是Java标准库提供的最基本的输入流。它位于java.io这个包里。java.io包提供了所有同步IO的功能。1 public abstract int read () throws IOException;
1 2 3 4 5 6 7 8 9 10 11 12 public void readFile () throws IOException { InputStream input = new FileInputStream ("src/readme.txt" ); for (;;) { int n = input.read(); if (n == -1 ) { break ; } System.out.println(n); } input.close(); }
1 2 3 4 5 6 7 8 9 10 11 12 public void readFile () throws IOException { InputStream input = null ; try { input = new FileInputStream ("src/readme.txt" ); int n; while ((n = input.read()) != -1 ) { System.out.println(n); } } finally { if (input != null ) { input.close(); } } }
try(resource)的语法，只需要编写try语句，让编译器自动为我们关闭资源。推荐的写法如下：1 2 3 4 5 6 7 8 public void readFile () throws IOException { try (InputStream input = new FileInputStream ("src/readme.txt" )) { int n; while ((n = input.read()) != -1 ) { System.out.println(n); } } }
try(resource = ...)中的对象是否实现了java.lang.AutoCloseable接口，如果实现了，就自动加上finally语句并调用close()方法。InputStream和OutputStream都实现了这个接口，因此，都可以用在try(resource)中。
缓冲 在读取流的时候，一次读取一个字节并不是最高效的方法。很多流支持一次性读取多个字节到缓冲区，对于文件和网络流来说，利用缓冲区一次性读取多个字节效率往往要高很多。InputStream提供了两个重载方法来支持读取多个字节：
int read(byte[] b)：读取若干字节并填充到byte[]数组，返回读取的字节数int read(byte[] b, int off, int len)：指定byte[]数组的偏移量和最大填充数
off：在数组b在其中写入数据的起始位置的偏移；off+len <= b的大小input.read()，因此在循环中，如果在下标小于偏移量的数组，是不读取的。
利用上述方法一次读取多个字节时，需要先定义一个byte[]数组作为缓冲区，read()方法会尽可能多地读取字节到缓冲区， 但不会超过缓冲区的大小。read()方法的返回值不再是字节的int值，而是返回实际读取了多少个字节。如果返回-1，表示没有更多的数据了。1 2 3 4 5 6 7 8 9 10 public void readFile () throws IOException { try (InputStream input = new FileInputStream ("src/readme.txt" )) { byte [] buffer = new byte [1000 ]; int n; while ((n = input.read(buffer)) != -1 ) { System.out.println("read " + n + " bytes." ); } } }
阻塞 在调用InputStream的read()方法读取数据时，我们说read()方法是阻塞（Blocking）的。它的意思是，对于下面的代码：1 2 3 int n;n = input.read(); int m = n;
用FileInputStream可以从文件获取输入流，这是InputStream常用的一个实现类。此外，ByteArrayInputStream可以在内存中模拟一个InputStream：1 2 3 4 5 6 7 8 9 10 11 12 13 import java.io.*;public class Main { public static void main (String[] args) throws IOException { byte [] data = { 72 , 101 , 108 , 108 , 111 , 33 }; try (InputStream input = new ByteArrayInputStream (data)) { int n; while ((n = input.read()) != -1 ) { System.out.println((char )n); } } } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Main { public static void main (String[] args) throws IOException { String s; try (InputStream input = new FileInputStream ("C:\\test\\README.txt" )) { int n; StringBuilder sb = new StringBuilder (); while ((n = input.read()) != -1 ) { sb.append((char ) n); } s = sb.toString(); } System.out.println(s); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class Main { public static void main (String[] args) throws IOException { String s; try (InputStream input = new FileInputStream ("C:\\test\\README.txt" )) { s = readAsString(input); } System.out.println(s); } public static String readAsString (InputStream input) throws IOException { int n; StringBuilder sb = new StringBuilder (); while ((n = input.read()) != -1 ) { sb.append((char ) n); } return sb.toString(); } }
String readAsString(InputStream input)方法进行测试就相当简单，因为不一定要传入一个真的FileInputStream：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 import java.io.*;public class Main { public static void main (String[] args) throws IOException { byte [] data = { 72 , 101 , 108 , 108 , 111 , 33 }; try (InputStream input = new ByteArrayInputStream (data)) { String s = readAsString(input); System.out.println(s); } } public static String readAsString (InputStream input) throws IOException { int n; StringBuilder sb = new StringBuilder (); while ((n = input.read()) != -1 ) { sb.append((char ) n); } return sb.toString(); } }
接受InputStream抽象类型，而不是具体的FileInputStream类型，从而使得代码可以处理InputStream的任意实现类。
小结
Java标准库的java.io.InputStream定义了所有输入流的超类：
FileInputStream实现了文件流输入；
ByteArrayInputStream在内存中模拟一个字节流输入。
总是使用try(resource)来保证InputStream正确关闭。
OutputStream 和InputStream相反，OutputStream是Java标准库提供的最基本的输出流。void write(int b)，签名如下：1 public abstract void write (int b) throws IOException;
b & 0xff）。close()方法关闭输出流，以便释放系统资源。要特别注意：OutputStream还提供了一个flush()方法，它的目的是将缓冲区的内容真正输出到目的地。
FileOutputStream 我们以FileOutputStream为例，演示如何将若干个字节写入文件流：1 2 3 4 5 6 7 8 9 public void writeFile () throws IOException { OutputStream output = new FileOutputStream ("out/readme.txt" ); output.write(72 ); output.write(101 ); output.write(108 ); output.write(108 ); output.write(111 ); output.close(); }
void write(byte[])来实现：1 2 3 4 5 public void writeFile () throws IOException { OutputStream output = new FileOutputStream ("out/readme.txt" ); output.write("Hello" .getBytes("UTF-8" )); output.close(); }
try(resource)来保证OutputStream在无论是否发生IO错误的时候都能够正确地关闭：1 2 3 4 5 public void writeFile () throws IOException { try (OutputStream output = new FileOutputStream ("out/readme.txt" )) { output.write("Hello" .getBytes("UTF-8" )); } }
阻塞 和InputStream一样，OutputStream的write()方法也是阻塞的。
OutputStream实现类 用FileOutputStream可以从文件获取输出流，这是OutputStream常用的一个实现类。此外，ByteArrayOutputStream可以在内存中模拟一个OutputStream：1 2 3 4 5 6 7 8 9 10 11 12 13 import java.io.*;public class Main { public static void main (String[] args) throws IOException { byte [] data; try (ByteArrayOutputStream output = new ByteArrayOutputStream ()) { output.write("Hello " .getBytes("UTF-8" )); output.write("world!" .getBytes("UTF-8" )); data = output.toByteArray(); } System.out.println(new String (data, "UTF-8" )); } }
byte[]数组在内存中变成一个OutputStream，虽然实际应用不多，但测试的时候，可以用它来构造一个OutputStream。try(resource) { ... }语句中可以同时写出多个资源，用;隔开。例如，同时读写两个文件：1 2 3 4 5 6 try (InputStream input = new FileInputStream ("input.txt" ); OutputStream output = new FileOutputStream ("output.txt" )) { input.transferTo(output); }
小结
Java标准库的java.io.OutputStream定义了所有输出流的超类：
FileOutputStream实现了文件流输出；
ByteArrayOutputStream在内存中模拟一个字节流输出。
某些情况下需要手动调用OutputStream的flush()方法来强制输出缓冲区。
总是使用try(resource)来保证OutputStream正确关闭。
Filter模式 Java的IO标准库提供的InputStream根据来源可以包括：
FileInputStream：从文件读取数据，是最终数据源；
ServletInputStream：从HTTP请求读取数据，是最终数据源；
Socket.getInputStream()：从TCP连接读取数据，是最终数据源；
…
如果我们要给FileInputStream添加缓冲功能，则可以从FileInputStream派生一个类：1 BufferedFileInputStream extends FileInputStream
1 DigestFileInputStream extends FileInputStream
1 CipherFileInputStream extends FileInputStream
1 2 3 4 5 6 7 8 9 10 11 12 13 ┌─────────────────┐ │ FileInputStream │ └─────────────────┘ ▲ ┌───────────┬─────────┼─────────┬───────────┐ │ │ │ │ │ ┌───────────────────────┐│┌─────────────────┐│┌─────────────────────┐ │BufferedFileInputStream│││DigestInputStream│││CipherFileInputStream│ └───────────────────────┘│└─────────────────┘│└─────────────────────┘ │ │ ┌─────────────────────────────┐ ┌─────────────────────────────┐ │BufferedDigestFileInputStream│ │BufferedCipherFileInputStream│ └─────────────────────────────┘ └─────────────────────────────┘
一类是直接提供数据的基础InputStream，例如：
FileInputStream
ByteArrayInputStream
ServletInputStream
…
一类是提供额外附加功能的InputStream，例如：
BufferedInputStream
DigestInputStream
CipherInputStream
…
当我们需要给一个“基础”InputStream附加各种功能时，我们先确定这个能提供数据源的InputStream，因为我们需要的数据总得来自某个地方，例如，FileInputStream，数据来源自文件：1 InputStream file = new FileInputStream ("test.gz" );
1 InputStream buffered = new BufferedInputStream (file);
1 2 3 4 5 6 7 8 9 ┌─────────────────────────┐ │GZIPInputStream │ │┌───────────────────────┐│ ││BufferedFileInputStream││ ││┌─────────────────────┐││ │││ FileInputStream │││ ││└─────────────────────┘││ │└───────────────────────┘│ └─────────────────────────┘
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ┌─────────────┐ │ InputStream │ └─────────────┘ ▲ ▲ ┌────────────────────┐ │ │ ┌─────────────────┐ │ FileInputStream │─┤ └─│FilterInputStream│ └────────────────────┘ │ └─────────────────┘ ┌────────────────────┐ │ ▲ ┌───────────────────┐ │ByteArrayInputStream│─┤ ├─│BufferedInputStream│ └────────────────────┘ │ │ └───────────────────┘ ┌────────────────────┐ │ │ ┌───────────────────┐ │ ServletInputStream │─┘ ├─│ DataInputStream │ └────────────────────┘ │ └───────────────────┘ │ ┌───────────────────┐ └─│CheckedInputStream │ └───────────────────┘
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ┌─────────────┐ │OutputStream │ └─────────────┘ ▲ ▲ ┌─────────────────────┐ │ │ ┌──────────────────┐ │ FileOutputStream │─┤ └─│FilterOutputStream│ └─────────────────────┘ │ └──────────────────┘ ┌─────────────────────┐ │ ▲ ┌────────────────────┐ │ByteArrayOutputStream│─┤ ├─│BufferedOutputStream│ └─────────────────────┘ │ │ └────────────────────┘ ┌─────────────────────┐ │ │ ┌────────────────────┐ │ ServletOutputStream │─┘ ├─│ DataOutputStream │ └─────────────────────┘ │ └────────────────────┘ │ ┌────────────────────┐ └─│CheckedOutputStream │ └────────────────────┘
我们也可以自己编写FilterInputStream，以便可以把自己的FilterInputStream“叠加”到任何一个InputStream中。1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 import java.io.*;public class Main { public static void main (String[] args) throws IOException { byte [] data = "hello, world!" .getBytes("UTF-8" ); try (CountInputStream input = new CountInputStream (new ByteArrayInputStream (data))) { int n; while ((n = input.read()) != -1 ) { System.out.println((char )n); } System.out.println("Total read " + input.getBytesRead() + " bytes" ); } } } class CountInputStream extends FilterInputStream { private int count = 0 ; CountInputStream(InputStream in) { super (in); } public int getBytesRead () { return this .count; } public int read () throws IOException { int n = in.read(); if (n != -1 ) { this .count ++; } return n; } public int read (byte [] b, int off, int len) throws IOException { int n = in.read(b, off, len); if (n != -1 ) { this .count += n; } return n; } }
小结
Java的IO标准库使用Filter模式为InputStream和OutputStream增加功能：
可以把一个InputStream和任意个FilterInputStream组合；
可以把一个OutputStream和任意个FilterOutputStream组合。
Filter模式可以在运行期动态增加功能（又称Decorator模式）。
操作Zip ZipInputStream是一种FilterInputStream，它可以直接读取zip包的内容：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 ┌───────────────────┐ │ InputStream │ └───────────────────┘ ▲ │ ┌───────────────────┐ │ FilterInputStream │ └───────────────────┘ ▲ │ ┌───────────────────┐ │InflaterInputStream│ └───────────────────┘ ▲ │ ┌───────────────────┐ │ ZipInputStream │ └───────────────────┘ ▲ │ ┌───────────────────┐ │ JarInputStream │ └───────────────────┘
读取zip包 我们来看看ZipInputStream的基本用法。1 2 3 4 5 6 7 8 9 10 11 try (ZipInputStream zip = new ZipInputStream (new FileInputStream (...))) { ZipEntry entry = null ; while ((entry = zip.getNextEntry()) != null ) { String name = entry.getName(); if (!entry.isDirectory()) { int n; while ((n = zip.read()) != -1 ) { ... } } }
写入zip包 ZipOutputStream是一种FilterOutputStream，它可以直接写入内容到zip包。我们要先创建一个ZipOutputStream，通常是包装一个FileOutputStream，然后，每写入一个文件前，先调用putNextEntry()，然后用write()写入byte[]数据，写入完毕后调用closeEntry()结束这个文件的打包：1 2 3 4 5 6 7 8 try (ZipOutputStream zip = new ZipOutputStream (new FileOutputStream (...))) { File[] files = ... for (File file : files) { zip.putNextEntry(new ZipEntry (file.getName())); zip.write(getFileDataAsBytes(file)); zip.closeEntry(); } }
小结
ZipInputStream可以读取zip格式的流，ZipOutputStream可以把多份数据写入zip包；
配合FileInputStream和FileOutputStream就可以读写zip文件。
读取classpath资源 很多Java程序启动的时候，都需要读取配置文件。例如，从一个.properties文件中读取配置：1 2 3 4 String conf = "C:\\conf\\default.properties" ;try (InputStream input = new FileInputStream (conf)) { }
配置文件，例如.properties；
图片文件，例如.jpg；
文本文件，例如.txt，.csv；
……
从classpath读取文件就可以避免不同环境下文件路径不一致的问题：如果我们把default.properties文件放到classpath中，就不用关心它的实际存放路径。1 2 3 try (InputStream input = getClass().getResourceAsStream("/default.properties" )) { }
1 2 3 4 5 try (InputStream input = getClass().getResourceAsStream("/default.properties" )) { if (input != null ) { } }
1 2 3 Properties props = new Properties ();props.load(inputStreamFromClassPath("/default.properties" )); props.load(inputStreamFromFile("./conf.properties" ));
小结
把资源存储在classpath中可以避免文件路径依赖；
Class对象的getResourceAsStream()可以从classpath中读取指定资源；
根据classpath读取资源时，需要检查返回的InputStream是否为null。
序列化 序列化是指把一个Java对象变成二进制内容，本质上就是一个byte[]数组。byte[]保存到文件中，或者把byte[]通过网络传输到远程，这样，就相当于把Java对象存储到文件或者通过网络传输出去了。byte[]数组）变回Java对象。有了反序列化，保存到文件中的byte[]数组又可以“变回”Java对象，或者从网络上读取byte[]并把它“变回”Java对象。1 2 public interface Serializable {}
序列化 把一个Java对象变为byte[]数组，需要使用ObjectOutputStream。它负责把一个Java对象写入一个字节流：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 import java.io.*;import java.util.Arrays;public class Main { public static void main (String[] args) throws IOException { ByteArrayOutputStream buffer = new ByteArrayOutputStream (); try (ObjectOutputStream output = new ObjectOutputStream (buffer)) { output.writeInt(12345 ); output.writeUTF("Hello" ); output.writeObject(Double.valueOf(123.456 )); } System.out.println(Arrays.toString(buffer.toByteArray())); } }
反序列化 和ObjectOutputStream相反，ObjectInputStream负责从一个字节流读取Java对象：1 2 3 4 5 try (ObjectInputStream input = new ObjectInputStream (...)) { int n = input.readInt(); String s = input.readUTF(); Double d = (Double) input.readObject(); }
ClassNotFoundException：没有找到对应的Class；
InvalidClassException：Class不匹配。
对于ClassNotFoundException，这种情况常见于一台电脑上的Java程序把一个Java对象，例如，Person对象序列化以后，通过网络传给另一台电脑上的另一个Java程序，但是这台电脑的Java程序并没有定义Person类，所以无法反序列化。1 2 3 public class Person implements Serializable { private static final long serialVersionUID = 2709425275741743919L ; }
安全性 因为Java的序列化机制可以导致一个实例能直接从byte[]数组创建，而不经过构造方法，因此，它存在一定的安全隐患。一个精心构造的byte[]数组被反序列化后可以执行特定的Java代码，从而导致严重的安全漏洞。
小结
可序列化的Java对象必须实现java.io.Serializable接口，类似Serializable这样的空接口被称为“标记接口”（Marker Interface）；
反序列化时不调用构造方法，可设置serialVersionUID作为版本号（非必需）；
Java的序列化机制仅适用于Java，如果需要与其它语言交换数据，必须使用通用的序列化方法，例如JSON。
Reader Reader是Java的IO库提供的另一个输入流接口。和InputStream的区别是，InputStream是一个字节流，即以byte为单位读取，而Reader是一个字符流，即以char为单位读取：
InputStream
Reader
字节流，以byte为单位
字符流，以char为单位
读取字节（-1，0~255）：int read()
读取字符（-1，0~65535）：int read()
读到字节数组：int read(byte[] b)
读到字符数组：int read(char[] c)
java.io.Reader是所有字符输入流的超类，它最主要的方法是：1 public int read () throws IOException;
FileReader FileReader是Reader的一个子类，它可以打开文件并获取Reader。下面的代码演示了如何完整地读取一个FileReader的所有字符：1 2 3 4 5 6 7 8 9 10 11 12 public void readFile () throws IOException { Reader reader = new FileReader ("src/readme.txt" ); for (;;) { int n = reader.read(); if (n == -1 ) { break ; } System.out.println((char )n); } reader.close(); }
1 Reader reader = new FileReader ("src/readme.txt" , StandardCharsets.UTF_8);
1 2 3 try (Reader reader = new FileReader ("src/readme.txt" , StandardCharsets.UTF_8) { }
char[]数组的方法：1 public int read (char [] c) throws IOException
1 2 3 4 5 6 7 8 9 public void readFile () throws IOException { try (Reader reader = new FileReader ("src/readme.txt" , StandardCharsets.UTF_8)) { char [] buffer = new char [1000 ]; int n; while ((n = reader.read(buffer)) != -1 ) { System.out.println("read " + n + " chars." ); } } }
CharArrayReader CharArrayReader可以在内存中模拟一个Reader，它的作用实际上是把一个char[]数组变成一个Reader，这和ByteArrayInputStream非常类似：1 2 try (Reader reader = new CharArrayReader ("Hello" .toCharArray())) {}
StringReader StringReader可以直接把String作为数据源，它和CharArrayReader几乎一样：1 2 try (Reader reader = new StringReader ("Hello" )) {}
Reader和InputStream有什么关系？1 2 3 4 InputStream input = new FileInputStream ("src/readme.txt" );Reader reader = new InputStreamReader (input, "UTF-8" );
1 2 3 try (Reader reader = new InputStreamReader (new FileInputStream ("src/readme.txt" ), "UTF-8" )) { }
使用InputStreamReader，可以把一个InputStream转换成一个Reader。
小结
Reader定义了所有字符输入流的超类：
FileReader实现了文件字符流输入，使用时需要指定编码；
CharArrayReader和StringReader可以在内存中模拟一个字符流输入。
Reader是基于InputStream构造的：可以通过InputStreamReader在指定编码的同时将任何InputStream转换为Reader。
总是使用try (resource)保证Reader正确关闭。
Writer Reader是带编码转换器的InputStream，它把byte转换为char，而Writer就是带编码转换器的OutputStream，它把char转换为byte并输出。
OutputStream
Writer
字节流，以byte为单位
字符流，以char为单位
写入字节（0~255）：void write(int b)
写入字符（0~65535）：void write(int c)
写入字节数组：void write(byte[] b)
写入字符数组：void write(char[] c)
无对应方法
写入String：void write(String s)
Writer是所有字符输出流的超类，它提供的方法主要有：
写入一个字符（0~65535）：void write(int c)；
写入字符数组的所有字符：void write(char[] c)；
写入String表示的所有字符：void write(String s)。
FileWriter FileWriter就是向文件中写入字符流的Writer。它的使用方法和FileReader类似：1 2 3 4 5 try (Writer writer = new FileWriter ("readme.txt" , StandardCharsets.UTF_8)) { writer.write('H' ); writer.write("Hello" .toCharArray()); writer.write("Hello" ); }
CharArrayWriter CharArrayWriter可以在内存中创建一个Writer，它的作用实际上是构造一个缓冲区，可以写入char，最后得到写入的char[]数组，这和ByteArrayOutputStream非常类似：1 2 3 4 5 6 try (CharArrayWriter writer = new CharArrayWriter ()) { writer.write(65 ); writer.write(66 ); writer.write(67 ); char [] data = writer.toCharArray(); }
StringWriter StringWriter也是一个基于内存的Writer，它和CharArrayWriter类似。实际上，StringWriter在内部维护了一个StringBuffer，并对外提供了Writer接口。
OutputStreamWriter 除了CharArrayWriter和StringWriter外，普通的Writer实际上是基于OutputStream构造的，它接收char，然后在内部自动转换成一个或多个byte，并写入OutputStream。因此，OutputStreamWriter就是一个将任意的OutputStream转换为Writer的转换器：1 2 3 try (Writer writer = new OutputStreamWriter (new FileOutputStream ("readme.txt" ), "UTF-8" )) { }
小结
Writer定义了所有字符输出流的超类：
FileWriter实现了文件字符流输出；
CharArrayWriter和StringWriter在内存中模拟一个字符流输出。
使用try (resource)保证Writer正确关闭。
Writer是基于OutputStream构造的，可以通过OutputStreamWriter将OutputStream转换为Writer，转换时需要指定编码。
PrintStream和PrintWriter PrintStream PrintStream是一种FilterOutputStream，它在OutputStream的接口上，额外提供了一些写入各种数据类型的方法：
写入int：print(int)
写入boolean：print(boolean)
写入String：print(String)
写入Object：print(Object)，实际上相当于print(object.toString())
…
以及对应的一组println()方法，它会自动加上换行符。1 2 3 System.out.print(12345 ); System.out.print(new Object ()); System.out.println("Hello" );
PrintWriter PrintStream最终输出的总是byte数据，而PrintWriter则是扩展了Writer接口，它的print()/println()方法最终输出的是char数据。两者的使用方法几乎是一模一样的：1 2 3 4 5 6 7 8 9 10 11 12 import java.io.*;public class Main { public static void main (String[] args) { StringWriter buffer = new StringWriter (); try (PrintWriter pw = new PrintWriter (buffer)) { pw.println("Hello" ); pw.println(12345 ); pw.println(true ); } System.out.println(buffer.toString()); } }
小结
PrintStream是一种能接收各种数据类型的输出，打印数据时比较方便：
System.out是标准输出；
System.err是标准错误输出。
PrintWriter是基于Writer的输出。
使用Files 从Java 7开始，提供了Files和Paths这两个工具类，能极大地方便我们读写文件。byte[]，可以这么写：1 byte [] data = Files.readAllBytes(Paths.get("/path/to/file.txt" ));
1 2 3 4 5 6 String content1 = Files.readString(Paths.get("/path/to/file.txt" ));String content2 = Files.readString(Paths.get("/path/to/file.txt" ), StandardCharsets.ISO_8859_1);List<String> lines = Files.readAllLines(Paths.get("/path/to/file.txt" ));
1 2 3 4 5 6 7 8 byte [] data = ...Files.write(Paths.get("/path/to/file.txt" ), data); Files.writeString(Paths.get("/path/to/file.txt" ), "文本内容..." , StandardCharsets.ISO_8859_1); List<String> lines = ... Files.write(Paths.get("/path/to/file.txt" ), lines);
小结
对于简单的小文件读写操作，可以使用Files工具类简化代码。
