隨筆檔案

所有的流在使用完畢時，都需要調用close方法進行關流，釋放資源。
由于流操作都會有異常，如果發(fā)生異常就有可能導致close方法不能被調用
所以，IO異常一定要處理，close方法寫在finally語句中
1.InputStream : 輸入字節(jié)流 方法： read()從流(關聯(lián)的設備)中讀一個字節(jié)
** int read(buf):從流中讀取n個字節(jié)放入緩沖區(qū)，方法會返回一個讀取字節(jié)的個數(shù) ips-->buf
讀到一個-1，說明讀到了流的末尾
 ------------------------------------------------------------------------------------------
|---FileInputStream: 重載的構造函數(shù)  (String fileName)  (File file)

2.OutputStream： 輸出字節(jié)流 :方法 write(int c)將一個字節(jié)寫入流  (byte)c
write(buf,offset,len)將指定字節(jié)數(shù)組的一部分寫入流。 buf-->ops
 -------------------------------------------------------------------------------------------
|---FileOutputStream: 重載的構造函數(shù) (Strng fileName) (String fileName, boolean append)
 append:指定數(shù)據(jù)是否追加到文件的末尾，默認是false，覆蓋原有的數(shù)據(jù)，
 設置為true，將數(shù)據(jù)追加到文件的末尾
3.Reader：輸入字符流 int read() 讀一個字符   int read(buf)  buf是char[]類型
|---FileReader:  FileReader = InputStreamReader(FileInputStream) 只做了一件事：解碼(父類在做)
4.Writer：輸出字符流 write(int c) (char)c \  write(String str)
|---|---FileWriter:  FileWriter = OutputStreamWriter(FileOutputStream) 只做了一件事：編碼

理解(會用)：
1.裝飾設計模式： 對原有的類的進行包裝，對方法進行增強
BufferedReader：實現(xiàn)緩沖的功能   創(chuàng)建包裝流對象的時候，必須組合一個被包裝的底層流
    增加了一個新方法 String readLine() 讀一行
|--LineNumberReader: 增加了行號功能，getLineNumber() 、setLineNumber()
BufferedWriter：實現(xiàn)了緩沖功能  new BufferedWriter(new FileWriter("1.txt");
    增加了新方法  newLine() 另起一行
BufferedInputStream：實現(xiàn)緩沖的功能
BufferedOutputStream：實現(xiàn)緩沖的功能

2.InputStreamReader： 轉換流   : 包裝，實現(xiàn)了編碼解碼的功能
new InputStreamReader(new FileInputStream("1.txt"));

3.使用包裝流包裝System.in，讀鍵盤方便，可以讀一行
BufferedReader br =
 new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
 
 
IO需要會寫的程序： BufferedReader和BufferedWriter包裝InputStream和OutputStream，讀一行寫一行

  BufferedReader和BufferedWriter包裝Reader和Writer
  BufferedInputStream和BufferedOutputStream包裝InputStream和OutputStream
  用基礎流讀寫，自定義數(shù)組作為緩沖區(qū)，實現(xiàn)拷貝
  
-------以下做一個總結:

io流:數(shù)據(jù)傳輸?shù)闹修D站-->IO流-->目的地

 IO流一般都是成對出現(xiàn)的,也就是說按照流的分向:輸入流-->輸出流
 IO流按照操作來分: 字節(jié)流-->字符流
 
一.字符流
基類:Reader(讀)Writer(寫)
|-Reader
 |--BufferedReader:對Reader進行了包裝,提供了緩沖區(qū)(8192),有ReadLine()方法
  構造函數(shù):BufferedReader(Reader r);
 |--InputStreamReader:轉換流:將字節(jié)流轉換成字符流:new InputStreamReader(System.in);
  |--FileReader:讀取文件的字符流,FileReader(File file) FileReader(String fileName);
|-Writer
 |--BufferedWriter:包裝流:常用的方法write(String s)、flush()刷新  newLine()換行
  構造函數(shù):BufferedWriter(Writer w);
 |--OutputStreamWriter:轉換流: new OutputStreamWriter(System.out);
  |--FileWriter:寫入文件,FileWriter(File file)  FileWriter(String fileName)
   FileWriter(File file,boolean append),FileWriter(String fileName,boolean append)
   當append為true,將寫入到文件的末尾處,當為false時,從文件開頭開始寫.就會覆蓋原來的.默認為false
   
二.字節(jié)流:
|-InputStream(輸入流)
 |--FileInputStream:讀取文件的字符流,和FileReader基本是一樣
 |--FilterInputStream:過濾流,一般不使用,只是針對了InputStream進行了包裝
  |--BufferedInputStream:包裝類:BufferedReader(InputStream in),提供緩存功能
  
|-OutputStream(輸出流)
 |--FileOutputStream:寫入文件的字符流,和FileWriter基本一樣
 |--FilterOutputStream
  |--BufferedOutputStream:包裝類:BufferedWriter(OutputStream out);
  
三.使用IO流必須要捕獲異常,原因在于我們必須要還資源(關閉流)

 1 FileWriter fw = null;
 2 try
 3 {
 4     fw = new FileWriter("src/1.txt");
 5 }
 6 catch(IOException e)
 7 {
 8     e.printStractTrace();
 9 }
10 finally
11 {
12     try{if(fw!=null)fw.close();}catch(IOException){e.printStackTrace();}
13 }

四.File文件類
1.構造方法:
File(File parnt,String child)
根據(jù)prent抽象路徑名和child路徑名字符串創(chuàng)建一個新的file實例.
File(String pathname)
通過將給定的路徑名字來創(chuàng)建一個新的file實例.
File(String parent, String child)
根據(jù) parent 路徑名字符串和 child 路徑名字符串創(chuàng)建一個新 File 實例.

2.常用方法:
isFile:判斷對象是否是一個標準文件
isDirectory:判斷對象是否為一個文件夾
isAbsolute:判斷是否為一個絕對路徑
exists:判斷對象指定的文件是否存在
createNewFile:根據(jù)對象的描述創(chuàng)建一個對象
getName:獲得文件名
getPath:獲得路徑名
getParent:獲得文件的父級抽象路徑
getAbsolutepath:獲得文件的絕對路徑名
mkdir:創(chuàng)建此抽象路徑指定的目錄,(只能在存在的文件夾下創(chuàng)建一個目錄)
mkdirs:創(chuàng)建此抽象路徑指定的目錄,包括所有必須但不存在的目錄.創(chuàng)建多級目錄(c:/a/b/c)
list(FilenameFilter filter)：根據(jù)指定過濾器遍歷文件夾中的所有文件，返回String[]
 如果對象為標準文件，則返回null，如果對象是一個空文件夾，則返回空數(shù)組。length為0
 FilenameFilter是一個接口，只有一個方法accept，我們需要實現(xiàn)接口的accept方法。
 實現(xiàn)類是給list方法自動調用的
 方法的參數(shù)是list方法傳給我們的，返回的結果也是給list方法去用。
listFiles：和list基本一樣，返回值類型不一樣，返回File[]。
常用案例：遍歷目錄下所有的文件和文件夾   拷貝一個文件夾  .

五:RandomAccessFile 文件流,可以讀寫
1.RandomAccessFile(File file,String mode)、RandomAccessFile(String fileName,String mode)
 mode:常用的: r,只讀 rw讀寫
2.有很多read和write方法.
 seek方法,指定從那個位置開始讀seek(0) ,從原有的位置覆蓋掉
skipBytes(int n)：跳過多少個字節(jié)

六:PrintStream、PrintWriter打印流
有一個特殊的方法print可以實現(xiàn)打印
write方法是直接將字節(jié)和字符寫出去
print：首先調用對象的toString方法轉成字符串(如果是基本數(shù)據(jù)類型，會先自動裝箱)
 再將字符串編碼成字節(jié)數(shù)組，調用write方法寫出去

七:SequenceInputStream序列流
可以將多個字節(jié)流組合起來
構造方法：SequenceInputStream(Enumeration<? extends InputStream> e) 
  //Enumeration可以通過Vector來獲得，如果用的是ArrayList，如何獲得呢？
     SequenceInputStream(InputStream in1,InputStream in2)

八:ObjectInputStream、ObjectOutputStream操作對象的字節(jié)流
一般成對出現(xiàn)
使用writeObject方法寫入的對象，只能由readObject方法讀出來
操作的對象必須實現(xiàn)java.io.Serializable序列化接口，該對象才可以被序列化和反序列化。
序列化: Java中規(guī)定的一種保存對象的數(shù)據(jù)格式

九:DataInputStream、DataOutputStream操作基本數(shù)據(jù)類型，格式化數(shù)據(jù)
readInt、writeInt等方法。
writeInt寫入一個整數(shù)，文件大小為4字節(jié)。證明就是把基本數(shù)據(jù)類型對應的字節(jié)寫出去了，沒有丟失精度

十:ByteArrayInputStream、ByteArrayOutputStream對Byte數(shù)組進行讀寫的字節(jié)流，針對內存進行讀寫
源和目的地都是內存，一般用于對內存中的數(shù)據(jù)進行處理。

十一:PipedInputStream、PipedOutputStream管道流
1、輸入管道流
構造方法：PipedInputStream(PipedOutputStream pos)實現(xiàn)拼接
也可以通過connect(PipedOutputStream pos)方法進行拼接

2、輸出管道流
構造方法：PipedOutputStream(PipedInputStream pis)實現(xiàn)拼接
也可以通過connect(PipedInputStream pis)方法進行拼接

 1 --Test:序列化與反序列化..
 2 package com.java.kudy_Say;
 3 
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.ObjectOutputStream;
 8 import java.io.Serializable;
 9 import java.util.ArrayList;
10 import java.io.ObjectInputStream;
11 import java.io.FileInputStream;
12 /*
13     序列化與反序列化的過程
14 */
15 public class Test {
16     
17     public static void main(String[]args) throws FileNotFoundException, IOException,ClassNotFoundException
18     {
19             
20 /*        Student s1 = new Student("張三",18);
21         Student s2 = new Student("王五",19);
22         Student s3 = new Student("李四",20);
23         Student s4 = new Student("大毛",21);
24         ObjectOutputStream oos = 
25                 new ObjectOutputStream(new FileOutputStream("f:/a.txt"));
26         ArrayList<Student> al = new ArrayList<Student>();
27         al.add(s1);
28         al.add(s2);
29         al.add(s3);
30         al.add(s4);
31         oos.writeObject(al);
32         oos.close();//關閉流
33         //首先我們把內容放到一個集合里面去
34 */
35         ObjectInputStream ois = 
36                 new ObjectInputStream(new FileInputStream("f:/a.txt"));
37         ArrayList<Student> al = (ArrayList<Student>)ois.readObject();
38         for(Student s :al)
39             System.out.println(s);
40         ois.close();
41     
42     
43         
44     }
45 }
46 
47 //必須要實現(xiàn)一個類
48 class Student implements Serializable
49 {
50     private String name;
51     private int age;
52     Student(){}
53     Student(String name,int age)
54     {
55         this.name = name;
56         this.age = age;
57     }
58     public String toString()
59     {
60         return name+"@"+age;
61     }
62 }