集合框架之線性表、棧、隊列、set、鍵值對Map、字符串、IO流、靜態類

 1. 線性表

1.1 java.util 接口 List

• 所有已知實現類：ArrayList, LinkedList, Vector, Stack
• 有序的 collection（也稱為序列）,與 set 不同，列表通常允許重復的元素

抽象方法

添加功能 add

• boolean add(E e): 將指定的元素追加到此列表的末尾。
• void add(int index, E element): 在列表的指定位置插入指定元素。
• boolean addAll(Collection<? extends E> c)：添加指定 collection 中的所有元素到此列表的結尾
• boolean addAll(int index, Collection<? extends E> c)：將指定 collection 中的所有元素都插入到列表中的指定位置

刪除功能 remove

• void clear()： 從列表中移除所有元素。
• E remove(int index)： 移除列表中指定位置的元素。
• boolean remove(Object o)： 從此列表中移除第一次出現的指定元素。
• boolean removeAll(Collection<?> c)： 從列表中移除指定 collection 中包含的其所有元素。

判斷功能 contains, equals, isEmpty

• boolean contains(Object o): 如果列表包含指定的元素，則返回 true。
• boolean containsAll(Collection<?> c): 如果列表包含指定 collection 的所有元素，則返回 true。
• boolean equals(Object o): 比較指定的對象與列表是否相等。
• boolean isEmpty(): 如果列表不包含元素，則返回 true。

獲取功能 get, indexOf, size, hashCode

• E get(int index): 返回列表中指定位置的元素。
• int hashCode(): 返回列表的哈希碼值。
• int indexOf(Object o): 返回此列表中第一次出現的指定元素的索引；如果此列表不包含該元素，則返回 -1。
• lastIndexOf(Object o): 返回此列表中最后出現的指定元素的索引；如果列表不包含此元素，則返回 -1。
• int size(): 返回列表中的元素數。
• List subList(int fromIndex, int toIndex): 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分視圖。

修改功能 set

• E set(int index, E element): 用指定元素替換列表中指定位置的元素。

迭代器功能 iterator

• Iterator iterator(): 返回按適當順序在列表的元素上進行迭代的迭代器。
• ListIterator listIterator(): 返回此列表元素的列表迭代器。

其他功能 toArray

• Object[] toArray()： 返回按適當順序包含列表中的所有元素的數組（從第一個元素到最后一個元素）。
• boolean retainAll(Collection<?> c)： 僅在列表中保留指定 collection 中所包含的元素。

注意事項

• 迭代器功能可用增強for替換： for(E e : list)
• 獲取長度為：int size()不是length()

• 集合和數組的區別?

  A:長度區別  
      數組固定  
      集合可變  
  B:內容區別  
      數組可以是基本類型，也可以是引用類型  
      集合只能是引用類型  
  

• 並發修改異常？

  A:出現的現象
      迭代器遍歷集合，集合修改集合元素
  B:原因
      迭代器是依賴於集合的，而集合的改變迭代器並不知道。
      Iterator在迭代時，只能對元素進行獲取next()和刪除remove()的操作。
  C:解決方案
      a:迭代器遍歷，迭代器修改(ListIterator)
          元素添加在剛才迭代的位置
      b:集合遍歷，集合修改(size()和get())
          元素添加在集合的末尾
  

1.2 java.util 類 ArrayList

• List 接口的大小可變數組的實現：transient Object[] elementData。
• 是隨機存取結構，查找塊，增刪慢
• 實現不是同步的，線程不安全

具體方法

構造方法

• public ArrayList(int initialCapacity):構造一個具有指定初始容量的空列表。
• public ArrayList():構造一個初始容量為 10 的空列表。
• public ArrayList(Collection<? extends E> c):構造一個包含指定 collection 的元素的列表。

特殊方法

• public Object clone()：返回此 ArrayList 實例的淺表副本。（不復制這些元素本身。）
• public void ensureCapacity(int minCapacity)：如有必要，增加此 ArrayList 實例的容量，以確保它至少能夠容納最小容量參數所指定的元素數。
• protected void removeRange(int fromIndex, int toIndex)：移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的所有元素。
• public void trimToSize()：將此 ArrayList 實例的容量調整為列表的當前大小。

1.3 java.util 類 LinkedList

• List 接口的鏈接列表實現，底層雙向列表實現。
• 不是隨機存取結構，查找慢，增刪快
• 此實現不是同步的，線程不安全

具體方法

構造方法

• public LinkedList():構造一個初始容量為 10 的空列表。
• public LinkedList(Collection<? extends E> c):構造一個包含指定 collection 的元素的列表。

棧方法

• public void push(E e)：將該元素插入此列表的開頭, 此方法等效於 addFirst(E)。
• public E pop()：移除並返回此列表的第一個元素, 此方法等效於 removeFirst()。

隊列方法

• boolean add(E e): 將指定的元素追加到此列表的末尾。
• public E peek()：獲取但不移除此列表的頭（第一個元素）。
• public E poll()：獲取並移除此列表的頭（第一個元素）。

特有方法

• public void addFirst(E e)
• public void addLast(E e)
• public E removeFirst()
• public E removeLast()
• public E getFirst()
• public E getLast()

1.4 java.util 類 Vector

• 可以實現可增長的對象數組：protected Object[] elementData;
• 是隨機存取結構，查找塊，增刪慢
• 實現是同步的，線程安全

特有方法

• public void addElement(E obj)：add()。
• public E elementAt(int index)：get()。
• public Enumeration elements()：iterator()。

1.5 綜合比較

    ArrayList
        底層數據結構是數組，查詢快，增刪慢。
        線程不安全，效率高。
    Vector
        底層數據結構是數組，查詢快，增刪慢。
        線程安全，效率低。
    LinkedList
        底層數據結構是鏈表，查詢慢，增刪快。
        線程不安全，效率高。

2. 棧和隊列

2.1 java.util 類 Stack

• 棧先進后出
• 繼承了Vector<E>集合，實現了List<E>接口
• 底層是可變長度數組，方法同步，線程安全。

具體方法push,pop,peek

構造方法

• public Stack()：創建一個空堆棧。

其他方法

• public boolean empty()：測試堆棧是否為空。
• public void push(E e)：把項壓入堆棧頂部。
• public E pop()：移除堆棧頂部的對象，並作為此函數的值返回該對象。
• public E peek()：查看堆棧頂部的對象，但不從堆棧中移除它。
• public int search(Object o)：返回對象在堆棧中的位置，棧頂計為1。

2.2 java.util 接口 Queue

• 隊列通常（但並非一定）以 FIFO（先進先出）的方式排序各個元素。
• 不過優先級隊列和 LIFO 隊列（或堆棧）例外，前者根據提供的比較器或元素的自然順序對元素進行排序，后者按 LIFO（后進先出）的方式對元素進行排序。。
• 繼承了Collection<E>接口
• 實現子類PriorityQueue<E>、ArrayDeque<E>、LinkedList<E>
• 子接口Deque<E>

	拋出異常	返回特殊值
插入	add(e)	offer(e)
移除	remove()	poll()
檢查	element()	peek()

抽象方法add,poll,peek

插入方法

• boolean add(E e)：將指定的元素插入此隊列，在成功時返回 true，如果當前沒有可用的空間，則拋出 IllegalStateException。
• boolean offer(E e)：將指定的元素插入此隊列，offer 方法設計用於正常的失敗情況，而不是出現異常的情況，例如在容量固定（有界）的隊列中。

移除方法

• E remove()：獲取並移除此隊列的頭，如果此隊列為空，拋出一個異常。
• E poll()：獲取並移除此隊列的頭，如果此隊列為空，則返回 null。

檢查方法

• E element()：獲取，但是不移除此隊列的頭。如果此隊列為空，拋出一個異常。
• E peek()：獲取但不移除此隊列的頭；如果此隊列為空，則返回 null。

2.3 java.util 類 PriorityQueue

• 實現了Collection<E>和Queue<E>接口
• 底層是由數組實現： transient Object[] queue
• 實現不是同步的，線程不安全
• 一個基於優先級堆的無界優先級隊列。
• 優先級隊列的元素按照其自然順序進行排序，或者根據構造隊列時提供的 Comparator 進行排序,具體取決於所使用的構造方法。
• 不允許使用 null 元素。

具體方法

構造方法

• public PriorityQueue()：使用默認的初始容量（11）創建一個 PriorityQueue，並根據其自然順序對元素進行排序。
• public PriorityQueue(int initialCapacity)：使用指定的初始容量創建一個 PriorityQueue，並根據其自然順序對元素進行排序。
• public PriorityQueue(int initialCapacity, Comparator<? super E> comparator)：使用指定的初始容量創建一個 PriorityQueue，並根據指定的比較器對元素進行排序。

插入方法

• boolean add(E e)：將指定的元素插入此優先級隊列。
• boolean offer(E e)：將指定的元素插入此優先級隊列。

移除方法

• E poll()：獲取並移除此隊列的頭，如果此隊列為空，則返回 null。
• public boolean remove(Object o)：從此隊列中移除指定元素的單個實例（如果存在）。

檢查方法

• E peek()：獲取但不移除此隊列的頭；如果此隊列為空，則返回 null。

其他方法

• public Comparator<? super E> comparator()：返回用來對此隊列中的元素進行排序的比較器；如果此隊列根據其元素的自然順序進行排序，則返回 null。

2.4 java.util 類 ArrayDeque

• 實現了Queue<E>接口和Deque<E>接口
• 名稱 deque 是“double ended queue（雙端隊列）”的縮寫，通常讀為“deck”。
• Deque 接口的大小可變數組的實現： transient Object[] elements
• 實現不是同步的，線程不安全
• 此類很可能在用作堆棧時快於 Stack，在用作隊列時快於 LinkedList。
• 方法類型幾乎等同於LinkedList
• Deque<E>接口、ArrayDeque<E>、LinkedList<E>方法幾乎相同，只是實現的方法不同。

2.5 綜合比較

• 比較Stack<E>先進后出、Queue<E>：先進先出
• 從底層實現、是否線程安全、適用場景方面，比較PriorityQueue<E>、ArrayDeque<E>、LinkedList<E>

	棧、隊列	底層實現	是否線程安全
LinkedList	棧、 隊列	鏈表	不安全
Stack	棧	數組	安全
ArrayDeque	雙端隊列（棧、隊列）	數組	不安全
PriorityQueue	優先隊列	數組	不安全

3. Set

3.1 java.util 接口 Set

• 一個不包含重復元素的 collection。
• 所有已知實現類：HashSet<E>、TreeSet<E>

抽象方法

添加功能 add

• boolean add(E e): 如果 set 中尚未存在指定的元素，則添加此元素。
• boolean addAll(Collection<? extends E> c)：如果 set 中沒有指定 collection 中的所有元素，則將其添加到此 set 中。

刪除功能 remove

• void clear()： 從列表中移除所有元素。
• boolean remove(Object o)： 移除此 set 中的所有元素。
• boolean removeAll(Collection<?> c)： 移除 set 中那些包含在指定 collection 中的元素。

判斷功能 contains, equals, isEmpty

• boolean contains(Object o): 如果 set 包含指定的元素，則返回 true。
• boolean containsAll(Collection<?> c): 如果此 set 包含指定 collection 的所有元素，則返回 true。
• boolean equals(Object o): 比較指定對象與此 set 的相等性。
• boolean isEmpty(): 如果列表不包含元素，則返回 true。

迭代器功能 iterator

• Iterator iterator(): 返回在此 set 中的元素上進行迭代的迭代器。

其他功能 size, toArray

• int size(): 返回列表中的元素數。
• int hashCode(): 返回列表的哈希碼值。
• Object[] toArray()： 返回按適當順序包含列表中的所有元素的數組（從第一個元素到最后一個元素）。
• boolean retainAll(Collection<?> c)： 僅在列表中保留指定 collection 中所包含的元素。

3.2 java.util 類 HashSet

    A:底層數據結構是哈希表(是一個元素為鏈表的數組)
    B:此類實現 Set 接口，由哈希表（實際上是一個 只使用了key成員變量的HashMap 實例）支持。
    C:實現不是同步的,線程不安全。
    D:哈希表底層依賴兩個方法：hashCode()和equals()
      執行順序：
        首先比較哈希值是否相同
            相同：繼續執行equals()方法
                返回true：元素重復了，不添加
                返回false：直接把元素添加到集合
            不同：就直接把元素添加到集合
    E:如何保證元素唯一性的呢?
        由hashCode()和equals()保證的
    F:如何解救hash沖突：鏈地址法
    G:開發的時候，自動生成即可。

具體方法（沒有特殊方法）

構造方法

• public HashSet()：構造一個新的空 set，其底層 HashMap 實例的默認初始容量是 16，加載因子是 0.75。
• public HashSet(int initialCapacity)：構造一個新的空 set，其底層 HashMap 實例具有指定的初始容量和默認的加載因子（0.75）。
• public HashSet(Collection<? extends E> c)：構造一個包含指定 collection 中的元素的新 set。
• public HashSet(int initialCapacity, float loadFactor)：構造一個新的空 set，其底層 HashMap 實例具有指定的初始容量和指定的加載因子。

3.3 java.util 類 TreeSet

    A:底層數據結構是紅黑樹(是一個自平衡的二叉樹，有指向left、right、parent的指針)
    B:基於 TreeMap 的 NavigableSet 實現。
    C:實現不是同步的,線程不安全。
    D:保證元素的排序方式
        a:自然排序(元素具備比較性)
            讓元素所屬的類實現Comparable接口
        b:比較器排序(集合具備比較性)
            讓集合構造方法接收Comparator的實現類對象

具體方法

構造方法

• public TreeSet()：構造一個新的空 set，該 set 根據其元素的自然順序進行排序。
• public TreeSet(Comparator<? super E> comparator)：構造一個新的空 TreeSet，它根據指定比較器進行排序。
• public HashSet(Collection<? extends E> c)：構造一個包含指定 collection 元素的新 TreeSet，它按照其元素的自然順序進行排序。

獲取方法

• public E ceiling(E e):返回此 set 中大於等於給定元素的最小元素；如果不存在這樣的元素，則返回 null。
• public E floor(E e):返回此 set 中小於等於給定元素的最大元素；如果不存在這樣的元素，則返回 null。
• public E higher(E e):返回此 set 中嚴格大於給定元素的最小元素；如果不存在這樣的元素，則返回 null。
• public E lower(E e):返回此 set 中嚴格小於給定元素的最大元素；如果不存在這樣的元素，則返回 null。
• public E first():返回此 set 中當前第一個（最低）元素。
• public E last():返回此 set 中當前最后一個（最高）元素。

刪除方法

• public E pollFirst():獲取並移除第一個（最低）元素；如果此 set 為空，則返回 null。
• public E pollLast():獲取並移除最后一個（最高）元素；如果此 set 為空，則返回 null。

3.4 綜合比較

唯一嗎?
    是：Set
        排序嗎?
            是：TreeSet
            否：HashSet
    如果你知道是Set，但是不知道是哪個Set，就用HashSet。

    否：List
        要安全嗎?
            是：Vector
            否：ArrayList或者LinkedList
                查詢多：ArrayList
                增刪多：LinkedList
    如果你知道是List，但是不知道是哪個List，就用ArrayList。

4. 鍵值對

4.1 java.util 接口 Map<K,V>

• 將鍵映射到值的對象。一個映射不能包含重復的鍵；每個鍵最多只能映射到一個值。
• Map 接口提供三種collection 視圖，允許以鍵集、值集或鍵-值映射關系集的形式查看某個映射的內容。
• 所有已知實現類：HashMap, Hashtable,TreeMap。
• Map和Collection的區別?
  A:Map 存儲的是鍵值對形式的元素，鍵唯一，值可以重復。
  B:Collection 存儲的是單獨出現的元素，子接口Set元素唯一，子接口List元素可重復。

嵌套類

• Map.Entry<K,V> 映射項（鍵-值對）：public static interface Map.Entry<K,V>
• Map.Entry<K,V>中 Entry<K,V> 為Map接口的內部接口，定義了數據類型為鍵值對。
• HashMap中Entry<K,V>實現並擴展了Map.Entry<K,V>，定義為元素為數組中的鏈表頭結點。
• TreeMap中Entry<K,V>實現並擴展了Map.Entry<K,V>，定義為元素為三叉鏈表，包含孩子和父指針。
• 其中設計采用了接口的內部接口，類的靜態內部類的方式。

抽象方法

添加功能 put

• V put(K key, V value):將指定的值與此映射中的指定鍵關聯,返回以前與 key 關聯的值，如果沒有針對 key 的映射關系，則返回 null。
• void putAll(Map<? extends K,? extends V> m)：從指定映射中將所有映射關系復制到此映射中。

刪除功能 remove

• void clear()：從此映射中移除所有映射關系。
• V remove(Object key)：如果存在一個鍵的映射關系，則將其從此映射中移除，返回此映射中以前關聯該鍵的值，如果此映射不包含該鍵的映射關系，則返回 null。

判斷功能 containsKey, containsValue

• boolean containsKey(Object key):如果此映射包含指定鍵的映射關系，則返回 true。
• boolean containsValue(Object value):如果此映射將一個或多個鍵映射到指定值，則返回 true。
• boolean equals(Object o):比較指定的對象與此映射是否相等。
• boolean isEmpty():如果此映射未包含鍵-值映射關系，則返回 true。

獲取功能 entrySet, keySet, values, get, size

• Set<Map.Entry<K,V>> entrySet():返回此映射中包含的映射關系的 Set 視圖，得到鍵值對。
• Set keySet()：返回此映射中包含的鍵的 Set 視圖。
• Collection values()：返回此映射中包含的值的 Collection 視圖。
• V get(Object key)：返回指定鍵所映射的值；如果此映射不包含該鍵的映射關系，則返回 null。
• int hashCode()：返回此映射的哈希碼值。
• int size()：返回此映射中的鍵-值映射關系數。如果該映射包含的元素大於 Integer.MAX_VALUE，則返回 Integer.MAX_VALUE。

知識擴展

Map集合的遍歷
    A:鍵找值
        a:獲取所有鍵的集合
        b:遍歷鍵的集合,得到每一個鍵
        c:根據鍵到集合中去找值

    B:鍵值對對象找鍵和值
        a:獲取所有的鍵值對對象的集合
        b:遍歷鍵值對對象的集合，獲取每一個鍵值對對象
        c:根據鍵值對對象去獲取鍵和值

    代碼體現：
        Map<String,String> hm = new HashMap<String,String>();

        hm.put("it002","hello");
        hm.put("it003","world");
        hm.put("it001","java");

        //方式1 鍵找值
        Set<String> set = hm.keySet();
        for(String key : set) {
            String value = hm.get(key);
            System.out.println(key+"---"+value);
        }

        //方式2 鍵值對對象找鍵和值
        Set<Map.Entry<String,String>> set2 = hm.entrySet();
        for(Map.Entry<String,String> me : set2) {
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+"---"+value);
        }

4.2 java.util 類 HashMap<K,V>

• 基於哈希表的 Map 接口的實現，HashSet集合也是基於HashMap實現。
• 底層數據結構是哈希表(是一個元素為鏈表的數組)。
• 此類為基本操作提供了穩定性能，這些基本操作包括 add、remove、contains 和 size。
• 此實現不是同步，線程不安全。
• 除了非同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。
• HashMap 的實例有兩個參數影響其性能：初始容量和加載因子。
• 默認加載因子 (0.75) 在時間和空間成本上尋求一種折衷。加載因子過高雖然減少了空間開銷，但同時也增加了查詢成本。

具體方法（參考Map即可）

嵌套類

• 類 AbstractMap.SimpleEntry<K,V> 映射項（鍵-值對）：public static class AbstractMap.SimpleEntry<K,V>
• 類 AbstractMap.SimpleImmutableEntry<K,V>：維護不可變的鍵和值的 Entry。此類不支持 setValue 方法。
• 均實現了Map.Entry<K,V>其中的方法，但沒有實際意義。因為HashMap和TreeMap中的Entry<K,V>是實現了Map.Entry<K,V>內部接口，並不是實現了AbstractMap中的內部類。

構造方法

• public HashMap()：構造一個映射關系與指定 Map 相同的新 HashMap。所創建的 HashMap 具有默認加載因子 (0.75) 和足以容納指定 Map 中映射關系的初始容量。
• public HashMap(int initialCapacity)：構造一個帶指定初始容量和默認加載因子 (0.75) 的空 HashMap。
• public HashMap(int initialCapacity, float loadFactor)：構造一個帶指定初始容量和加載因子的空 HashMap。
• public HashMap(Map<? extends K,? extends V> m)：構造一個映射關系與指定 Map 相同的新 HashMap。

4.3 java.util 類 TreeMap<K,V>

• 基於紅黑樹（Red-Black tree）的 NavigableMap 實現。
• 該映射根據其鍵的自然順序進行排序，或者根據創建映射時提供的 Comparator 進行排序，具體取決於使用的構造方法。
• 此實現為 containsKey、get、put 和 remove 操作提供受保證的 log(n) 時間開銷。
• 此實現不是同步，線程不安全。

具體方法

嵌套類（與hashMap相同）

構造方法

• public TreeMap()：使用鍵的自然順序構造一個新的、空的樹映射。
• public TreeMap(Comparator<? super K> comparator)：構造一個新的、空的樹映射，該映射根據給定比較器進行排序。
• public TreeMap(Map<? extends K,? extends V> m)：構造一個與給定映射具有相同映射關系的新的樹映射，該映射根據其鍵的自然順序 進行排序。

特殊方法（主要利用了tree結構中key的排序功能）

返回鍵值對

• public Map.Entry<K,V> ceilingEntry(K key)：返回一個鍵-值映射關系，它與大於等於給定鍵的最小鍵關聯；如果不存在這樣的鍵，則返回 null。
• public Map.Entry<K,V> floorEntry(K key)：返回一個鍵-值映射關系，它與小於等於給定鍵的最大鍵關聯；如果不存在這樣的鍵，則返回 null。
• public Map.Entry<K,V> higherEntry(K key)：返回一個鍵-值映射關系，它與嚴格大於給定鍵的最小鍵關聯；如果不存在這樣的鍵，則返回 null。
• public Map.Entry<K,V> lowerEntry(K key)：返回一個鍵-值映射關系，它與嚴格小於給定鍵的最大鍵關聯；如果不存在這樣的鍵，則返回 null。
• public Map.Entry<K,V> firstEntry()：返回一個與此映射中的最小鍵關聯的鍵-值映射關系；如果映射為空，則返回 null。
• public Map.Entry<K,V> lastEntry()：返回與此映射中的最大鍵關聯的鍵-值映射關系；如果映射為空，則返回 null。
• public Map.Entry<K,V> pollFirstEntry()：移除並返回與此映射中的最小鍵關聯的鍵-值映射關系；如果映射為空，則返回 null。
• public Map.Entry<K,V> pollLastEntry()：移除並返回與此映射中的最大鍵關聯的鍵-值映射關系；如果映射為空，則返回 null。

返回鍵

• public K ceilingKey(K key)：返回大於等於給定鍵的最小鍵；如果不存在這樣的鍵，則返回 null。
• public K floorKey(K key)：返回小於等於給定鍵的最大鍵；如果不存在這樣的鍵，則返回 null。
• public K higherKey(K key)：返回嚴格大於給定鍵的最小鍵；如果不存在這樣的鍵，則返回 null。
• public K lowerKey(K key)：返回嚴格小於給定鍵的最大鍵；如果不存在這樣的鍵，則返回 null。
• public K firstKey()：返回此映射中當前第一個（最低）鍵。
• public K lastKey()：返回映射中當前最后一個（最高）鍵。

4.4 java.util 類 Hashtable<K,V>

• 此類實現一個哈希表，該哈希表將鍵映射到相應的值。
• 同步，線程安全。

特殊方法（其余參考HashMap即可）

• public Enumeration elements()：返回此哈希表中的值的枚舉。
• public Enumeration keys()：返回此哈希表中的鍵的枚舉。
• protected void rehash()：增加此哈希表的容量並在內部對其進行重組，以便更有效地容納和訪問其元素。當哈希表中的鍵的數量超出哈希表的容量和加載因子時，自動調用此方法。

4.5 java.util 接口 Map.Entry<K,V>

• public static interface Map.Entry<K,V>，Map接口的內部接口。
• 定義了數據類型為映射項（鍵-值對）。

抽象方法 getKey, getValue, setValue

• boolean equals(Object o)：比較指定對象與此項的相等性。
• K getKey()：返回與此項對應的鍵。
• V getValue()：返回與此項對應的值。
• int hashCode()：返回此映射項的哈希碼值。
• V setValue(V value)：用指定的值替換與此項對應的值。

知識擴展

java中外部接口與內部接口的使用
新建一個非抽象類（普通類）實現接口如下：
1、普通類實現了接口，那么就必須實現接口中的所有方法
2、那么反過來沒有實現接口中的方法的類就是抽象類
3、一個類可以實現多個接口
這里用內部類的好處就是： 
1、當你只實現外部接口，那么只需實現外部接口的方法即可（內部接口是調不到的）。
2、而實現內部接口的方式是“外部接口.內部接口”，那么就可以實現內部接口的方法了。通過這個方法，可以將外部接口和內部接口分開實現，一般內部接口中的方法只在 3、內部接口也是一種數據類型。

參考鏈接：https://www.jianshu.com/p/ab539e9a7955

4.6 java.util 類 AbstractMap.SimpleEntry<K,V>

• 是AbstractMap的內部類，實現了 Map.Entry<K,V>
• 維護鍵和值的 Entry。可以使用 setValue 方法更改值。
• 具體方法看 Map.Entry<K,V>即可。

4.7 綜合比較

	底層實現	是否線程安全
HashMap<K,V>	hash表（元素為鏈表的數組）	不安全
TreeMap<K,V>	樹（三叉鏈表）	不安全
Hashtable<K,V>	hash表（元素為鏈表的數組）	安全

 

5. 字符串

5.1 java.lang 類 String

• 字符串是常量,它們的值在創建之后不能更改。
• 底層是由數組實現：private final char value[]; 由final修飾，只能賦一次值。
• 多個字符組成的一串數據。
• 字面值作為字符串對象（變量指向main方法區）和通過構造方法創建對象（變量指向堆內存，堆內存再指向main方法區）的不同。
  String s = new String("hello"); 和String s = "hello"不同。

具體方法

構造方法 byte[], char[]

• public String()：初始化一個新創建的 String 對象，使其表示一個空字符序列。
• public String(byte[] bytes)：通過使用平台的默認字符集解碼指定的 byte 數組，構造一個新的 String。注意這個得到了是數字對應的字符，A-Z 65-90，a-z 97-122。
• public String(byte[] bytes,int offset,int length)：通過使用平台的默認字符集解碼指定的 byte 子數組，構造一個新的 String。
• public String(char[] value)：通過使用平台的默認字符集解碼指定的 byte 數組，構造一個新的 String。
• public String(char[] value,int offset,int count)：分配一個新的 String，它包含取自字符數組參數一個子數組的字符。
• public String(String original)：初始化一個新創建的 String 對象，使其表示一個與參數相同的字符序列。

判斷方法 contains, equals, equalsIgnoreCase, startsWith, endsWith, isEmpty

• boolean contains(String str)：當且僅當此字符串包含指定的 char 值序列時，返回 true。
• boolean equals(Object obj)：將此字符串與指定的對象比較。
• boolean equalsIgnoreCase(String str)：將此 String 與另一個 String 比較，不考慮大小寫。
• boolean startsWith(String str)：測試此字符串是否以指定的前綴開始。
• public boolean startsWith(String prefix, int toffset)：測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
• boolean endsWith(String str)：測試此字符串是否以指定的后綴結束。
• boolean isEmpty()：當且僅當 length() 為 0 時返回 true。
• public boolean matches(String regex):告知此字符串是否匹配給定的正則表達式。

獲取方法 length, charAt, indexOf, substring, split

• int length():返回此字符串的長度。
• char charAt(int index):返回指定索引處的 char 值。
• int indexOf(int ch):返回指定字符在此字符串中第一次出現處的索引。
• int indexOf(int ch,int fromIndex):返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
• int indexOf(String str)：返回指定子字符串在此字符串中第一次出現處的索引。
• int indexOf(String str,int fromIndex)：返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。
• public int lastIndexOf(int ch):返回指定字符在此字符串中最后一次出現處的索引。
• public int lastIndexOf(String str):返回指定子字符串在此字符串中最右邊出現處的索引。
• String substring(int start)：返回一個新的字符串，它是此字符串的一個子字符串。
• String substring(int start,int end)：返回一個新字符串，它是此字符串的一個子字符串。
• public String[] split(String regex):根據給定正則表達式的匹配拆分此字符串。
• public String[] split(String regex,int limit):根據匹配給定的正則表達式來拆分此字符串。limit 參數控制模式應用的次數，因此影響所得數組的長度。

轉換方法 getBytes, toCharArray, valueOf, toLowerCase, toUpperCase

• byte[] getBytes()： 使用平台的默認字符集將此 String 編碼為 byte 序列，並將結果存儲到一個新的 byte 數組中。
• char[] toCharArray()：將此字符串轉換為一個新的字符數組。
• static String valueOf(char[] chs)：返回 char 數組參數的字符串表示形式。
• static String valueOf(int i)：返回 int 參數的字符串表示形式。
• String toLowerCase():使用默認語言環境的規則將此 String 中的所有字符都轉換為小寫。
• String toUpperCase():使用默認語言環境的規則將此 String 中的所有字符都轉換為大寫。
• String concat(String str):將指定字符串連接到此字符串的結尾,用‘+’即可。

替換功能 replace

• String replace(char old,char new):返回一個新的字符串，它是通過用 newChar 替換此字符串中出現的所有 oldChar 得到的。
• String replace(String old,String new):使用指定的字面值替換序列替換此字符串所有匹配字面值目標序列的子字符串。

其他方法 trim

• String trim()： 返回字符串的副本，忽略前導空白和尾部空白。
• int compareTo(String str)：按字典順序比較兩個字符串。
• int compareToIgnoreCase(String str)：按字典順序比較兩個字符串，不考慮大小寫。

5.2 java.lang 類 StringBuffer

• 線程安全的可變字符序列。
• private transient char[] toStringCache;底層由可變數組實現。
• StringBuffer 上的主要操作是 append 和 insert 方法，可重載這些方法，以接受任意類型的數據。

具體方法

構造方法

• StringBuffer()：構造一個其中不帶字符的字符串緩沖區，其初始容量為 16 個字符。
• StringBuffer(int capacity)：構造一個不帶字符，但具有指定初始容量的字符串緩沖區。
• StringBuffer(String str)：構造一個字符串緩沖區，並將其內容初始化為指定的字符串內容。

添加方法 append, insert

• public StringBuffer append(String str)：將指定的字符串追加到此字符序列。其中String可以是其余數據類型。
• public StringBuffer insert(int offset, String str):將字符串插入此字符序列中。

刪除方法 delete

• public StringBuffer delete(int start, int end)：移除此序列的子字符串中的字符。該子字符串從指定的 start 處開始，一直到索引 end - 1 處的字符。
• public StringBuffer deleteCharAt(int index)：移除此序列指定位置的 char。此序列將縮短一個 char。

替換方法 replace

• public StringBuffer replace(int start, int end, String str)：使用給定 String 中的字符替換此序列的子字符串中的字符。

反轉方法 reverse

• public StringBuffer reverse()：將此字符序列用其反轉形式取代。

獲取方法 substring, toString

• public String substring(int start)：返回一個新的 String，它包含此字符序列當前所包含的字符子序列。
• public String substring(int start, int end):返回一個新的 String，它包含此序列當前所包含的字符子序列。
• public String toString():返回此序列中數據的字符串表示形式。

5.3 java.lang 類 StringBuilder

• 一個可變的字符序列。此類提供一個與 StringBuffer 兼容的 API，但不保證同步。
• 在 StringBuilder 上的主要操作是 append 和 insert 方法，可重載這些方法，以接受任意類型的數據。
• 如果可能，建議優先采用該類，因為在大多數實現中，它比 StringBuffer 要快。

具體方法(與StringBuffer相同）

5.4 綜合比較

• String提供對字符串串聯符號（"+"）以及將其他對象轉換為字符串的特殊支持。
• StringBuilder（或 StringBuffer）類及其 append 方法實現的。字符串轉換是通過 toString 方法實現。
• 比較String與StringBuffer或StringBuilder的不同
  StringBuffer和StringBuilder長度和內容可變，做字符串的拼接不會浪費太多的資源。
  StringBuffer：同步的，數據安全，效率低。
  StringBuilder：不同步的，數據不安全，效率高。

6. IO流

(1)IO用於在設備間進行數據傳輸的操作    
(2)分類：
    A:流向
        輸入流 讀取數據
        輸出流 寫出數據
    B:數據類型
        字節流 
                字節輸入流
                字節輸出流
        字符流
                字符輸入流
                字符輸出流

（3）IO流
    |--字節流
        |--字節輸入流
            InputStream
                int read():一次讀取一個字節
                int read(byte[] bys):一次讀取一個字節數組

                |--FileInputStream
                |--BufferedInputStream
        |--字節輸出流
            OutputStream
                void write(int by):一次寫一個字節
                void write(byte[] bys,int index,int len):一次寫一個字節數組的一部分

                |--FileOutputStream
                |--BufferedOutputStream
    |--字符流 （是由字節流和編碼表組成，因此字符流的層次關系較字節流多一層)
        |--字符輸入流
            Reader
                int read():一次讀取一個字符
                int read(char[] chs):一次讀取一個字符數組

                |--InputStreamReader
                    |--FileReader （相當於FileInputStreamReader，但是太長了，因此用FileReader來表示）    
                |--BufferedReader
                    String readLine():一次讀取一個字符串
        |--字符輸出流
            Writer
                void write(int ch):一次寫一個字符
                void write(char[] chs,int index,int len):一次寫一個字符數組的一部分

                |--OutputStreamWriter
                    |--FileWriter
                |--BufferedWriter
                    void newLine():寫一個換行符                       
                    void write(String line):一次寫一個字符串

注意事項

• 當用字節流read()方法將文本文件中的漢字輸出到控制台會出現錯誤，但是當 write(int by)寫入到文本文件中則沒有問題
  • read()方法每次只獲取到一個字節數據，就把該字節數據轉換為了字符數據，然后輸出到控制台，但是漢字最少由2個字節數組組成。
  • write(int by)寫入到文本文件中，會自己做轉換。
• 字符流FileReader和FileWriter拷貝圖片或者音頻文件會出錯。
  • 發現丟失了信息。
  • 圖片本來就是二進制文件，不需要進行編碼。
• 字節流是通用的流，可用於任何類型的對象，包括二進制流對象和漢字字符，而字符流只能處理字符或者字符串。
  • 但是用字節流處理字符有可能出現編碼表不匹配等問題，因為采用的是默認編碼表。
  • 用字節流輸出字符到控制台時候，不能一次只讀取一個字節，因為字符是多個字節組成。
  • 用字符流處理字符更高效，使用了緩沖區，並且可以選擇編碼表類型。
• 何時使用字符流，何時使用字節流？依據是什么？
  • 使用字符流的應用場景：如果是讀寫字符數據的時候則使用字符流，打開文檔能看懂。
  • 使用字節流的應用場景：如果是讀寫的數據都不需要轉換成字符的時候，則使用字節流，打開文檔看不懂的。
• 字節流默認不使用緩沖區；字符流使用緩沖區。

6.1 java.io 類 File

• 文件和目錄路徑名的抽象表示形式。

具體方法

構造方法（接收String和File參數）

• public File(String pathname)：通過將給定路徑名字符串轉換為抽象路徑名來創建一個新 File 實例，file = new File("e:\demo\a.txt");
• public File(String parent, String child)：根據 parent 抽象路徑名和 child 路徑名字符串創建一個新 File 實例，file = new File("e:\demo","a.txt");
• public File(File parent, String child)：根據 parent 抽象路徑名和 child 路徑名字符串創建一個新 File 實例，File file2 = new File(file,"a.txt");

創建功能 createNewFile, mkdirs

• public boolean createNewFile() throws IOException：當且僅當不存在具有此抽象路徑名指定名稱的文件時，不可分地創建一個新的空文件。
• public boolean mkdir()：創建此抽象路徑名指定的目錄。
• public boolean mkdirs()：創建此抽象路徑名指定的目錄，包括所有必需但不存在的父目錄。

刪除功能 delete

• public boolean delete()：刪除此抽象路徑名表示的文件或目錄。如果此路徑名表示一個目錄，則該目錄必須為空才能刪除。

重命名功能 renameTo

• public boolean renameTo(File dest)：重新命名此抽象路徑名表示的文件。

判斷功能 isDirectory, isFile, exists, canRead, canWrite

• public boolean isDirectory()：測試此抽象路徑名表示的文件是否是一個目錄。
• public boolean isFile()：測試此抽象路徑名表示的文件是否是一個標准文件。
• public boolean exists()：測試此抽象路徑名表示的文件或目錄是否存在。
• public boolean isHidden()：測試此抽象路徑名指定的文件是否是一個隱藏文件。
• public boolean canRead()：測試應用程序是否可以讀取此抽象路徑名表示的文件。
• public boolean canWrite()：測試應用程序是否可以修改此抽象路徑名表示的文件。

獲取功能 getAbsolutePath, getPath, list

• public String getAbsolutePath()：返回此抽象路徑名的絕對路徑名字符串。
• public String getPath()：獲取相對於當前目錄下的相對路徑。
• public String getName()：返回由此抽象路徑名表示的文件或目錄的名稱。
• public long length()：返回由此抽象路徑名表示的文件的長度。
• public long lastModified()：返回此抽象路徑名表示的文件最后一次被修改的時間。
• public String[] list()：返回一個字符串數組，這些字符串指定此抽象路徑名表示的目錄中的文件和目錄。
• public File[] listFiles()：返回一個抽象路徑名數組，這些路徑名表示此抽象路徑名表示的目錄中的文件。

過濾器功能

• public String[] list(FilenameFilter filter)：返回一個字符串數組，這些字符串指定此抽象路徑名表示的目錄中滿足指定過濾器的文件和目錄。
• public File[] listFiles(FilenameFilter filter)：返回抽象路徑名數組，這些路徑名表示此抽象路徑名表示的目錄中滿足指定過濾器的文件和目錄。

6.2 java.io 類 InputStream

• 此抽象類是表示字節輸入流的所有類的超類。
• 實現子類FileInputStream

抽象方法 read, close

• public abstract int read() throws IOException：從輸入流中讀取數據的下一個字節。
• public int read(byte[] b) throws IOException：從輸入流中讀取一定數量的字節，並將其存儲在緩沖區數組 b 中。
• public int read(byte[] b, int off, int len) throws IOException:將輸入流中最多 len 個數據字節讀入 byte 數組。
• public void close() throws IOException：關閉此輸入流並釋放與該流關聯的所有系統資源。
• public void mark(int readlimit)：在此輸入流中標記當前的位置。
• public void reset() throws IOException：將此流重新定位到最后一次對此輸入流調用 mark 方法時的位置。

6.2 java.io 類 FileInputStream

• 為InputStream字節流的實現子類
• FileInputStream 從文件系統中的某個文件中獲得輸入字節。
• FileInputStream 用於讀取諸如圖像數據之類的原始字節流。
• 要讀取字符流，請考慮使用 FileReader。

構造方法（方法查看InputStream即可）

• public FileInputStream(File file) throws FileNotFoundException:通過打開一個到實際文件的連接來創建一個 FileInputStream，該文件通過文件系統中的 File 對象 file 指定。
• public FileInputStream(String name) throws FileNotFoundException:通過打開一個到實際文件的連接來創建一個 FileInputStream，該文件通過文件系統中的路徑名 name 指定。

6.3 java.io 類 InputStreamReader

• 為Reader字符流的實現子類
• InputStreamReader 是字節流通向字符流的橋梁。
• 每次調用 InputStreamReader 中的一個 read() 方法都會導致從底層輸入流讀取一個或多個字節。
• 為了達到最高效率，可要考慮在 BufferedReader 內包裝 InputStreamReader。

構造方法（方法查看InputStream即可）

• public InputStreamReader(InputStream in):創建一個使用默認字符集的 InputStreamReader。
• public InputStreamReader(InputStream in, String charsetName):指定編碼。

6.4 java.io 類 BufferedReader

• 為Reader字符流的實現子類
• 從字符輸入流中讀取文本，緩沖各個字符，從而實現字符、數組和行的高效讀取。
• 可以指定緩沖區的大小，或者可使用默認的大小。大多數情況下，默認值就足夠大了。
• 建議用 BufferedReader 包裝所有其 read() 操作可能開銷很高的 Reader（如 FileReader 和 InputStreamReader）。
  • BufferedReader in = new BufferedReader(new FileReader("foo.in"));
  • BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

構造方法

• public BufferedReader(Reader in):創建一個使用默認大小輸入緩沖區的緩沖字符輸入流。
• public BufferedReader(Reader in, int sz):創建一個使用指定大小輸入緩沖區的緩沖字符輸入流。

特殊方法 readLine（其余參考InputStream即可）

• public String readLine()：讀取一個文本行。通過下列字符之一即可認為某行已終止：換行 ('\n')、回車 ('\r') 或回車后直接跟着換行。

6.5 java.io 類 OutputStream

• 此抽象類是表示輸出字節流的所有類的超類。
• 實現子類 FileOutputStream

抽象方法 write, flush, close

• public abstract void write(int b)：將指定的字節寫入此輸出流。
• public void write(byte[] b)：將 b.length 個字節從指定的 byte 數組寫入此輸出流。
• public void write(byte[] b, int off, int len)：將指定 byte 數組中從偏移量 off 開始的 len 個字節寫入此輸出流。
• public void flush()：刷新此輸出流並強制寫出所有緩沖的輸出字節。
• public void close()：關閉此輸出流並釋放與此流有關的所有系統資源。

6.6 java.io 類 FileOutputStream

• 為OutputStream字節流的實現子類。
• FileOutputStream 用於寫入諸如圖像數據之類的原始字節的流。
• 要寫入字符流，請考慮使用 FileWriter。

構造方法（方法查看OutputStream即可）

• public FileOutputStream(File file):創建一個向指定 File 對象表示的文件中寫入數據的文件輸出流。
• public FileOutputStream(File file, boolean append):如果第二個參數為 true，則將字節寫入文件末尾處，而不是寫入文件開始處。
• public FileOutputStream(String name)：創建一個向具有指定名稱的文件中寫入數據的輸出文件流。
• public FileOutputStream(String name, boolean append)：如果第二個參數為 true，則將字節寫入文件末尾處，而不是寫入文件開始處。

6.7 java.io 類 OutputStreamWriter

• 為Writer字符流的實現子類
• OutputStreamWriter 是字符流通向字節流的橋梁。
• 每次調用 write() 方法都會導致在給定字符（或字符集）上調用編碼轉換器。
• 為了獲得最高效率，可考慮將 OutputStreamWriter 包裝到 BufferedWriter 中，以避免頻繁調用轉換器。
  • Writer out = new BufferedWriter(new OutputStreamWriter(System.out));

構造方法（方法查看InputStream即可）

• OutputStreamWriter(OutputStream out) :創建使用默認字符編碼的 OutputStreamWriter。
• public OutputStreamWriter(OutputStream out, String charsetName):指定編碼。

6.8 java.io 類 BufferedWriter

• 為Writer字符流的實現子類
• 將文本寫入字符輸出流，緩沖各個字符，從而提供單個字符、數組和字符串的高效寫入。
• 可以指定緩沖區的大小，或者可使用默認的大小。大多數情況下，默認值就足夠大了。
• 建議用 BufferedWriter 包裝所有其 write() 操作可能開銷很高的 Writer（如 FileWriters 和 OutputStreamWriters）。
  • PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));
  • Writer out = new BufferedWriter(new OutputStreamWriter(System.out));

構造方法

• public BufferedWriter(Writer out):創建一個使用默認大小輸出緩沖區的緩沖字符輸出流。
• public BufferedWriter(Writer out, int sz):創建一個使用給定大小輸出緩沖區的新緩沖字符輸出流。

特殊方法 newLine（其余參考OutputStream即可）

• public void newLine()：寫入一個行分隔符。

7. 靜態類

7.1 java.util 類 Arrays

• 此類包含用來操作數組（比如排序和搜索）的各種方法。
• 此類還包含一個允許將數組作為列表來查看的靜態工廠。

靜態方法 binarySearch, sort, toString

• public static int binarySearch(int[] a, int key)：使用二分搜索法來搜索指定的 int 型數組，以獲得指定的值。
• public static void sort(int[] a)：對指定的 int 型數組按數字升序進行排序。該排序算法是一個經過調優的快速排序法。
• public static String toString(int[] a)：返回指定數組內容的字符串表示形式。
• public static boolean equals(int[] a, int[] a2)：如果兩個指定的 int 型數組彼此相等，則返回 true。

7.2 java.util 類 Collections

• 此類完全由在 collection 上進行操作或返回 collection 的靜態方法組成。

二分查找方法 binarySearch,

• public static int binarySearch(List<? extends Comparable<? super T>> list, T key)：使用二分搜索法搜索指定列表，以獲得指定對象。在進行此調用之前，必須根據列表元素的自然順序對列表進行升序排序（通過 sort(List) 方法）。如果列表包含多個等於指定對象的元素，則無法保證找到的是哪一個。
• public static int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)：使用二分搜索法搜索指定列表，以獲得指定對象。在進行此調用之前，必須根據指定的比較器對列表進行升序排序（通過 sort(List, Comparator) 方法）。

排序方法 sort

• public static <T extends Comparable<? super T>> void sort(List list)：根據元素的自然順序 對指定列表按升序進行排序。列表中的所有元素都必須實現 Comparable 接口。此外，列表中的所有元素都必須是可相互比較的。
• public static void sort(List list, Comparator<? super T> c)：根據指定比較器產生的順序對指定列表進行排序。

最值方法 max, min

• public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)：根據元素的自然順序，返回給定 collection 的最大元素。collection 中的所有元素都必須實現 Comparable 接口。此外，collection 中的所有元素都必須是可相互比較的。
• public static T max(Collection<? extends T> coll, Comparator<? super T> comp)：根據指定比較器產生的順序，返回給定 collection 的最大元素。
• public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)：根據元素的自然順序 返回給定 collection 的最小元素。
• public static T min(Collection<? extends T> coll, Comparator<? super T> comp)：根據指定比較器產生的順序，返回給定 collection 的最小元素。

同步方法

• public static Collection synchronizedCollection(Collection c)：返回指定 collection 支持的同步（線程安全的）collection。
• public static List synchronizedList(List list)：返回指定列表支持的同步（線程安全的）列表。
• public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)：返回由指定映射支持的同步（線程安全的）映射。
• public static Set synchronizedSet(Set s)：返回指定 set 支持的同步（線程安全的）set。

其他方法 shuffle, reverse

• public static void shuffle(List<?> list)：使用默認隨機源對指定列表進行置換。
• public static void reverse(List<?> list)：反轉指定列表中元素的順序。
• public static boolean replaceAll(List list, T oldVal, T newVal)：使用另一個值替換列表中出現的所有某一指定值。

知識拓展

Collection和Collections的區別
    A:Collection 是單列集合的頂層接口，有兩個子接口List和Set
    B:Collections 是針對集合進行操作的工具類，可以對集合進行排序和查找等