I/O流

IO流（資料流）：對儲存裝置上的資料進行操作

硬碟磁頭：複製檔案時這裡複製一次，磁頭在這邊複製一次；寫入的那邊，寫一次磁頭移動到那邊又寫一次。硬體移動花費時間量大，所以複製時要定義足夠大的緩衝區來一次性複製大量資料並寫入，大大增加效率

I/O流輸入輸出裝置區分：

源裝置：記憶體System.in、硬碟FileStream、鍵盤ArrayStream

目的裝置：記憶體System.out、硬碟File Stream、控制檯ArrayStream

字元流結構圖：

位元組流結構圖：

I/O流其他結構圖：

1.編碼表

1.碼錶分類

（1）ACCII碼錶：美國資訊標準交換碼，用二進位制數字表示英文字元

（2）GB2312碼錶：中國碼錶，用二進位制陣列表示中國漢字

（3）GBK碼錶：前者擴容後得到的GBK碼錶，現在為GBK18030。GBK中每個中文用2個位元組表示

（4）UNICODE碼錶：世界碼錶，國際標準化組織用二進位制數字表示全世界所有文字。Java預設編碼形式，char型別資料的編碼

（5）UTF-8碼錶：前者優化得來的，主要優化了任何字元都在UNICODE碼錶中佔用了個位元組的問題。UTF-8中每個中文用3個位元組表示。有自己的標識頭，資料最開始有標識，讀取資料方便

（6）IOS8859-1：拉丁碼錶，歐洲碼錶，伺服器Tomcat用的就是該碼錶，當用get方法傳遞資料是必須手動轉碼，post方法可以用內建物件解決

2.知識點

2.1 編碼：字串變為位元組陣列。資料儲存在硬碟上是進行了編碼操作

2.2 解碼：字元陣列變為字串。用不同軟體開啟硬碟上的檔案都是在做著解碼的操作

2.3 具體例子

（1）字串String str = "你好"，當使用getBytes("utf-8")形式編碼時，卻用new String(,"gbk")形式解碼，結果是：浣犲ソ。錯誤編碼無法解決，因為底層資料錯亂了

（2）字串String str = "你好"，當使用getBytes("gbk")形式編碼時，卻用new String(,"ISO8859-1")形式解碼，結果是：???。錯誤解碼可以解決，再次按照錯誤的碼錶編碼=>getBytes("ISO8859-1")，然後按照正確的碼錶解碼即可new String("gbk")。因為位元組陣列中的資料從頭至尾都是正確的沒有改變過。過程如下圖：

注意：如果是按照“utf-8形式解碼，不能用這種方法解決，因為再次編碼時改變源資料。問題的產生是因為【gbk】與【utf-8】都識別中文

===================================================================================================================

（3）問題：聯通（記事本txt中只存入“聯通”字元，不存入任何其他字元，儲存後再開啟會發現解碼錯誤，顯示亂碼）

           闡述：自動按照utf-8碼錶形式解碼。這裡解決問題先要闡述一下utf-8碼錶，這個碼錶中有2個位元組代表1字元，也有3個位元組代表1字元的，這樣如何判斷是讀取2個位元組還是3個位元組來查表？其實utf-8碼錶對每個位元組都新增了一個標示頭資訊，通過該標示頭資訊就可以知道是讀取1個或者2個還是位元組3個位元組來查表。這時我們可以獲取“聯通”字串的4個位元組的二進位制表現形式，你會發現這2個字元正好符合utf-8定義的標識頭，所以記事本沒有按照gbk碼錶解碼，而是用utf-8碼錶解碼的。

         解決：在聯通前邊加入任意其他中文字元即可正常解碼，使用gbk解碼，顯示正常

特：utf-8的標示頭對照表如下：

\u0001' 到 '\u007F' 範圍內的所有字元都是用單個位元組表示的：

	位值
位元組 1	0 位 6-0

null 字元 '\u0000' 以及從 '\u0080' 到 '\u07FF' 的範圍內的字元用兩個位元組表示：

	位值
位元組 1	1 1 0 位 10-6
位元組 2	1 0 位 5-0

	位值
位元組 1	1 1 1 0 位 15-12
位元組 2	1 0 位 11-6
位元組 3	1 0 位 5-0

===================================================================================================================

2.字元流

特點：主要用於操作字元資料。基於位元組流，解決了編碼問題，因為內部融合了編碼表，查位元組對碼錶。可以自定義指定所需要的碼錶

注意：應用系統不同換行符不同，windows為 \r\n， Linux為 \n

1.Writer抽象類

注意：寫入的過程都是在呼叫系統中的資源在寫入資料，所以使用完畢後一定要釋放資源

import java.io.*;

class java
{
	public static void main(String[] args){
		FileWriter fw = null;//定義引用

		try{
			//建立檔案寫入流
			fw = new FileWriter("d:\\a.txt");
			
			//寫入資料
			fw.write("鄭天成是個SB！");

		}catch(IOException e){//處理異常
			e.printStackTrace();
		}finally{
			if(fw!=null)//判斷是否為空
				try{
					fw.close();//關資源
				}catch(IOException e){
					e.printStackTrace();
				}
		}
	}
}

1.1 OutputStreamWriter類

1.2 FileWriter類

FileWriter字符集：採用平臺預設字元編碼

2.Reader抽象類

注意：windows每個檔案結尾處都有一個被系統識別的結束標識

2.1 InputStreamReader類

2.2 FileReader類

FileWriter字符集：採用平臺預設字元編碼

（1）程式碼演示：（將一個檔案讀取並列印在控制檯上）

import java.io.*;

/**
*將一個檔案讀取並列印在控制檯上
*/
class java
{
	public static void main(String[] args){
		FileReader fr = null;

		try{
			fr = new FileReader("t03.java");//指定讀取的檔案

			char[] chr = new char[1024];//定義儲存資料的陣列
			int length = 0;//定義判斷標記，陣列可用資料長度

			while((length=fr.read(chr))!=-1){
				System.out.print(String.valueOf(chr,0,length));
			}		
		}catch(IOException e){
			System.out.println(e.toString());
		}finally{//保證一定關閉資源
			if(fr!=null)//防止拋異常後空指標的出現
				try{
					fr.close();//關閉資源
				}catch(IOException e){
					System.out.println(e.toString());
				}
		}
	}
}

/**
*將D盤一個文字檔案複製到E盤
*/
class java
{
	public static void main(String[] args){
		FileReader fr = null;
		FileWriter fw = null;

		try{
			fr = new FileReader("t03.java");//指定讀取的檔案
			fw = new FileWriter("E:\\java複製的檔案.txt");//指定複製的地址與檔名

			char[] chr = new char[1024];//定義儲存資料的陣列
			int length = 0;//定義判斷標記，陣列可用資料長度

			while((length=fr.read(chr))!=-1){
				fw.write(String.valueOf(chr,0,length));
				fw.flush();
			}		
		}catch(IOException e){
			System.out.println(e.toString());
		}finally{//保證一定關閉資源
			if(fr!=null)//防止拋異常後空指標的出現
				try{
					fr.close();//關閉資源
				}catch(IOException e){
					System.out.println(e.toString());
				}
			if(fw!=null)
				try{
					fw.close();//關閉資源
				}catch(IOException e){
					System.out.println(e.toString());
				}
		}
	}
}

意義：緩衝區的出現是為了增加流運算元據的效率的，所有在建立緩衝區之前，一定要有流物件。

知識：下載工具中就有緩衝區的存在，表示先把資料放在一塊設定好大小的記憶體當中——緩衝區，然後當緩衝區填滿後再傳輸進硬碟

3.1 BufferedWriter類

3.2 BufferedReader類

（1）自定義一個BufferedReader（注意最後一行沒有換行符時，單單隻判斷結束標記會導致最後一行無法返回）

class MyBufferedReader
{
	private FileReader fr;
	MyBufferedReader(FileReader fr){
		this.fr = fr;
	}

	//可以每次讀取一行的方法
	public String myReadLine()throws IOException{
		//原緩衝區是用的字元陣列，這裡為了方便用了StringBuilder
		StringBuilder sb = new StringBuilder();

		int ch;

		while((ch=fr.read())!=-1){
			if(ch=='\r')
				continue;
			else if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}

		//當最後一行沒有回車時不加下邊語句，最後一行不會返回
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}

	public void myClose()throws IOException{
		fr.close();
	}
}

3.2.1 LineNumberReader類

1.知識點：

2.功能簡介：

3.位元組流

特點：當操作的資料不是本文資料，比如多媒體資料，應該用位元組流操作

要點：（底層）

問題：當讀取到一個多媒體檔案時，由於多媒體檔案資料排列不一，很可能出現其中1位元組的資料是1111-1111，因為1111-1111對應的十進位制數字是-1，這樣讀到的這一位元組返回值就是-1。沒有讀到檔案結尾處就返回了-1

解決：你會發現API中read方法返回值為int型，這是為什麼?

返回的byte型-1二級制形式為1111-1111，正常轉換為int型後應該是1111-1111 1111-1111 1111-1111 1111-1111。這樣還是不能解決問題。

不過可以通過int型-1=>1111-1111 1111-1111 1111-1111 1111-1111 和 255=>0000-0000 0000-0000 0000-0000 1111-1111做"&"的運算。

結果為255，二級製表現形式為 0000-0000 0000-0000 0000-0000 1111-1111，你會發現在這樣處理既保證後設資料沒有變化，又避免了-1這種情況的草出現。這也是為什麼返回值不是byte型，而是int型的原因。返回的結果都在做著 &255的操作。

read()方法讀取到的資料是int型別，是原來byte型別大小的四倍；而wirte()方法又在做著強轉的過程，保證了寫入的資料是byte型別，只往出寫資料的最低8位。（記憶體中真正的過程）

1.OutputStream抽象類

2.1 FileOutputStream類

注意：此類寫資料時不用重新整理，因為此類沒用到緩衝區，這是對最小單位位元組的操作，直接往目的地裡存即可，中間過程不涉及任何轉換，所以用不到緩衝區，也就不會用到重新整理操作

1.InputStream抽象類

/**
*鍵盤錄入：定義輸入裝置，鍵盤錄入，然後列印輸入文字的大寫形式，輸入over結束本功能
*/
class java
{
	public static void main(String[] args)throws IOException{
		InputStream is = System.in;//鍵盤錄入讀取流
		StringBuilder sb = new StringBuilder();//緩衝區
		
		while(true){
			int ch = is.read();//記住讀到的字元
			if(ch=='\r')
				continue;
			if(ch=='\n'){
				String str = sb.toString();
				if("over".equals(str))//輸入over結束的實現
					break;
				System.out.println(str.toUpperCase());//輸出大寫形式
				sb.delete(0,sb.length());//清空緩衝區
			}
			else
				sb.append((char)ch);//存入緩衝區

		}
	}
}

1.1 FileInputStream類

（1）程式碼演示：（複製一張圖片）

/**
*複製一張圖片到指定位置
*/
class java
{
	public static void main(String[] args){
		InputStream fis = null;//位元組輸入流
		OutputStream fos = null;//位元組輸出流
		try{
			fis = new FileInputStream("MIKU.jpg");//目標檔案
			fos = new  FileOutputStream("我的圖片.jpg");//目的地
			
			byte[] ch = new byte[1024];//緩衝區陣列
			int len;//陣列長度
			while((len=fis.read(ch))!=-1)
				fos.write(ch,0,len);//寫資料
		}catch(IOException e){
			throw new RuntimeException(e);//異常傳遞	
		}finally{
			if(fis!=null)
				try{
					fis.close();//關閉資源
				}catch(IOException e){
					throw new RuntimeException(e);
				}
			if(fos!=null)
				try{
					fos.close();//關閉資源
				}catch(IOException e){
					throw new RuntimeException(e);
				}
		}
	}
}

3.緩衝區

注意：緩衝區一定要用read(byte[]）的方法，不然不但不增加效率，而且減少效率，還不如在FileInputStream中自定義new byte[1024]這種來的有效率

特點：緩衝區就是自定義一個陣列接收臨時資料，存多了一起存數儲存介質中

3.1 BufferedOutputStream類

3.2 BufferedInputStream類

（1）緩衝區效率上的體現（三個函式分別採用三種方式複製檔案）

import java.io.*;

/**
*比較緩衝區相比正常檔案流效率上的優化
*/
class java
{
	public static void main(String[] args)throws Exception{
		long start = System.currentTimeMillis();
		copy_3();
		long end = System.currentTimeMillis();
		System.out.println((end-start)+"毫秒");
	}

	public static void copy_1(){
		InputStream fis = null;//位元組輸入流
		OutputStream fos = null;//位元組輸出流
		try{
			fis = new FileInputStream("笨蛋、測試、召喚獸第一季-OP.m4a");//目標檔案
			fos = new  FileOutputStream("01.m4a");//目的地
			
			byte[] ch = new byte[1024];//緩衝區陣列
			int len;//陣列長度
			while((len=fis.read(ch))!=-1)
				fos.write(ch,0,len);//寫資料
		}catch(IOException e){
			throw new RuntimeException(e);//異常傳遞	
		}finally{
			if(fis!=null)
				try{
					fis.close();//關閉資源
				}catch(IOException e){
					throw new RuntimeException(e);
				}
			if(fos!=null)
				try{
					fos.close();//關閉資源
				}catch(IOException e){
					throw new RuntimeException(e);
				}
		}
	}

	public static void copy_2()throws IOException{
		BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("笨蛋、測試、召喚獸第一季-OP.m4a"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("01.m4a"));

		int ch;
		while((ch=bufis.read())!=-1)
			bufos.write(ch);

		bufis.close();
		bufos.close();
	}

	public static void copy_3()throws IOException{
		BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("笨蛋、測試、召喚獸第一季-OP.m4a"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("01.m4a"));

		byte[] buf = new byte[1024];
		int ch;
		while((ch=bufis.read(buf))!=-1)
			bufos.write(buf,0,ch);

		bufis.close();
		bufos.close();
	}
}

4.轉換流

注意：下邊兩個類的使用方法請在標題2中去查詢

檔案字元流其實就是封裝了本地字符集(GBK)的轉換流，做了簡單的封裝。所以不是GBK就用轉換流就好

1.OutputStreamWriter類

意義：此轉換流是位元組流通向字元流的橋樑，實際應用時就是為了用字元流的特殊方法操作位元組流接收的資料

2.InpuStreamReader類

意義：此轉換流是位元組流通向字元流的橋樑，實際應用時就是為了用字元流的特殊方法操作位元組流接收的資料

（1）程式碼實際操作

/**
*鍵盤錄入：定義輸入裝置，鍵盤錄入，然後列印輸入文字的大寫形式，輸入over就是本功能
*/
class java
{
	public static void main(String[] args)throws IOException{
		//獲取鍵盤錄入，通過轉換流來實現用字元緩衝讀取流操作
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));	

		//獲取列印控制檯的流，通過轉換流老實現字元緩衝寫入流操作
		BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

		String line = null;

		while((line=bufr.readLine())!=null){
			if("over".equals(line))//定義結束標記
				break;
			bufw.write(line.toUpperCase());//大寫輸出
			bufw.newLine();//跨平臺換行
			bufw.flush();//重新整理
		}

		bufr.close();
		bufw.close();
	}
}

5.File類

（1）用來將檔案或資料夾封裝成物件，可以操作檔案或資料夾的屬性資訊

1 功能簡介：

1.1 建立

1.2 刪除

1.3 判斷

1.4 獲取資訊

1.5 移動

2.FilenameFilter介面

意義：這是檔名過濾器

意義：這是檔名過濾器

import java.io.*;
/**
*檔名過濾器
*/
class java
{
	public static void main(String[] args)throws Exception{
		File mainDir = new File("F:\\我妹妹最近有點怪");

		File[] arr =  mainDir.listFiles(new FileFilter(){//傳入檔名過濾器
			public boolean accept(File pathname){
				if(pathname.getName().endsWith(".mkv"))//判斷是否是mkv格式
					return true;
				return false;
			}
		});

		for(File f : arr){
			System.out.println(f);//獲取檔案資訊列印在控制檯上
		}
	}
}

4.遞迴

（1）事實：就是函式自身執行的過程中呼叫自身。遞迴需要限定條件才能實現，不然就是無限迴圈

（2）程式碼演示：（最簡單的遞迴）

/**
*最簡單的遞迴，遞迴就是函式自身執行時呼叫自身
*/

class java
{
	public static void main(String[] args){
		getContent(new File("E:\\新建資料夾"));
	}

	public static void getContent(File dir){
		File[] files = dir.listFiles();

		for(File file : files){
			if(file.isDirectory())
				getContent(file);
			else
				System.out.println(file);
		}
	}
}

（3）底層運算樣圖（以把6轉換為二進位制遞迴為例）

（4）遞迴與迴圈的優劣

<1>.遞迴演算法： 
優點：程式碼簡潔、清晰，並且容易驗證正確性。（如果你真的理解了演算法的話，否則你更暈） 
缺點：它的執行需要較多次數的函式呼叫，如果呼叫層數比較深，需要增加額外的堆疊處理，比如引數傳遞需要壓棧等操作，會對執行效率有一定影響。但是，對於某些問題，如果不使用遞迴，那將是極端難看的程式碼。 遞迴次數太多，超出棧內寸的空間，記憶體溢位

<2>.迴圈演算法：  
優點：速度快，結構簡單。
缺點：並不能解決所有的問題。有的問題適合使用遞迴而不是迴圈。如果使用迴圈並不困難的話，最好使用迴圈。

遞迴演算法 和迴圈演算法總結  
1.   一般遞迴呼叫可以處理的演算法，也通過迴圈去解決常需要額外的低效處理 。
2.   現在的編譯器在優化後，對於多次呼叫的函式處理會有非常好的效率優化，效率未必低於迴圈。

（5）程式碼演示：（帶層級的列出資料夾下的所有內容）

import java.io.*;

class java
{
	public static void main(String[] args){
		getContent(new File("E:\\動漫MAD"),0);
	}

	//新增層級字串
	public static String getLevel(int level){
		StringBuilder sb = new StringBuilder();
		sb.append("|--");
		for(int x=0;x<level;x++){
			//sb.append("|--");
			sb.insert(0,"  ");
		}
		return sb.toString();
	}

	//遞迴得到目錄下的全部內容
	public static void getContent(File dir,int level){
		File[] files = dir.listFiles();
		level++;

		for(File file : files){
			if(!file.isHidden() && file.isDirectory())
				getContent(file,level);
			else
				System.out.println(getLevel(level)+file);
		}
	}
}

6 列印流

（1）注意：列印的流全是輸出流，只是分為字元和位元組兩種

（2）列印流的好處：可以對基本資料型別直接操作，保證資料的原樣性將資料列印

（3）列印流非常常用，必須會用。列印流特點方法 => println

1.PrintStream類

2.PrintWriter類

import java.io.*;
/**
*列印流
*/
class java
{
	public static void main(String[] args)throws Exception{
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

		String line = null;

		PrintWriter pw = new PrintWriter(new FileWriter("Upper.txt"),true);//自動重新整理

		while((line=bufr.readLine())!=null){
			if("over".equals(line))//結束標記
				break;
			pw.println(line.toUpperCase());//列印流不用重新整理和換行
		}

		bufr.close();
		pw.close();
	}
}

7.合併流

1.SequenceInputStream類

（1）意義：合併多個流為一個大流，從第一個開始一直讀出最後一個的資料。可以同時讀取多個檔案的資料合併到一個檔案中

2.切割檔案

（1）切割的原理：通過定義一個固定大小的byte[]型陣列，來知道每次寫入資料的具體大小

（2）切割檔案與合併檔案程式碼實現：

import java.io.*;
import java.util.*;
/**
*分割與合併多個檔案
*/

class java
{
	public static void main(String[] args)throws Exception{
		File file = new File("d:\\銀魂第二季-ED1.m4a");
		spitFile(file);
		combineFile();
	}

	//分割檔案
	public static void spitFile(File file)throws Exception{
		BufferedInputStream bufis = new BufferedInputStream(new FileInputStream(file));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("d:\\分割檔案\\1.part"));;

		byte[] buf = new byte[1024*1024];
		
		for(int countFile=2,countSize=0,len;(len=bufis.read(buf))!=-1;countSize++){
			if(countSize==5){//限制每個檔案大小為5M
				bufos = new BufferedOutputStream(new FileOutputStream("d:\\分割檔案\\"+countFile+".part"));
				countFile++;
				countSize = 0;
			}
			bufos.write(buf,0,len);//寫入1M資料
		}

		bufis.close();
		bufos.close();
	}

	//合併檔案
	public static void combineFile()throws Exception{
		Vector<InputStream> list = new Vector<InputStream>();
		list.add(new FileInputStream("d:\\分割檔案\\1.part"));
		list.add(new FileInputStream("d:\\分割檔案\\2.part"));

		Enumeration<InputStream> en = list.elements();
		
		BufferedInputStream bufis = new BufferedInputStream(new SequenceInputStream(en));//合併多個流

		byte[] buf = new byte[1024];
		int len;
		PrintStream ps = new PrintStream("d:\\我的銀魂.m4a");
		while((len=bufis.read(buf))!=-1)
			ps.write(buf,0,len);

		bufis.close();
		ps.close();
	}
}

8.操作物件的流

（1）意義：對堆記憶體中的物件進行持久化儲存，也稱為物件的序列化

1.ObjectOutputStream類

2.ObjectInputStream類

3.Serializable介面

（1）說明：你會發現這個介面沒有成員，這種介面一般被稱為標記介面，就等於給實現它的類做了標記

（2）原理：ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;每個類都有一個serialVersionUID號，這樣類就被ID所標識，其所生成的物件也被這個ID鎖標識，這個ID一般被編譯器所用。當類改變時，其ID也會隨之改變，持久化儲存的物件會因為ID號與新的類不同而產生不匹配的結果。這個UID是通過類中的所有成員的數字標識(數字簽名)所得出的

（3）如果不想讓系統自動根據成員生成UID，可由我們自動固定UID，建立子類成員變數——public static final long serialVersionUID = 42L;來讓UID固定不變

（4）只有堆記憶體中的資料能夠序列化，方法區中的靜態成員無法序列化

（5）如果你不想讓非靜態成員序列化，那麼可以用transient關鍵字修飾

（6）物件序列化儲存的本地檔案命名格式可以為：類名.object

4.transient關鍵字

import java.io.*;
/**
*物件的序列化
*/
class java
{
	public static void main(String[] args)throws Exception{
		//write(new Person[]{new Person("張天成",25),new Person("張天",5)});//傳入多個物件
		read(new File("d:\\save.object"));
	}

	//讀取檔案中的物件
	public static void read(File file)throws Exception{
		//讀取序列化物件
		ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(file)));

		Person[] p = (Person[])ois.readObject();//獲取物件陣列

		for(Person per : p){//解析出陣列中的全部物件取出物件
			per.get();	
		}
	}

	public static <T> void write(T t)throws IOException{
		//序列化物件
		ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:\\save.object")));

		oos.writeObject(t);

		oos.close();
	}
}

class Person implements Serializable//實現標記介面
{
	private String name;
	private int age;

	Person(String name,int age){
		this.name = name;
		this.age = age;
	}

	public void get(){
		System.out.println(name+"..."+age);
	}
}

9.管道流

（1）意義：一般輸出流與輸入流同時操作要提供一箇中轉站——一個陣列、字串等，而管道流能直接連線上，不用建立中轉站

（2）注意：建議通過多執行緒的wait、nitify來控制，單執行緒可能會造成死鎖

1.PipedInputStream類

2.PipedOutputStream類

10.操作集中資料型別的流

1.操作基本資料型別

1.1 DataOutputStream類

（1）此流的功能與RundomAccessFile流中寫基本資料型別的方法相同，不在一一舉出

1.2 DataIntputStream類

2.操作位元組陣列中資料

2.1 ByteArrayOutputStream類

2.2 ByteArrayInputStream類

3.操作字元陣列中資料

3.1 CharArrayWriter類

3.2 CharArrayReader類

4.操作字串中資料

4.1 StringWriter類

4.2 StringReader類

注意：此類會丟擲異常，請處理，雖說不知道為什麼

11.RandomAccessFile類

（1）意義：此類例項支援對隨機訪問檔案的讀取和寫入，物件內部封裝了陣列和指標，通過指標來運算元據

（2）特點：不算是IO體系中的子類，直接繼承自Object

（3）重點：能夠實現隨機讀寫資料——就是讀取某具體位置的資料或者在某個具體位置寫入資料。基於這個原理可以實現資料的分段寫入，並用多執行緒操作不同資料段來增加效率。如果讓多執行緒操作其他的流，寫完資料後就會發現寫入的資料是錯亂的。這就是隨機讀寫訪問，下載就是基於這個原理

（4）注意：此流不會覆蓋原始檔，而是在其基礎上覆寫檔案

import java.io.*;
import java.util.*;

/*
需求：有五個學生，每個學生有3門課的成績，從鍵盤輸入以上資料（包括姓名，三門課成績）
	  輸入格式：如：張三 30, 40, 60計算出總成績，並把學生的資訊和計算出來的總分數高低順序高低順序存放在磁碟檔案"stud.txt"
思路：1.首先鍵盤錄入是可以這樣表示
*/

class java
{
	public static void main(String[] args) 
	{
		new StudentIn().inputInfo();
	}
}

class Student implements Comparable<Student>
{
	private String name;
	private int math;
	private int en;
	private int chis;
	private int bio;
	
	//初始化成員
	Student(String name,int math,int en, int chis,int bio){
		this.name = name;
		this.math = math;
		this.en = en;
		this.chis = chis;
		this.bio = bio;
	}

	//獲取成員
	public int getMath(){
		return math;
	}

	public int getEn(){
		return en;
	}

	public int getChis(){
		return chis;
	}

	public int getBio(){
		return bio;
	}

	public int getGrade(){
		return math+en+chis+bio;
	}

	public String getName(){
		return this.name;
	}

	//複寫hashCode方法
	public int hashCode(){
		return name.hashCode()+math*6+en*2+chis*9+bio*7;
	}

	//複習equal方法
	public boolean equals(Object o){
		if(!(o instanceof Student))
			throw new ClassCastException();
		Student s = (Student)o;

		return name.equals(s.getName()) && getGrade() == s.getGrade();
	}

	//判斷大小
	public int compareTo(Student s){
		if(getGrade()==s.getGrade())
			return name.compareTo(s.getName());
		else
			return new Integer(getGrade()).compareTo(s.getGrade());
	}
}

class StudentIn
{

	public void inputInfo(){
		File file = new File("studentInfo.text");//獲取資料儲存檔案地址

		BufferedReader bufr = null;
		PrintWriter pw = null;

		//儲存資料的集合，對學生成績總分進行排序，按照從大到小的順序
		TreeSet<Student> ts = new TreeSet<Student>(Collections.reverseOrder());
		try{
			bufr = new BufferedReader(new InputStreamReader(System.in));
			pw = new PrintWriter(new BufferedWriter(new FileWriter(file)),true);

			for(int x=0;x<3;x++){//存入三個學生
				System.out.print("請輸入學生名稱：");
				String name = bufr.readLine();
				System.out.print("請輸入數學成績：");
				int math = Integer.parseInt(bufr.readLine());
				System.out.print("請輸入英語成績：");
				int en = Integer.parseInt(bufr.readLine());
				System.out.print("請輸入語文成績：");
				int chis = Integer.parseInt(bufr.readLine());
				System.out.print("請輸入生物成績：");
				int bio = Integer.parseInt(bufr.readLine());
				System.out.println("======================");
				
				Student s = new Student(name,math,en,chis,bio);

				ts.add(s);//存入TreeSet集合，並進行排序
			}
			
			//寫入資料到檔案
			for(Student s : ts){
				pw.println("姓名："+s.getName());
				pw.println("數學："+s.getMath());
				pw.println("英語："+s.getEn());
				pw.println("語文："+s.getChis());
				pw.println("生物："+s.getBio());
				pw.println("總分："+s.getGrade());
				pw.println();
			}

			pw.close();
			bufr.close();//便於觀看，未新增到finally程式碼塊
			
		}catch(IOException e){
			throw new RuntimeException("存入資料出錯",e);
		}
		System.out.print("========資訊存入成功========");
	}

}