第二周

• 2020 年 9 月 12 日
• 筆記
• Java複習

第二周（08/10~08/15）

內部類和匿名類

內部類是指在一個類的內部定義其他類，稱為內部類。

內部類：

• 內部類當中可以調用外部類當中的屬性和方法，而外部類卻不能調用內部類當中的。

• 內部類的類體中不可以聲明類變數和類方法，內部類可以由外部類使用外部類中在函數中創建內部類對象來使用，如果內部類 的許可權是非私有，非靜態的，就可以在外部其他程式中被訪問 到，就可以通過創建外部類對象完成；如果內部類是靜態的，非私有的，靜態成員可以直接類名調用，非靜態成員通過創建外部類對象使用。

• 內部類的位元組碼文件會不一樣。會變成外部類名$內部類名

匿名類：

• 匿名類，就是沒有名稱的類，其名稱由Java編譯器給出，一般是形如：外部類名稱+$+匿名類順序，沒有名稱也就是其他地方就不能引用，不能實例化，只用一次，當然也就不能有構造器。

• 匿名類就是利用父類的構造函數和自身類體構造成一個類。

• 格式 new 父類( ){子類內容}；

  上面格式中的「父類」是子類需要繼承或者實現外部的類或者介面

• 匿名類可以繼承父類的方法，也可以重寫父類的方法。

• 匿名類可以訪問外部類的成員變數和方法，匿名類的類體不可以聲明稱static成員變數和static方法。

• 匿名類由於是一個new的結果，所以其實可以賦值給一個父類對象。因此可以分為兩種匿名類，成員匿名類和局部匿名類（作為函數參數）

匿名內部類：

• 匿名是因為匿名內部類的具體名字不會被我們在程式當眾編寫出來，因為它已經在主方法當中被實例化了。

• 匿名內部類可以繼承兩類數據結構：

  一：抽象類

  二：介面。

異常

異常就是程式在編譯時發生的意想不到的情況，一般而言分為兩類:錯誤(Error)和異常(Exception)

Exception異常分為編譯時異常和運行時異常，由於我們無法預測程式里可能出現的錯誤或用戶在使用程式時會出現的錯誤，所以需要異常類來告訴我們程式出現了異常

java 中的異常資訊主要是調用 Throwable 的幾個方法進行處理的，主要的方法有：

printStackTrace()，getMessage()，getStackTrace()方法。

異常的捕獲:

異常的捕獲需要用到try-catch語法結構

try…catch…finally 結構

該結構對異常捕獲和處理的形式如下：

try{

//此處放可能產生錯誤的程式碼

}catch(異常類名 1 異常對象名 1){

//此處放處理異常對象 1 的程式碼

} catch(異常類名 2 異常對象名 2){

//此處放處理異常對象 2 的程式碼

}finally{

//必須執行的程式碼

}

1. 如果拋出的異常被捕獲了，程式會繼續執行，而不會終止運行。

2. try塊里的程式碼如果拋出異常，則try塊里的程式碼不會繼續執行，而是轉到catch塊里執行。

3. 一個try可以對應多個catch，catch的規則應該是先catch子類異常，後catch父類異常，且一個異常只會被catch一次

4. 所有異常都繼承自Exception，所以在最後catch一下Exception是一個好習慣

5. 運行時異常也可以被catch

throw 語句

通常情況下，異常是由系統自動拋出的。但程式設計師也可以自己通過 throw 語句拋出異

常。throw 語句拋出異常的格式如下：

throw new 異常類名(異常描述);

其中異常類名為系統異常類名或用戶自定義異常類名。

如果一個方法沒有捕獲可能觸發的異常，調用該方法的其它方法應該捕獲並處理該異常。

為了明確某個方法不能捕獲某個異常，而讓調用該方法的其它方法捕獲異常，可以在方法聲

明的時候，使用 throws 可選項拋出該類異常。其聲明的格式如下

[修飾符] 返回值類型 方法名(參數列表) throws 異常類型名{

方法體

}

即在方法聲明的後面添加 throws 異常類型名。

throws，表明可以拋出多個異常，多個異常用逗號隔開 throws拋出的異常不一定會被拋出，throws只是負責向外拋這個方法捕獲到的異常，不負責判斷這個異常到底有沒有被捕獲到，所以throws後面可以隨便寫 但是，throws後面必須包含本方法可能被拋出的異常，除非這個異常在本方法內已經被捕獲了或者這個異常是運行時異常

public boolean equals(Object obj)

equals 方法應該實現的功能是將當前對象（this）與傳入對象進行比較，返回比較結果。

返回值為 boolean 類型，相等返回 true，否則返回 false。傳入的參數代表比較對象，將其

與當前對象（this）的內容進行比較。一般來說應該按照如下規則實現 equals 方法：

\1. 首先判斷傳入對象是否為 null，如果為 null 返回 false。

\2. 判斷傳入對象與當前對象是否為同一類型（通過 instanceof 關鍵字），如果不是返

回 false。

\3. 判斷當前對象與傳入對象的內容。

StringBuffer和StringBuilder的區別

共同之處:都是final類,不允許被繼承，主要是從性能和安全性上考慮的，因為這幾個類都是經常被使用著，且考慮到防止其中的參數被參數修改影響到其他的應用

區別主要是在兩個方面，即運行速度和執行緒安全這兩方面

運行速度，或者說是執行速度，**在這方面運行速度快慢為：StringBuilder > StringBuffer

在執行緒安全上，StringBuilder是執行緒不安全的，而StringBuffer是執行緒安全的。如果一個StringBuffer對象在字元串緩衝區被多個執行緒使用時，StringBuffer中很多方法可以帶有synchronized關鍵字，所以可以保證執行緒是安全的，但StringBuilder的方法則沒有該關鍵字，所以不能保證執行緒安全，有可能會出現一些錯誤的操作。所以如果要進行的操作是多執行緒的，那麼就要使用StringBuffer，但是在單執行緒的情況下，還是建議使用速度比較快的StringBuilder。。

集合

Collection

Collection集合的方法： boolean add(E e) 在集合末尾添加元素 boolean remove(Object o) 若本類集中有值與o的值相等的元素，則刪除該元素，返回ture void clear()清楚本類集中所有元素，調用晚該方法之後本類集將為空 boolean contains(Object o)判斷集合中是否包含某元素 boolean isEmpty()判斷集合是否為空 int size()返回集合中的元素個數 boolean addAll(Collection c)將一個類集c中的所有元素添加到另一一個類集 Object[] toArray() 返回一個包含了本類集中的所有元素的數組，數組類型為:Object[] Iterator iterartor() 迭代器，集合的專用遍歷方式

List

List集合是一個元素有序（每個元素都有對應的順序索引，第一個元素索引為零），且可重複的集合。存取順序一致 List是Collection介面的子介面，擁有Collection所有方法外，還有一些對索引操作的方法。

void add(int index, E element);：將元素element插入到List集合的index處；

boolean addAll(int index, Collection<? extends E> c);：將集合c所有的元素都插入到List集合的index起始處；

E remove(int index);：移除並返回index處的元素；

int indexOf(Object o);：返回對象o在List集合中第一次出現的位置索引；

int lastIndexOf(Object o);：返回對象o在List集合中最後一次出現的位置索引；

E set(int index, E element);：將index索引處的元素替換為新的element對象，並返回被替換的舊元素；

E get(int index);：返回集合index索引處的對象；

List<E> subList(int fromIndex, int toIndex);：返回從索引fromIndex（包含）到索引toIndex（不包含）所有元素組成的子集合；

void sort(Comparator<? super E> c)：根據Comparator參數對List集合元素進行排序；

void replaceAll(UnaryOperator<E> operator)：根據operator指定的計算規則重新設置集合的所有元素。

ListIterator<E> listIterator();：返回一個ListIterator對象，該介面繼承了Iterator介面，在Iterator介面基礎上增加了以下方法，具有向前迭代功能且可以增加元素:

Arrylist

ArrayList 類提供了快速的基於索引的成員訪問方式，對尾部成員的增加和刪除支援較好。使用 ArrayList 創建的集合，允許對集合中的元素進行快速的隨機訪問

特點：排列有序，可重複；底層使用數組；速度快，增刪慢，getter()和setter()方法塊；執行緒不安全；當容量不夠時，ArrayList當前容量*1.5+1

常用的ArrayList類成員方法：

• 增加元素到鏈表中

  • boolean add(Element e) 增加指定元素到鏈表尾部.

  • void add(int index, Element e) 增加指定元素到鏈表指定位置.

• 從鏈表中刪除元素

  • void clear() 從鏈表中刪除所有元素.

  • E remove(int index) 刪除鏈表中指定位置的元素.

  • protected void removeRange(int start, int end) 刪除鏈表中從某一個位置開始到某一個位置結束的元素。

• 獲取鏈表中的元素

  • E get(int index) 獲取鏈表中指定位置處的元素.

  • Object[] toArray() 獲取一個數組，數組中所有元素是鏈表中的元素.（即將鏈錶轉換為一個數組）

• 修改某個元素

  • E set(int index, E element) 將鏈表中指定位置上的元素替換成新元素。

• 搜索元素

  • boolean contains(Object o) 如果鏈表包含指定元素，返回true.

  • int indexOf(Object o) 返回元素在鏈表中第一次出現的位置，如果返回-1，表示鏈表中沒有這個元素。

  • int lastIndexOf(Object o) 返回元素在鏈表中最後一次出現的位置，如果返回-1，表示鏈表中沒有這個元素。

• 檢查鏈表是否為空

  • boolean isEmpty() 返回true表示鏈表中沒有任何元素.

• 獲取鏈表大小

  • int size() 返回鏈表長度（鏈表包含元素的個數）.

Vector

特點：排列有序，可重複；底層使用數組；速度快，增刪慢；執行緒安全，效率低；當容量不夠時，Vector默認擴展一倍容量

Vector的四種構造方法：

1、Vector(); 構造一個空向量，使其內部數據數組的大小為10，其標準容量增量為零。 Vector vec=new Vector();

2、Vector(Collection c); 構造一個包含指定collection中的元素的向量，這些元素按其collection的迭代器返回元素的順序排列。 Vector v=new Vector(vec);

3、Vector(int initialCapacity); 使用指定的初始容量和等於零的容量增量構造一個空向量。

4、Vector(int initialCapacity,int capacityIncrement); 使用指定的初始容量和容量增量構造一個空的向量。 Vector類中的方法：

1、boolean add(E e); 將指定的元素添加到此向量的末尾。

2、void addElement(E obj); 將指定的組件添加到此向量的末尾，將其大小增加1。

3、void add(int indext,E e); 在此向量的指定位置插入指定的元素。

4、boolean addAll(Collection c); 將指定Collection中的所有元素添加到此向量的末尾，按照指定collection的迭代器所返回的順序添加這些元素。

5、boolean addAll(int index,Collection c); 在指定位置將指定Collection中的所有元素插入到此向量中。

6、int capacity(); 返回此向量的當前容量。

7、Object clone(); 返迴向量的一個副本。

8、boolean contains(Object o); 如果此向量包含指定的元素，怎返回true。

9、boolean containsAll(Collection c); 如果此向量包含Collection中的所有元素，則返回true。

10、void copyInto(Object[] anArray); 將此向量的組件複製到指定的數組中。

11、E elementAt(int index); 返回指定索引處的組件。

12、Enumeration<E> elements(); 返回此向量的組件的枚舉。

13、void ensureCapacity(int minCapacity); 增加此向量的容量(如有必要),以確保其至少能夠保證最小容量參數指定的組件數。

14、boolean equals(Object o); 比較指定對象與此向量的相等性。

16、E lastelement(); 返回此向量的最後一個組件。程式碼略。

17、E get(int index); 返迴向量中指定位置 的元素。

18、int hashCode(); 返回此向量的哈希碼值。

19、int indexOf(Object o,int index); 返回此向量中第一次出現的指定的元素的索引，從index處正向索引，如果未找到該元素，則返回-1.

20、int indexOf(Object o); 返回此向量中第一次出現的指定元素的索引，如果此向量不包含該元素，則返回-1。

21、int lastIndexOf(Object o,int index); 返回此向量中最後一次出現的指定元素的索引，從index處逆向搜索，如果未找到該元素，則返回-1.

22、int lastIndexOf(Object o); 返回此向量中最後一次出現的指定元素的索引，如果此向量不包含該元素，則返回-1。

23、boolean isEmpty(); 測試此向量是否不包含組件。

24、void clear(); 從此向量中移除所有元素。

25、E remove(int index); 移除此向量中指定位置的元素

26、boolean remove(Object o); 移除此向量中指定元素的第一個匹配項，如果向量不包含該元素，則元素保持不變。

27、boolean removeAll(Collection c); 從此向量中移除包含在指定Collection中的所有元素。

28、void removeAllElements(); 從此向量中移除全部組件，並將其大小設置為零。

29、boolean removeElement(Object obj); 從此向量中移除變數的第一個(索引最小的)匹配項。

30、void removeElementAt(int index); 刪除指定索引處的組件。

31、protected void removeRange(int fromIndex,int toIndex); 從此list中移除位於formIndex(包括)與toIndex(不包括)之間的所有元素。

32、boolean retainAll(Collection c); 在此向量中僅保留包含在指定Collection中的元素。

LinkedList

LinkedList 類採用鏈表結構保存對象，這種結構的優點是便於向集合中插入或者刪除元素。需要頻繁向集合中插入和刪除元素時，使用 LinkedList 類比 ArrayList 類效果高

特點 ：排列有序，可重複；底層使用雙向鏈表循環數據結構；查詢速度慢，增刪快；add()和remove()方法快；執行緒不安全

構造方法

1. LinkedList<類> list = new LinkedList<類>();

2. LinkedList<類> list = new LinkedList(Collection<? extends E> c); 使用一個集合創建一個新的linkedList。

常用方法

1.增

• public boolean add(E e)，鏈表末尾添加元素，返回是否成功；

• public void add(int index, E element)，向指定位置插入元素；

• public boolean addAll(Collection<? extends E> c)，將一個集合的所有元素添加到鏈表後面，返回是否成功；

• public boolean addAll(int index, Collection<? extends E> c)，將一個集合的所有元素添加到鏈表的指定位置後面，返回是否成功；

• public void addFirst(E e)，添加到第一個元素；

• public void addLast(E e)，添加到最後一個元素；

• public boolean offer(E e)，向鏈表末尾添加元素，返回是否成功；

• public boolean offerFirst(E e)，頭部插入元素，返回是否成功；

• public boolean offerLast(E e)，尾部插入元素，返回是否成功；

2.刪

• public void clear()，清空鏈表；

• public E removeFirst()，刪除並返回第一個元素；

• public E removeLast()，刪除並返回最後一個元素；

• public boolean remove(Object o)，刪除某一元素，返回是否成功；

• public E remove(int index)，刪除指定位置的元素；

• public E poll()，刪除並返回第一個元素；

• public E remove()，刪除並返回第一個元素；

3.查

• public boolean contains(Object o)，判斷是否含有某一元素；

• public E get(int index)，返回指定位置的元素；

• public E getFirst(), 返回第一個元素；

• public E getLast()，返回最後一個元素；

• public int indexOf(Object o)，查找指定元素從前往後第一次出現的索引；

• public int lastIndexOf(Object o)，查找指定元素最後一次出現的索引；

• public E peek()，返回第一個元素；

• public E element()，返回第一個元素；

• public E peekFirst()，返回頭部元素；

• public E peekLast()，返回尾部元素；

4.改

• public E set(int index, E element)，設置指定位置的元素；

5.遍歷

 for (int size = linkedList.size(), i = 0; i < size; i++) {
            System.out.println(linkedList.get(i));
        }
        for (String str: linkedList) {
            System.out.println(str);
        }
        Iterator iter = linkedList.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }

Set

Set中的元素是不能重複的，如果使用add(Object obj)方法添加已經存在的對象，則會覆蓋前面的對象。存儲順序無序

Hashset

HashSet 類是按照哈希演算法來存儲集合中的元素，使用哈希演算法可以提高集合元素的存儲速度，當向 Set 集合中添加一個元素時，HashSet 會調用該元素的 hashCode() 方法，獲取其哈希碼，然後根據這個哈希碼計算出該元素在集合中的存儲位置,

特點：排列無序，不可重複；底層使用Hash表實現；記憶體速度快，內部是HashMap

HashSet的一些常用方法：

添加元素：

hashset.add(E e)：返回boolean型，如果此 set 中尚未包含指定元素，則添加指定元素；如果此 set 已包含該元素，則該調用不更改 set 並返回 false。

刪除元素：
hashset.clear()：從此 set 中移除所有元素。
hashset.remove(Object o)：如果指定元素存在於此 set 中，則將其移除。
hashset.isEmpty()：如果此 set 不包含任何元素，則返回 true。
hashset.contains(Object o)：如果此 set 包含指定元素，則返回 true。
hashset.size()：返回此 set 中的元素的數量（set 的容量）。

TreeSet

TreeSet 類同時實現了 Set 介面和 SortedSet 介面。SortedSet 介面是 Set 介面的子介面，可以實現對集合升序排序。TreeSet 只能對實現了 Comparable 介面的類對象進行排序，因為 Comparable 介面中有一個 compareTo(Object o) 方法用於比較兩個對象的大小

特點：排列無序，不可重複；底層使用二叉樹實現；排序存儲；內部是TreeMap的SortedSet

LinkedHashSet

特點 ：採用hash表存儲，並用雙向鏈表記錄插入數據；內部是LinkedHashMap;

Map

特點：Map集合中的鍵是唯一的；Map集合中的值是可以重複的

兩種遍歷方法

第一種方法：使用keySet()

這種方法遍歷了2次，一次是轉為iterator，另一次是從HashMap中取出key所對應的value。

(1) For-Each

    Set <String> keys = map.keySet();  //map.keySet()返回key的集合
    for(String key:keys) {
        System.out.println(key+":"+map.get(key));  //map.get(key)返回key所對應的value值
    }
1234

(2) 迭代器

    Set <String> keys = map.keySet();
    Iterator<String> it = keys.iterator();
    String key;
    while (it.hasNext()) {
        key = it.next();
        System.out.println(key+":"+map.get(key));                         
    }
1234567

第二種方法：使用entrySet()

這種方法只遍歷了1次,它把key和value都放到了entry中，因此比keySet()快。

(1) For-Each

    Set<Entry<String,String>> entrySet = map.entrySet();  //map.entrySet()返回<key,value>鍵值對的集合
    for (Entry<String,String> entry:entrySet) {
        System.out.println(entry.getKey()+":"+entry.getValue());  //entry.getKey()返回key,entry.getValue()返回value
    }
1234

(2) 迭代器

    Set<Entry<String,String>> entrySet = map.entrySet();
    Iterator<Entry<String,String>> it = entrySet.iterator();
    Entry<String,String> entry;
    while (it.hasNext()) {
        entry = it.next();
        System.out.println(entry.getKey()+":"+entry.getValue());
    }

關於文件的類——File類

public class File implements Serializable, Comparable<File>

File類實現了Serializable(序列化)和Comparable(可比較)介面

File類對象是文件和目錄路徑名的抽象表示形式。

File類的構造器:

常用方法:

public boolean exists()

測試此抽象路徑名表示的文件或目錄是否存在。

public boolean createNewFile()
                      throws IOException

當且僅當不存在具有此抽象路徑名指定名稱的文件時，不可分地創建一個新的空文件。檢查文件是否存在，若不存在則創建該文件，這是單個操作，對於其他所有可能影響該文件的文件系統活動來說，該操作是不可分的

返回：

如果指定的文件不存在並成功地創建，則返回 true；如果指定的文件已經存在，則返回 false

//String getName() 獲取文件名

//String getAbsolutePath() 獲取絕對路徑

//boolean isFile() 是否是文件

//boolean isDirectory() 是否是目錄(文件夾)

//boolean delete() 刪除文件

//long length() 獲取文件內容的長度(其實就是文件大小)

IO流的體系

抽象基類里的InputStream和以及訪問文件的FileInputStream

位元組流和字元流的區別:

單位的區別，位元組流以位元組為單位進行輸入輸出，字元流以字元為單位進行輸入輸出。

位元組對應的類是Byte(基本數據類型是byte)，字元對應的類是Character(基本數據類型是char)

InputStream

public abstract class InputStream implements Closeable 

InputStream是一個抽象類，所以 不能直接new對象

然後，InputStream實現了一個介面Closeable，顧名思義就是可關閉的，

Closeable

public interface Closeable extends AutoCloseable {

    public void close() throws IOException;

}

Closeable繼承自AutoCloseable介面，並且聲明了一個方法close()

public interface AutoCloseable {

    void close() throws Exception;

}

1.流的概念及分類

Java將所有傳統的流模型(類或抽象類)，都放在了Java.io包中，用來實現輸入輸出的功能。

這裡面我們將流分成兩種：輸入流和輸出流。

輸入流：只能從中讀取數據，而不能向其寫入數據。代表：InputStream(位元組輸入流),Reader(字元輸入流)。

輸出流：只能向其寫入數據，而不能從中讀取數據。代表：OutputStream(位元組輸出流),Writer(字元輸出流)。

流按照操作類型也可以分成兩種：

位元組流 : 位元組流可以操作任何數據,因為在電腦中任何數據都是以位元組的形式存儲的 。它操作的數據單元是8位的位元組。

字元流 : 字元流只能操作純字元數據，比較方便。它操作的數據單元是16位的字元。

從Java程式指向文件，這個過程我們稱為輸出或者寫入文件，從文件指向Java程式，這個過程我們稱為輸入或者讀出文件。

在輸入流和輸出流中，我們主要掌握4個流文件的操作：InputStream,OutputStream,Reader,Writer。這四個類都是抽象類，前兩個代表了位元組的輸入輸出流，後兩個代表字元的輸入輸出流，當我們調用的時候通常使用他們的子類來實現我們的類方法。

2.位元組輸出流(OutputStream)

位元組輸出流它有以下幾個方法可以提供給它的子類使用(在輸入輸出流中，子類幾乎沒什麼方法，都是調用父類的方法)

• void close(): 關閉此輸出流並釋放與此流有關的所有系統資源。

• void write(byte[] b)： 將 b.length 個位元組從指定的 byte 數組寫入此輸出流

• void write(byte[] b, int off, int len) ：將指定 byte 數組中從偏移量 off 開始的 len 個位元組寫入此輸出流。

• abstract void write(int b) ： 將指定的位元組寫入此輸出流。

由於OutputStream是抽象類，因此我們在向文件寫入(輸出)位元組的時候，需要用到它的子類FileOutputStream,接下來通過使用上面的方法，來實現位元組流的輸出操作。

關於FileOutputStream:

(1).寫入數據文件，通過使用父類的方法，調用子類的對象

(2).FileOutputStream構造方法：

• 作用：綁定輸出的輸出目的

• FileOutputStream(File file)

  • 創建一個向指定 File 對象表示的文件中寫入數據的文件輸出流。

• FileOutputStream(File file, boolean append)

  • 創建一個向指定 File 對象表示的文件中寫入數據的文件輸出流，以追加的方式寫入。

• FileOutputStream(String name)

  • 創建一個向具有指定名稱的文件中寫入數據的輸出文件流。

• FileOutputStream(String name, boolean append)

  • 創建一個向具有指定 name 的文件中寫入數據的輸出文件流，以追加的方式寫入。

(3).流對象的使用步驟:

　　1).創建流子類的對象，綁定數據目的。

　　2).調用流對象的方法write寫

　　3).close釋放資源

(4).注意事項：流對象的構造方法，可以用來創建文件，如果文件存在的情況下，直接覆蓋原文件。

3.位元組輸入流(InputStream)

位元組輸入流它有以下幾個方法可以提供給它的子類使用(在輸入輸出流中，子類幾乎沒什麼方法，都是調用父類的方法)

• abstract int read() ： * 從輸入流中讀取數據的下一個位元組，返回-1表示文件結束

• int read(byte[] b) * 從輸入流中讀取一定數量的位元組，並將其存儲在緩衝區數組 b 中。讀入緩衝區的位元組總數，如果因為已經到達文件末尾而沒有更多的數據，則返回 -1。

• int read(byte[] b, int off, int len) * 將輸入流中最多 len 個數據位元組讀入 byte 數組。 * void close() * 關閉此輸入流並釋放與該流關聯的所有系統資源。

由於InputStream是抽象類，因此我們在從文件讀取(輸入)位元組的時候，需要用到它的子類FileInputStream,接下來通過使用上面的方法，來實現位元組流的輸入操作。

關於FileInputStream:

在使用FileInputStream創建對象的時候，我們也需要為這個類綁定數據源(我們要讀取的文件名)

FileInputStream的構造方法與上述的構造方法相似，裡面的參數有兩種類型：File類型對象,String類型對象。

輸入流讀取文件的操作步驟：

(1).創建位元組輸入流的子類對象

(2).調用讀取方法read讀取

(3).關閉資源

注意事項：read()方法每執行一次，就會自動的讀取下一個位元組。它的返回值是讀取到的位元組，如果沒有位元組可以讀取了，那麼返回-1。

4.字元輸出流(Writer)

由於Writer也是一個抽象類，因此我們用它的子類FileWriter來實現字元流的輸出操作。

關於FileWriter:

(1).方法介紹：

　　void write(int c):寫入單個字元。

　　void write(String str):寫入字元串。

　　void write(String str, int off, int len):寫入字元串的某一部分。

　　void write(char[] cbuf):寫入字元數組。

　　abstract void write(char[] cbuf, int off, int len):寫入字元數組的某一部分。

5.字元輸入流(Reader)

由於Reader也是一個抽象類，因此我們用它的子類FileReader來實現字元流的輸出操作。

(1)方法介紹：

　　 int read() * 讀取單個字元

　　 int read(char[] cbuf) * 將字元讀入數組

　　 abstract int read(char[] cbu f, int off, int len) * 將字元讀入數組的某一部分。

字元流的輸入輸出與位元組流的差不多，但是字元流只能操作文本文件，不能操作除了文本文件以外的文件，而位元組流可以操作文本文件以及音樂，影片等文件，因此在平時的IO流中，我們使用位元組流的操作更多一些。

6.文件的複製操作。(這裡面我使用位元組流的方式實現)

文件的複製操作簡單的說就是將一個文件上的內容讀取出來，並且將讀取到的內容寫入到另一個文件上，因此在文件的複製操作中，需要使用文件的輸入和輸出流操作。