标签：
Java I/O系统：
1. Java类库提供了大量类，可以帮助我们从不同的设备读取数据，并保存或输出到不同的设备中。这些类同一放在java.io包和java.nio包中，统称为java I/O系统。
2. 流：我们可以将流理解为传送数据的管道，流是java I/O的基础，是java语言对 I/O 的一个最基本的抽象
流的两个最基本特性：
①含有流质。流质就是数据
②有方向。方向就是读或写，即针对设备进行信息的输入和输出
流的分类：
1)输入流和输出流——按流的方向分
输入流：从数据源读取数据到程序中。只能读不能写。io包中的输入流都继承自抽象类OutputStream或Reader 。
输出流：将数据从程序写入数据目的地。只能写不能读。io包中的输出流都继承自抽象类InputStream或Writer 。
2)字节流和字符流——流按处理数据的最小单位的不同分
字节流：以byte为最小单位进行数据传送。io包中的字节流都继承自抽象类InputStream或OutputStream 。
字符流：以char为最小单位进行数据传送。io包中的字节流都继承自抽象类Reader 或Writer 。
3)节点流和处理流——按流的功能分
节点流：又叫低级流，是可以直接 从 / 向 一个特定的数据源 读 / 写 数据的流 。
处理流：又叫高级流，处理流不能直接连接到设备，而是连接在已存在的流之上，通过对数据的处理为程序提供更强大的 读 / 写 功能 。
* 如果类的构造器带有一个已存在的流作为参数，那它就是高级流 。
3. I/O库中类具有对成性：
1)输入流和输出流的对称
2)字节流和字符流的对称
I/O操作步骤：建立流—>操作流—>关闭流
4. 文件类：将File对象看成是代表一个文件或目录的名称和位置的字符串。
5. 字节流：用于处理二进制文件
1 import java.io.File; 2 import java.io.FileInputStream; 3 import java.io.FileNotFoundException; 4 import java.io.FileOutputStream; 5 import java.io.IOException; 6 import java.io.InputStream; 7 import java.io.OutputStream; 8 9 /** 10 * 字节输入输出流测试 11 * 12 * 13 */ 14 public class IOTest { 15 16 public static void main(String[] args) { 17 StringBuffer buffer = new StringBuffer(); // 字符串缓冲 18 19 /* 输入流 */ 20 InputStream in = null; 21 22 try { 23 // 1. 打开输入流 24 in = new FileInputStream("E:\\jg\\exercise.txt"); 25 // 2. 读取 26 // byte[] b = new byte[128]; 27 byte[] b = new byte[1024 * 4]; 28 int len = in.read(b); // 返回读取到的字节数，返回-1表示读取到流结尾 29 while(len != -1){ 30 buffer.append(new String(b, 0, len)); // 将读取到的字节解析为String追加到缓冲 31 len = in.read(b); 32 } 33 // System.out.println("读到" + len + "字节的数据"); 34 System.out.println(buffer.toString()); 35 } catch (FileNotFoundException e) { 36 e.printStackTrace(); 37 } catch (IOException e) { 38 e.printStackTrace(); 39 } finally { 40 // 3. 释放资源，关闭输入流 41 if (in != null){ 42 try { 43 in.close(); 44 } catch (IOException e) { 45 e.printStackTrace(); 46 } 47 } 48 } 49 50 /* 输出流 */ 51 OutputStream out = null; 52 53 try { 54 File file = new File("D:\\test\\demo\\test.txt"); 55 if (!file.getParentFile().exists()){ // 文件路径不存在，则创建路径中所有不存在的目录 56 file.getParentFile().mkdirs(); 57 } 58 // 1. 打开输出流 59 out = new FileOutputStream(file); 60 // 2. 写 61 out.write(buffer.toString().getBytes()); 62 } catch (FileNotFoundException e) { 63 e.printStackTrace(); 64 } catch (IOException e) { 65 e.printStackTrace(); 66 } finally { 67 // 3. 释放输出流资源 68 if (out != null){ 69 try { 70 out.flush(); 71 out.close(); 72 } catch (IOException e) { 73 e.printStackTrace(); 74 } 75 } 76 } 77 } 78 }
6. 字符流：用于处理文本文件
1 import java.io.FileNotFoundException; 2 import java.io.FileReader; 3 import java.io.FileWriter; 4 import java.io.IOException; 5 import java.io.Reader; 6 import java.io.Writer; 7 8 /** 9 * 字符输入输出流测试 10 * 11 * 12 */ 13 public class IOTest2 { 14 15 public static void main(String[] args) { 16 StringBuffer buffer = new StringBuffer(); 17 18 /* 输入流 */ 19 Reader reader = null; 20 21 try { 22 // 1. 打开流 23 reader = new FileReader("E:\\jg\\exercise.txt"); 24 // 2. 读取 25 char[] ch = new char[128]; // 缓冲区 26 int len; 27 do { 28 len = reader.read(ch); 29 if (len == -1) 30 break; 31 buffer.append(new String(ch, 0, len)); 32 } while (len != -1); 33 System.out.println(buffer.toString()); 34 } catch (FileNotFoundException e) { 35 e.printStackTrace(); 36 } catch (IOException e) { 37 e.printStackTrace(); 38 } finally { 39 // 3. 释放资源 40 if (reader != null) { 41 try { 42 reader.close(); 43 } catch (IOException e) { 44 e.printStackTrace(); 45 } 46 } 47 } 48 49 /* 输出流 */ 50 51 Writer writer = null; 52 53 try { 54 // 1. 打开流 55 writer = new FileWriter("d:\\test.txt"); 56 // 2. 写入 57 writer.write(buffer.toString()); 58 } catch (IOException e) { 59 e.printStackTrace(); 60 } finally { 61 // 3. 释放资源 62 if (writer != null) { 63 try { 64 writer.flush(); 65 writer.close(); 66 } catch (IOException e) { 67 e.printStackTrace(); 68 } 69 } 70 } 71 } 72 }
7. 对象流：基于对象的读写，由ObjectInputStream / ObjectOutputStream来提供
读写对象：①对应的类必须实现java.io.Serializable接口；
②类被序列化之后通过ObjectInputStream / ObjectOutputStream对对象进行读写。
在定义类是用 transient 修饰属性则该属性不能被实例化。这样有利于保护数据安全性。
实现接口后使用ObjectInputStream 类将对象拆成字节序列的过程称为序列化；使用 ObjectOutputStream 类将字节序列还原称对象的过程称为反序列化。
8. java IO一般使用原则：
8.1按数据来源（去向）分类：
1、是文件：FileInputStream, FileOutputStream, FileReader, FileWriter
2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream
3、是Char[]: CharArrayReader, CharArrayWriter
4、是String: StringBufferInputStream, StringReader, StringWriter
5、网络数据流：InputStream, OutputStream, Reader, Writer
8.2按是否格式化输出分：
1、要格式化输出：PRintStream, PrintWriter
8.3按是否要缓冲分：
1、要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter
8.4按数据格式分：
1、二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream及其所有带Stream结束的子类
2、纯文本格式（含纯英文与汉字或其他编码方式）；Reader, Writer及其所有带Reader, Writer的子类
8.5按输入输出分：
1、输入：Reader, InputStream类型的子类
2、输出：Writer, OutputStream类型的子类
8.6特殊需要：
1、从Stream到Reader,Writer的转换类：InputStreamReader, OutputStreamWriter
2、对象输入输出：ObjectInputStream, ObjectOutputStream
3、进程间通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
4、合并输入：SequenceInputStream
5、更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader
标签：
原文地址：http://www.cnblogs.com/Myth-FQ/p/4457838.html
