标签：
在java中，流(stream)是从源到目的地的字节的有序序列。流中的字节依据先进先出，具有严格顺序，因此流式I/O是一种顺序存取方式。
在java中有两种基本——输入流(InputStream)与输出流(OutputStream)，对于这两种流都采用相同的顺序读写方式，其读写操作过程如下：
流的读操作过程，打开流—>当流中还有数据时执行读操作—>关闭流
流的写操作过程，打开流—>当有数据需要输出时执行写操作—>关闭流。
Java中实现上述流式I/O的类都在java.io包中。
这些流根据流相对于程序的另一个端点的不同，分为节点流（Node Stream）和过滤流（Filter Stream）
节点流：以特定流如磁盘文件、内存某区域或线程之间的管道为端点构造的输入/输出流,它是一种最基本的流。
过滤流：以其他已经存在的流为端点构造的输入/输出流,称为过滤流或者处理流,它要对其相连的另一种流进行某种转换。
流根据数据单位不同又分为字节流和字符流：字节流（8位）和字符流（16位）。
1.输入字节流
InputStream是输入字节流的抽象顶层父类。
2.输出字节流
1.输入字符流
2.输出字符流
节点流类型常见的有：
对文件操作的字节流有FileInputStream/FileOutputStream，
字符流有FileReader/FileWriter。
处理流类型常见的有：
缓冲流：缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写效率，同事增加了一些新的方法。
字节缓冲流有BufferedInputStream/BufferedOutputStream，
字符缓冲流有BufferedReader/BufferedWriter，字符缓冲流分别提供了读取和写入一行的方法ReadLine和NewLine方法。
对于输出地缓冲流，写出的数据，会先写入到内存中，再使用flush方法将内存中的数据刷到硬盘。所以，在使用字符缓冲流的时候，一定要先flush，然后再close，避免数据丢失。
转换流：用于字节数据到字符数据之间的转换。
仅有字符流InputStreamReader/OutputStreamWriter。其中，InputStreamReader需要与InputStream“套接”，OutputStreamWriter需要与OutputStream“套接”。
数据流：提供了读写Java中的基本数据类型的功能。
DataInputStream和DataOutputStream分别继承自InputStream和OutputStream，需要“套接”在InputStream和OutputStream类型的节点流之上。
对象流：用于直接将对象写入写出。
流类有ObjectInputStream和ObjectOutputStream，本身这两个方法没什么，但是其要写出的对象有要求，该对象必须实现Serializable接口，来声明其是可以序列化的。否则，不能用对象流读写。
输入字节流：FileInputStream
--------| InputStream 所有输入字节流的基类 抽象类
------------| FileInputStream 读取文件数据的输入字节流
使用FileInputStream读取文件数据的步骤：
1. 找到目标文件
2. 建立数据的输入通道。
3. 读取文件中的数据。
4. 关闭 资源.
在使用时经常会使用自定义的缓冲数组以加快读取速度。
1 public class MyFileInputStream { 2 3 public static void main(String[] args) throws IOException { 4 readTest4(); 5 } 6 7 //使用缓冲数组配合循环一起读取。 推荐使用 8 public static void readTest4() throws IOException{ 9 long startTime = System.currentTimeMillis(); 10 //找到目标文件 11 File file = new File("F:\\81179-106.jpg"); 12 //建立数据的输入通道 13 FileInputStream fileInputStream = new FileInputStream(file); 14 //建立缓冲数组配合循环读取文件的数据。 15 int length = 0; //保存每次读取到的字节个数。 16 //存储读取到的数据 缓冲数组 的长度一般是1024的倍数，因为与计算机的处理单位。 理论上缓冲数组越大，效率越高 17 byte[] buf = new byte[1024]; 18 19 while((length = fileInputStream.read(buf))!=-1){ // read方法如果读取到了文件的末尾，那么会返回-1表示。 20 System.out.print(new String(buf,0,length)); 21 } 22 23 //关闭资源 24 fileInputStream.close(); 25 long endTime = System.currentTimeMillis(); 26 System.out.println("读取的时间是："+ (endTime-startTime)); //103 27 } 28 }
输出字节流：FileOutStream
--------| OutputStream 是所有输出字节流 的父类。 抽象类
-----------| FileOutStream 向文件输出数据的输出字节流。
FileOutputStream要注意的细节：
1. 使用FileOutputStream 的时候，如果目标文件不存在，那么会自动创建目标文件对象。
2. 使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。
3.使用FileOutputStream写数据的时候, 如果目标文件已经存在，需要在原来数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数，第二参数为true。
4.使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据，只是
把低八位的二进制数据写出，其他二十四位数据全部丢弃。
1 public class MyFileOutStream { 2 3 public static void main(String[] args) throws IOException { 4 writeTest3(); 5 } 6 7 8 //使用字节数组把数据写出。 9 public static void writeTest3() throws IOException{ 10 //找到目标文件 11 File file = new File("F:\\b.txt"); 12 //建立数据输出通道 13 FileOutputStream fileOutputStream = new FileOutputStream(file); 14 //把数据写出。 15 String data = "abc"; 16 byte[] buf = data.getBytes(); 17 fileOutputStream.write(buf, 0, 3); // 0 从字节数组的指定索引值开始写， 2：写出两个字节。 18 19 //关闭资源 20 fileOutputStream.close(); 21 } 22 }
----------| Reader 输入字符流的基类 抽象类
-------------| FileReader 读取文件的输入字符流。
1 public class MyFileReader { 2 3 public static void main(String[] args) throws IOException { 4 readTest2(); 5 } 6 public static void readTest2() throws IOException{ 7 //找到目标文件 8 File file = new File("F:\\Demo1.java"); 9 // 建立数据的输入通道 10 @SuppressWarnings("resource") 11 FileReader fileReader = new FileReader(file); 12 //建立缓冲字符数组读取文件数据 13 char[] buf = new char[1024]; 14 int length = 0 ; 15 while((length = fileReader.read(buf))!=-1){ 16 System.out.print(new String(buf,0,length)); 17 } 18 fileReader.close(); 19 } 20 21 }
------| Writer 输出字符流的基类。 抽象类
-----------| FileWriter 向文件数据数据的输出字符流
FileWriter要注意的事项：
1. 使用FileWriter写数据的时候，FileWriter内部是维护了一个1024个字符数组的，写数据的时候会先写入到它内部维护的字符数组中，如果需要
把数据真正写到硬盘上，需要调用flush或者是close方法或者是填满了内部的字符数组。
2. 使用FileWriter的时候，如果目标文件不存在，那么会自动创建目标文件。
3.使用FileWriter的时候， 如果目标文件已经存在了，那么默认情况会先情况文件中的数据，然后再写入数据 ， 如果需要在原来的基础上追加数据，
需要使用“new FileWriter(File , boolean)”的构造方法，第二参数为true。
FileWriter----| InputStream 输入字节流的基类。 抽象
----------| FileInputStream 读取文件数据的输入字节流
----------| BufferedInputStream 缓冲输入字节流 缓冲输入字节流的出现主要是为了提高读取文件数据的效率。
其实该类内部只不过是维护了一个8kb的字节数组而已。
注意： 凡是缓冲流都不具备读写文件的能力。
BufferedInputStream-------| OutputStream 所有输出字节流的基类 抽象类
------------| FileOutputStream 向文件 输出数据 的输出字节流
------------| Bufferedoutputstream 缓冲输出字节流 BufferedOutputStream出现的目的是为了提高写数据的效率。
内部也是维护了一个8kb的字节数组而已。
BufferedOutputStream 要注意的细节
1. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
2. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
调用flush方法或者是close方法、 或者是内部维护的字节数组已经填满数据的时候。
1 public class MyBufferedOutputStream { 2 3 public static void main(String[] args) throws IOException { 4 //找到目标文件 5 File file = new File("F:\\a.txt"); 6 //建立数据的输出通道 7 FileOutputStream fileOutputStream = new FileOutputStream(file); 8 //建立缓冲输出字节流对象 9 BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream); 10 //把数据写出 11 bufferedOutputStream.write("hello world".getBytes()); 12 //把缓冲数组中内部的数据写到硬盘上面。 13 //bufferedOutputStream.flush(); 14 bufferedOutputStream.close(); 15 } 16 17 }
输入字符流:
-------| Reader 所有输入字符流的基类。 抽象类
----------| FileReader 读取文件字符串的输入字符流。
----------| BufferedReader 缓冲输入字符流 。 缓冲 输入字符流出现的目的是为了提高读取文件 的效率和拓展了FileReader的功能。 其实该类内部也是维护了一个字符数组
----------| Writer 所有输出字符流的基类， 抽象类。
--------------- | FileWriter 向文件输出字符数据的输出字符流。
----------------| BufferedWriter 缓冲输出字符流 缓冲输出字符流作用： 提高FileWriter的写数据效率与拓展FileWriter的功能。
BufferedWriter内部只不过是提供了一个8k长度的字符数组作为缓冲区而已，拓展了FileWriter的功能。
对象输入输出流要注意的细节：
1. 如果对象需要被写出到文件上，那么对象所属的类必须要实现Serializable接口。 Serializable接口没有任何的方法，是一个标识接口而已。
2. 对象的反序列化创建对象的时候并不会调用到构造方法的、
3. serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字。
4. 使用ObjectInputStream反序列化的时候，ObjeectInputStream会先读取文件中的serialVersionUID，然后与本地的class文件的serialVersionUID
进行对比，如果这两个id不一致，那么反序列化就失败了。
5. 如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后
在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。
6. 如果一个对象某个数据不想被序列化到硬盘上，可以使用关键字transient修饰。
7. 如果一个类维护了另外一个类的引用，那么另外一个类也需要实现Serializable接口。
1 class Address implements Serializable{ 2 3 private static final long serialVersionUID = 1L; 4 5 String country; 6 7 String city; 8 9 public Address(String country,String city){ 10 this.country = country; 11 this.city = city; 12 } 13 14 } 15 16 class User implements Serializable{ 17 18 private static final long serialVersionUID = 1L; 19 20 String userName ; 21 22 String password; 23 24 transient int age; // transient 透明 25 26 Address address ; 27 28 29 public User(String userName , String passwrod) { 30 this.userName = userName; 31 this.password = passwrod; 32 } 33 34 35 public User(String userName , String passwrod,int age,Address address) { 36 this.userName = userName; 37 this.password = passwrod; 38 this.age = age; 39 this.address = address; 40 } 41 42 @Override 43 public String toString() { 44 return "用户名："+this.userName+ " 密码："+ this.password+" 年龄："+this.age+" 地址："+this.address.city; 45 } 46 } 47 public class ObjectOutputStream1 { 48 49 public static void main(String[] args) throws IOException, Exception { 50 writeObj(); 51 // readObj(); 52 } 53 54 //把文件中的对象信息读取出来-------->对象的反序列化 55 public static void readObj() throws IOException, ClassNotFoundException{ 56 //找到目标文件 57 File file = new File("F:\\obj.txt"); 58 //建立数据的输入通道 59 FileInputStream fileInputStream = new FileInputStream(file); 60 //建立对象的输入流对象 61 ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream); 62 //读取对象信息 63 User user = (User) objectInputStream.readObject(); //创建对象肯定要依赖对象所属 的class文件。 64 System.out.println("对象的信息："+ user); 65 } 66 //定义方法把对象的信息写到硬盘上------>对象的序列化。 67 public static void writeObj() throws IOException{ 68 //把user对象的信息持久化存储。 69 Address address = new Address("中国","广州"); 70 User user = new User("admin","123",15,address); 71 //找到目标文件 72 File file = new File("F:\\obj.txt"); 73 //建立数据输出流对象 74 FileOutputStream fileOutputStream = new FileOutputStream(file); 75 //建立对象的输出流对象 76 ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream); 77 //把对象写出 78 objectOutputStream.writeObject(user); 79 //关闭资源 80 objectOutputStream.close(); 81 82 83 } 84 }
1 /* 2 3 需求： 把一首mp3先切割成n份，然后再把这些文件合并起来。 4 5 */ 6 public class SequenceInputStream2 { 7 8 public static void main(String[] args) throws IOException { 9 // cutFile(); 10 mergeFlile(); 11 } 12 13 //合并 14 public static void mergeFlile() throws IOException{ 15 //找到目标文件 16 File dir = new File("F:\\music"); 17 //通过目标文件夹找到所有的MP3文件，然后把所有的MP3文件添加到vector中。 18 Vector<FileInputStream> vector = new Vector<FileInputStream>(); 19 File[] files = dir.listFiles(); 20 for(File file : files){ 21 if(file.getName().endsWith(".mp3")){ 22 vector.add(new FileInputStream(file)); 23 } 24 } 25 //通过Vector获取迭代器 26 Enumeration<FileInputStream> e = vector.elements(); 27 //创建序列流 28 SequenceInputStream inputStream = new SequenceInputStream(e); 29 //建立文件的输出通道 30 FileOutputStream fileOutputStream = new FileOutputStream("F:\\合并.mp3"); 31 //建立缓冲数组读取文件 32 byte[] buf = new byte[1024]; 33 int length = 0 ; 34 while((length = inputStream.read(buf))!=-1){ 35 fileOutputStream.write(buf,0,length); 36 } 37 //关闭资源 38 fileOutputStream.close(); 39 inputStream.close(); 40 41 } 42 43 //切割MP3 44 public static void cutFile() throws IOException{ 45 File file = new File("F:\\美女\\1.mp3"); 46 //目标文件夹 47 File dir = new File("F:\\music"); 48 //建立数据的输入通道 49 FileInputStream fileInputStream = new FileInputStream(file); 50 //建立缓冲数组读取 51 byte[] buf = new byte[1024*1024]; 52 int length = 0; 53 for(int i = 0 ; (length = fileInputStream.read(buf))!=-1 ; i++){ 54 FileOutputStream fileOutputStream = new FileOutputStream(new File(dir,"part"+i+".mp3")); 55 fileOutputStream.write(buf,0,length); 56 fileOutputStream.close(); 57 } 58 //关闭资源 59 fileInputStream.close(); 60 } 61 62 }
标签：
原文地址：http://www.cnblogs.com/FuckHard/p/5558426.html
