Java——IO流(四)一些不常見的IO流(內存輸出流,隨機訪問流,序列流等等)

1.序列流：可以把多個字節輸入流整合成一個，從序列流中讀取數據時，將從被整合的第一個流開始讀，讀完一個之後繼續第二個
         SequenceInputStream
2.內存輸出流：可以向內存中寫數據，把內存當作一個緩衝區，寫出之後可以一次性獲取所有數據
         使用方式：(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)Scanner
7.隨機訪問流
         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 + "]";
	}
	
}