1.序列流：可以把多個位元組輸入流整合成一個，從序列流中讀取資料時，將從被整合的第一個流開始讀，讀完一個之後繼續第二個          SequenceInputStream2.記憶體輸出流：可以向記憶體中寫資料，把記憶體當作一個緩衝區，寫出之後可以一次性獲取所有資料          使用方式：(1)建立物件 new ByteArrayOutputStream()                  (2)寫出資料 write(int),write(byte[])                  (3)獲取資料 toByteArray()3.物件操作流：可以將一個物件寫出，或者讀取一個物件到程式中，也就是執行了序列化和反序列化的操作           序列化：將物件寫到檔案上4.列印流:

可以很方便的將物件的toString()結果輸出，並且自動加上換行，而且可以使用自動刷出的模式          System.out就是一個printStream，其預設向控制檯輸出資訊          使用方式：                  列印   print(),println()                  自動刷出:printWriter(OutputStream out,boolean autoFlush,String encoding)                  列印流只操作資料目的 5.標準的輸入輸出流          修改標準輸入輸出流,如果不關聯檔案，則可以不用關流6.兩種方式實現鍵盤錄入          (1)BufferedReader的readline()方法          (2)Scanner7.隨機訪問流          RandomAccessFile:不屬於流，是object類的子類，但融合了InputStream和OutputStream的功能支援隨機訪問檔案的讀取和寫入。              read(),write(),seek()8.資料輸入輸出流:DataInputStream和DateOutputStream可以按照基本資料型別大小讀寫資料

package pra_18;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintStream;
import java.io.RandomAccessFile;
import java.io.SequenceInputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Scanner;
import java.util.Vector;

public class J_36 {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		
		//1.序列流整合兩個的情況
		FileInputStream fis13=new FileInputStream("a.txt");
		FileInputStream fis23=new FileInputStream("b.txt");
		SequenceInputStream sis=new SequenceInputStream(fis13,fis23);
		FileOutputStream fos=new FileOutputStream("abba.txt");
		int b;
		while((b=sis.read())!=-1){
			fos.write(b);
		}
		sis.close();	//會將構造方法中傳入的流物件關閉
		fos.close();
		
			//序列流整合多個的情況
		FileInputStream fis1=new FileInputStream("a.txt");
		FileInputStream fis2=new FileInputStream("b.txt");
		FileInputStream fis3=new FileInputStream("c.txt");
		Vector<FileInputStream> v=new Vector<>();		//建立集合物件
		v.add(fis1);									//將流物件儲存進去
		v.add(fis2);
		v.add(fis3);
		Enumeration<FileInputStream> en=v.elements();
		SequenceInputStream sis2=new SequenceInputStream(en);	//將列舉的輸入流整合成一個
		FileOutputStream fos4=new FileOutputStream("abcc.txt");
		int c;
		while((c=sis2.read())!=-1){
			fos4.write(c);
		}
		sis2.close();
		fos4.close();
		
		//2.記憶體輸出流
		FileInputStream fis5=new FileInputStream("a.txt");
		ByteArrayOutputStream baos=new ByteArrayOutputStream();	//在記憶體中建立了可以增長的記憶體陣列
		int d;
		while((d=fis5.read())!=-1){
			baos.write(d);				//將讀取到的資料逐個寫到記憶體中
		}
		byte[] arr=baos.toByteArray();	//將緩衝區的資料全部獲取出來，並賦值給arr陣列
		//System.out.println(baos.toString());		//直接將緩衝區的內容轉換為了字串
		System.out.println(new String(arr));
		fis5.close();
		
		//3.物件操作流
			//物件輸出流，寫物件，序列化
		Pe2 pe=new Pe2("aa",1);
		Pe2 pe2=new Pe2("bb",2);
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("ada.txt"));
		oos.writeObject(pe);	//物件需要序列化才能寫出,需要實現Serializable的介面
		oos.writeObject(pe2);
		oos.close();
			//物件輸出流，讀物件，反序列化
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("ada.txt"));
		Pe2 pe3=(Pe2)ois.readObject();
		Pe2 pe4=(Pe2)ois.readObject();
		System.out.println(pe3);	//Pe2 [name=aa, age=1]
		System.out.println(pe4);	//Pe2 [name=bb, age=2]
			//物件操作流優化，將物件儲存在集合中寫出
		Pe2 pe5=new Pe2("cc",3);
		Pe2 pe6=new Pe2("dd",4);
		Pe2 pe7=new Pe2("ee",5);
		Pe2 pe8=new Pe2("ff",6);
		ArrayList<Pe2> al=new ArrayList<>();
		al.add(pe5);
		al.add(pe6);
		al.add(pe7);
		al.add(pe8);
		ObjectOutputStream oos2=new ObjectOutputStream(new FileOutputStream("ada2.txt"));
		oos2.writeObject(al);						//將集合物件一次寫入
		oos2.close();
		ObjectInputStream ois2=new ObjectInputStream(new FileInputStream("ada2.txt"));	
		ArrayList<Pe2> al2=(ArrayList<Pe2>)ois2.readObject();		//將集合物件一次讀取
		for (Pe2 pe22 : al2) {
			System.out.println(pe22);
		}
		ois2.close();
		
		//5.修改標準輸入輸出流拷貝圖片
		System.setIn(new FileInputStream("5.jpg")); 	//改變標準輸入流
		System.setOut(new PrintStream("5_06.jpg")); 		//改變標準輸出流
		
		InputStream is=System.in;
		PrintStream ps=System.out;
		byte[] arr2=new byte[1024];
		int len;
		while((len=is.read())!=-1){
			ps.write(arr2,0,len);
		}
		is.close();
		ps.close();
		//6.BufferedReader實現鍵盤錄入
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String line=br.readLine();
		System.out.println(line);
		br.close();
		
		//7.隨機訪問流,可以通過seek()方法實現多執行緒下載
		RandomAccessFile raf=new RandomAccessFile("aaa.txt","rw");
		int x=raf.read();
		System.out.println(x);
		raf.seek(10);				//在指定位置設定指標
		raf.write(8);
		raf.close();
		
		//8.資料輸入輸出流
		DataOutputStream dos=new DataOutputStream(new FileOutputStream("a.txt"));
		dos.writeInt(1102);
		dos.writeInt(1103);
		dos.writeInt(1104);
		dos.close();
		
		DataInputStream dis=new DataInputStream(new FileInputStream("a.txt"));
		int r=dis.readInt();
		int t=dis.readInt();
		int y=dis.readInt();
		System.out.println(r+" "+t+" "+y);
		dis.close();
	}
}
class Pe2 implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;	//在報錯時能儘快知道怎麼回事
	private String name;
	private int age;
	public Pe2() {
		super();
		
	}
	public Pe2(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Pe2 [name=" + name + ", age=" + age + "]";
	}
	
}