通用容器類和總結

一、抽象容器類

一）AbstractCollection

提供了Collection接口的基礎實現，具體來說，實現了如下方法：

public boolean addAll(Collection<? extends E> c)
public boolean contains(Object o)
public boolean containsAll(Collection<?> c)
public boolean isEmpty()
public boolean remove(Object o)
public boolean removeAll(Collection<?> c)
 
public boolean retainAll(Collection<?> c)
public void clear()
public Object[] toArray()
public <T> T[] toArray(T[] a)
public String toString()

AbstractCollection不知道基礎數據是怎麽存儲的，它如何實現這些方法呢？

它依賴於如下更為基礎的方法：

public boolean add(E e)
public abstract int size();
public abstract Iterator<E> iterator();

add方法：

public boolean add(E e) {
    throw new UnsupportedOperationException();//如果子類集合是不可被修改的，則不用重寫該方法，使用默認實現就可以了，否則必須重寫
}

size()是抽象方法，iterator也是抽象方法。

二）AbstractList

提供了List接口的基本實現：

public boolean add(E e)
public boolean addAll(int index, Collection<? extends E> c)
public void clear()
public
 
 boolean equals(Object o)
public int hashCode()
public int indexOf(Object o)
public Iterator<E> iterator()
public int lastIndexOf(Object o)
public ListIterator<E> listIterator()
public ListIterator<E> listIterator(final int index)
public List<E> subList(int fromIndex, int toIndex)

abstrackList通過如下更為基礎的方法實現：

public abstract int size();
abstract public E get(int index);
public E set(int index, E element)
public void add(int index, E element)
public E remove(int index)
//set, add, remove默認實現都是拋出異常

另外，AbstrackList不需要實現叠代器類和相關方法，因為其內部已經實現了。

三）AbstractSequentialList

它是AbstractList子類，它實現了如下方法：

public void add(int index, E element)
public boolean addAll(int index, Collection<? extends E> c)
public E get(int index)
public Iterator<E> iterator()
public E remove(int index)
public E set(int index, E element)

它實現了根據索引位置進行操作的get,set,add,remove方法

這是通過重寫listIterator（）方法實現的。

public E get(int index) {
    try {
        return listIterator(index).next();
    } catch (NoSuchElementException exc) {
        throw new IndexOutOfBoundsException("Index: "+index);
    }
}

雖然AbstractSequentialLis 是AbstrackList的子類，但實現邏輯和用法上和Abstract正好相反。

Abstrack需要具體子類寫根據索引操作的方法get,set,add,remove,它提供了叠代器，但叠代器是

基於這些方法實現的。它假定子類可以高效地根據索引位置進行操作，適用於內部是隨機訪問類型

的存儲結構（如數組），比如ArrayList就繼承自AbstrackList。

AbstractSequentialList 需要具體子類重寫叠代器，它提供了根據索引的操作方法get,set,add,

remove,但這些方法是基於叠代器實現的。它適用於內部是順序訪問類型的存儲結構（如鏈表）。

四）AbstrackMap

AbstrackMap提供了Map接口的基礎實現：

public void clear()
public boolean containsKey(Object key)
public boolean containsValue(Object value)
public boolean equals(Object o)
public V get(Object key)
public int hashCode()
public boolean isEmpty()
public Set<K> keySet()
public void putAll(Map<? extends K, ? extends V> m)
public V remove(Object key)
public int size()
public String toString()
public Collection<V> values()

AbstractMap 實現這些方法依賴於更基礎的方法：

public V put(K key, V value)
//抽象方法，子類必須實現
public abstract Set<Entry<K,V>> entrySet();

定義了兩個公有的靜態內部類：

AbstractMap.SimpleEntry implements Entry<K,V>
//表示只讀的鍵值對
AbstractMap.SimpleImmutableEntry implements Entry<K,V>

二、Collections

一）查找和替換

1.二分查找

//二分查找
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
public static <T> int binarySearch(List<? extends T> list,T key, Comparator<? super T> c) 

二分查找要求List中的元素是從小到大排序的。如果是從大到小排序，

需要傳遞一個逆序Comparator對象，Collections提供了返回逆序Comparator的方法：

public static <T> Comparator<T> reverseOrder()
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

ArrayList<Integer> list = new ArrayList<>(Arrays.asList
        (new Integer[]{33, 22, 37, 88, 1, 8, 9}));
Collections.sort(list);
System.out.println(Collections.binarySearch(list, 22)); //3

2.查找最大最小值:

<T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
<T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
<T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
<T> T min(Collection<? extends T> coll, Comparator<? super T> comp)

3.查找元素出現次數：

public static int frequency(Collection<?> c, Object o)

4.在sourceList中查找targetList的位置：

public static int indexOfSubList(List<?> source, List<?> target)
public static int lastIndexOfSubList(List<?> source, List<?> target)

indexOfSubList 從頭開始查找，lastIndexOfList從結尾開始查找，沒有找到返回-1，

找到第一個匹配元素的索引位置。

5.查看兩個集合是否有交集：

public static boolean disjoint(Collection<?> c1, Collection<?> c2)//沒有返回true，有返回false

6.替換：

public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)//替換成功返回true

二）排序和調整順序

1.排序、交換位置與翻轉：

public static <T extends Comparable<? super T>> void sort(List<T> list)
public static <T> void sort(List<T> list, Comparator<? super T> c)

//交換元素位置
public static void swap(List<?> list, int i, int j)

//翻轉
public static void reverse(List<?> list)

2.隨機化重排：

public static void shuffle(List<?> list)
public static void shuffle(List<?> list, Random rnd)

Java筆記（十一）通用容器類和總結