處理流（包在其他管道上的管道）


緩衝流：
BufferedReader(Reader in)
BufferedReader(Reader in,int sz)//sz為自定義緩衝區的大小
BufferedWriter(Writer out)
BufferedInputStream(InputStream in)
BufferedOutputStream(OutputStream out)


public class BufferedCopy{
public static void main(String [] args){
try{
BufferedReader br = new BufferedReader(new FileReader("D;\\a\\a.txt"));
BufferedWriter bw = new BufferedReader(new FileWriter("D:\\a\\a.txt"));
String s= null;
for(int i;i<=100;i++){
s = String.valueOf(Math.random());
bw.write(s);
bw.newLine();


}
bw.flush();
while((s=br.readLine())!=null){
System.out.println((char)s);

}
bw.close();
br.close();
}catch(IOException ioe){
ioe.printStackTrace();
}
}
try{ 
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream(D:\\a.txt));
osw.write("abababababa");
System.out.println(osw.getEncoding);
osw.close();
osw  = new OutputStreamWriter(
new FileOutputStream("D:\\a.txt",true),"ISO08859_1");
//進行續寫，不加true，直接覆蓋
osw.write("fdfdfdfdsaafdsffdf");
System.out.pritln(osw.getEncoding());
osw.close();
}catch(IOException ioe){
e.printStackTrace();
}


System.in 標準輸入流 inputStream
System.out 標準輸出流
public class TransForm2{
public static void main(){
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
try{
while(s!=null){
if(s.equalsIgnoreCase("exit"))
break;
System.out.println(s.toUpperCase());
s = br.readLine();
}
br.close();
}catch(IOException){
e.printStackTrace();
}
}
}




資料流：(處理流)
PrintWriter
PrintStream


Public class TestPrintStream{
public static void main(){
PrintStream ps = null;
try{
FileOutputStream fos = new FileOutputStream
("D:\\a\\a.txt");
ps = new PrintStream(fos);
}catch(Exception e){
e.printStackTrace();
}
if(ps!=null){
System.setOut(ps);把向控制檯輸出改成向檔案內部輸出
}
int ln =0;
for(char c =0;c<60000;c++){
System.out.print(c+" "); //內容列印在a.txt內部
if(ln++>100){
System.out.println();
ln = 0;
}
}

}
}






printStream 包含著 FileOutputStream 關聯著a.txt
當System呼叫setOut（ps），就不再向預設的控制檯列印，而是指向了
printStream，因此 System.out.println時候就向著a.txt內部列印。




System.out是一種PrintStream
public class TestPrintStream{
public static void main(){
String filename = args[0];
if(filename!=null){
list(filename,System.out)
} 
}

public static void list(String filename, PrintStream ps){
try{
BufferedReader br =new BufferedReader(new FileReader(filename));
String s = null;
while((s=br.readLine())!=null){//readLine是否到達檔案尾部比較的是null
//BufferedReader 的readLine()一次讀一行，返回字串
//read是否到達檔案尾部比較的是-1
//FileReader的read()一次讀2個位元組


ps.println(s);
}
br.close();
}catch(Exception e){
e.printStackTrace();
}
}
}








PrintStream 為其他輸出流添加了功能，使它們能夠方便地列印各種資料值表示形式。它還提供其他兩項功能。與其他輸出流不同，PrintStream 永遠不會丟擲 IOException；而是，異常情況僅設定可通過 checkError 方法測試的內部標誌。另外，為了自動重新整理，可以建立一個 PrintStream；這意味著可在寫入 byte 陣列之後自動呼叫 flush 方法，可呼叫其中一個 println 方法，或寫入一個換行符或位元組 ('\n')。


PrintStream 列印的所有字元都使用平臺的預設字元編碼轉換為位元組。在需要寫入字元而不是寫入位元組的情況下，應該使用 PrintWriter 類。


public class TestPrintStream3{
public static void main(){
String s =null;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try{
FileWriter fw = new FileWriter("d:/a.txt");
PrintWriter log = new PrintWriter(fw);
while((s=br.readLine())!=null){
if(s.equalsIgnoreCase("exit")){
break;
}
System.out.println(s.toUpperCase());
log.println(s.toUpperCase());
}
log.println(new Date());
log.flush();
log.close();
}catch(Exception e){
e.printStackTrace();
}
}


}


抽象類
Reader
Writer
InputStream
OutputStream


初始流
FileReader
FileWriter
FileInputStream
FileOutputStream


處理流
InputStreamReader將位元組流轉換成字元流  中文是兩個位元組，單個位元組輸出顯示？？
OutputStreamWritere將字元流轉換成位元組流
處理流（包裹在初始流之上）
BufferedReader
BufferedWriter
BufferedOutputStream
BufferedInputStream
PrintWriterPrintStream都屬於輸出流，分別針對字元，位元組，都屬於處理流
提供了過載的print println（）用於多種型別資料的輸出
println()用於多種資料型別的輸出
PrintWriter和PrintStream 不會丟擲異常，使用者通過檢測錯誤狀態獲取錯誤資訊。
PrintWriter PrintStream具有自動flush功能


Serializable介面 ，沒有方法，可以被序列化。標記的介面


某個物件需要被序列化，必須實現Serializable介面


處理流 ObjectInputStream讀一個物件
ObjectOutputStream 寫一個物件（該物件應該實現系列化）
public class TestObjectIo {
public static void main(String [] args){
T t = new T();
FileOutputStream  fos = new FileOutputStream("D:\\a.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(t);
oos.flush();
oos.close();


FileInputStream fis = new FileInputStream("D:\\a.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
T t = (T)ois.readObject();
System.out.println(t.i);
System.out.println(t.j);
System.out.println(t.k);
}
}


class T implements Serailizable{//該物件應該實現序列化
int i =1;
double j =2.0;
transient int k = 5;//透明的
}






externalizable介面//外部化（Serializable子介面）
readExternal(ObjectInput in)
writeExternal(ObjectOutput out)


InputStreamReader/OutputStreamWriter轉換流
把位元組轉換成字元，沒有把字元轉換成位元組的流。