Java集合框架

集合框架體系圖

Java集合框架位於java.util包下

短虛線框表示接口,長虛線框表示抽象類,實線框表示類

帶三角箭頭的實線表示繼承關係,由子類指向父類

帶三角箭頭的虛線表示實現,由類指向接口

帶實箭頭的虛線表示依賴關係

右下角的Collections和Arrays是工具類

Iterable

Iterable是一個接口,實現該接口代表自身可迭代,核心在於實現接口方法iterator()返回一個迭代器

接口方法

default void forEach(Consumer<? super T> action) 
//對 Iterable的每一個元素執行給定的操做，直到全部元素都被處理或動做引起異常。  
Iterator<T> iterator() 
//返回類型爲 T元素的迭代器。  
default Spliterator<T> spliterator() 
//在Iterable描述的元素上建立一個Iterable 。

Iterator

Iterator是一個接口,定義了遍歷集合類的基本方法(由方法能夠看出只能支持簡單的單向遍歷)

由圖中能夠看出Collection依賴於Iterator,也就是說實現了接口Collection的類都是可迭代對象

接口方法

default void forEachRemaining(Consumer<? super E> action) 
//對每一個剩餘元素執行給定的操做，直到全部元素都被處理或動做引起異常。  
boolean hasNext() 
//若是迭代具備更多元素，則返回 true 。  
E next() 
//返回迭代中的下一個元素。  
default void remove() 
//從底層集合中刪除此迭代器返回的最後一個元素（少用）。

ListIterator

ListIterator是Iterator的子接口,在Iterator的基礎上容許任意方向的遍歷,而且能夠獲取迭代位置和添加對象

由圖中能夠看出List依賴於ListIterator,也就是說實現接口List的類都是可進行上述迭代的對象

接口方法

void add(E e) 
//將指定的元素插入列表。  
boolean hasNext() 
//返回 true若是遍歷正向列表，列表迭代器有多個元素。  
boolean hasPrevious() 
//返回 true若是遍歷反向列表，列表迭代器有多個元素。  
E next() 
//返回列表中的下一個元素，而且前進光標位置。  
int nextIndex() 
//返回隨後調用 next()返回的元素的索引。  
E previous() 
//返回列表中的上一個元素，並向後移動光標位置。  
int previousIndex() 
//返回由後續調用 previous()返回的元素的索引。  
void remove() 
//從列表中刪除由 next()或 previous()返回的最後一個元素（可選操做）。  
void set(E e) 
//用 指定的元素替換由 next()或 previous()返回的最後一個元素（可選操做）。

集合框架爲何選擇實現Interable接口

• 若是實現Interator接口
  • Interator接口核心方法next()和hasNext()依賴於迭代器的迭代位置,爲了解決這個問題在集合對象中勢必要包含迭代位置,
  • 迭代後迭代位置是未知的,那麼有須要一個reset()方法來重置迭代位置
  • 除此以外這種方法不支持多個迭代器並行迭代(不得不說這種解決方法缺陷很大)
• 若是實現Interable接口
  • 集合對象不包含迭代位置,下降了耦合度
  • 集合對象的迭代依賴於iterator()返回的迭代器,多個迭代器互不干擾,也就是說解決了迭代位置的未知性和不可並行迭代的問題

Collection

public interface Collection<E>
extends Iterable<E>

集合Collection是一個接口,高度抽象了集合應該有的共性方法,實現了Iterable接口

部分接口方法

boolean add(E e) 
//先集合中添加一個元素    
void clear() 
//刪除集合中全部元素  
boolean contains(Object o) 
//判斷集合中是否包含元素o    
boolean equals(Object o) 
//將指定的對象與此集合進行比較以得到相等性。  
int hashCode() 
//返回此集合的哈希碼值。  
boolean isEmpty() 
//若是此集合不包含元素，則返回 true 。  
Iterator<E> iterator() 
//返回此集合中的元素的迭代器。  。  
boolean remove(Object o) 
//從該集合中刪除指定元素的單個實例（若是存在）（可選操做）。    
int size() 
//返回此集合中的元素數。  
Object[] toArray() 
//返回一個包含此集合中全部元素的數組。

AbstractCollection

public abstract class AbstractCollection<E>
extends Object
implements Collection<E>

AbstractCollection是一個抽象類,實現了Collection的許多常見方法,繼承起來更爲方便(不用一一實現Collection中的方法)

抽象方法

abstract Iterator<E> iterator() 
//返回包含在該集合中的元素的迭代器。   
abstract int size() 
//返回此集合中的元素數。

List

public interface List<E>
extends Collection<E>

List接口也稱爲有序序列,用戶能夠經過整數索引操做元素

由圖中能夠看出List依賴於ListIterator,也就是說實現接口List的類支持ListIterator的迭代方法

特有方法

E get(int index) 
//返回此列表中指定位置的元素。
int indexOf(Object o) 
//返回此列表中指定元素的第一次出現的索引，若是此列表不包含元素，則返回-1。
ListIterator<E> listIterator() 
//返回列表中的列表迭代器。
ListIterator<E> listIterator(int index) 
//表中的指定位置開始，返回列表中的元素（按正確順序）的列表迭代器。 
E remove(int index) 
//該列表中指定位置的元素（可選操做）。 
E set(int index, E element) 
//定的元素替換此列表中指定位置的元素。 
List<E> subList(int fromIndex, int toIndex) 
//此列表中指定的 fromIndex （含）和 toIndex之間的視圖。

AbstractList

public abstract class AbstractList<E>
extends AbstractCollection<E>
implements List<E>

AbstractList是一個抽象類,在AbstractCollection的基礎上又實現了一些List的方法

抽象方法

abstract E get(int index) 
//返回此列表中指定位置的元素。

AbstractSequentialList

public abstract class AbstractList<E>
extends AbstractCollection<E>
implements List<E>

AbstractSequentialList也是抽象類,顧名思義底層是鏈表

抽象方法

abstract E get(int index) 
//返回此列表中指定位置的元素。

List子類對比

List子類	底層	線程安全
ArrayList	數組	否
Vector	數組	是
LinkedList	鏈表	否

• 查詢多用ArrayList
• 增刪多用LinkedList
• 若是都多ArrayList

Map

public interface Map<K,V>

Map也就是鍵值對,該接口定義了全部map的共性方法

Map值能夠重複,但鍵不能夠重複.

部分接口方法

void clear() 
//從該地圖中刪除全部的映射。  
boolean containsKey(Object key) 
//若是此映射包含指定鍵的映射，則返回 true 。  
boolean containsValue(Object value) 
//若是此地圖將一個或多個鍵映射到指定的值，則返回 true 。  
Set<Map.Entry<K,V>> entrySet() 
//返回此地圖中包含的映射的Set視圖。  
boolean equals(Object o) 
//將指定的對象與此映射進行比較以得到相等性。  
V get(Object key) 
//返回到指定鍵所映射的值，或 null若是此映射包含該鍵的映射。    
int hashCode() 
//返回此地圖的哈希碼值。  
boolean isEmpty() 
//若是此地圖不包含鍵值映射，則返回 true 。  
Set<K> keySet() 
//返回此地圖中包含的鍵的Set視圖。  
V remove(Object key) 
//若是存在，從該地圖中刪除一個鍵的映射。  
int size() 
//返回此地圖中鍵值映射的數量。  
Collection<V> values() 
//返回此地圖中包含的值的Collection視圖。

AbstractMap

public abstract class AbstractMap<K,V>
extends Object
implements Map<K,V>

AbstractMap是一個抽象類,實現了許多Map接口的方法

抽象方法

abstract Set<Map.Entry<K,V>> entrySet() 
//返回此地圖中包含的映射的Set視圖。

SortedMap

public interface SortedMap<K,V>
extends Map<K,V>

SortedMap接口在Map基礎之上進行排序,要實現此功能必須實現Comparable接口

部分接口方法

Comparator<? super K> comparator() 
//返回用於訂購此地圖中的鍵的比較器，或null若是此地圖使用其鍵的natural ordering 。  
K firstKey() 
//返回此地圖中當前的第一個（最低）鍵。  
SortedMap<K,V> headMap(K toKey) 
//返回該地圖的部分密鑰嚴格小於 toKey 。  
Set<K> keySet() 
//返回此地圖中包含的鍵的Set視圖。  
K lastKey() 
//返回當前在此地圖中的最後（最高）鍵。  
SortedMap<K,V> subMap(K fromKey, K toKey) 
//返回此地圖部分的視圖，其關鍵字範圍爲 fromKey （含），不 toKey toKey。  
SortedMap<K,V> tailMap(K fromKey) 
//返回此地圖部分的視圖，其鍵大於或等於 fromKey 。

Map子類對比

Map子類	線程安全	迭代順序	存取效率
HashMap	否	規律	O(1)
TreeMap	否	天然順序	Olog(n)
LinkedhashMap	否	插入順序	O(1)

能夠用 Collections的synchronizedMap方法使HashMap具備同步的能力，或者使用ConcurrentHashMap。

Hashtable是線程安全的,但效率低

Set

public interface Set<E>
extends Collection<E>

Set不包含重複元素,也不存在索引,元素的插入順序可能和實際順序無關

其實Set很大一部分依賴於Map,Map去掉值就是Map

//HashSet的構造函數
public HashSet() {
        map = new HashMap<>();
}

部分接口方法

boolean add(E e) 
//若是指定的元素不存在，則將其指定的元素添加.  
void clear() 
//今後集合中刪除全部元素（可選操做）。  
boolean contains(Object o) 
//若是此集合包含指定的元素，則返回 true 。    
boolean equals(Object o) 
//將指定的對象與此集合進行比較以實現相等。  
int hashCode() 
//返回此集合的哈希碼值。  
boolean isEmpty() 
//若是此集合不包含元素，則返回 true 。  
Iterator<E> iterator() 
//返回此集合中元素的迭代器。  
boolean remove(Object o) 
//若是存在，則從該集合中刪除指定的元素（可選操做）。    
int size() 
//返回此集合中的元素數（其基數）。  
Object[] toArray() 
//返回一個包含此集合中全部元素的數組。

AbstractSet

public abstract class AbstractSet<E>
extends AbstractCollection<E>
implements Set<E>

AbstractSet抽象類繼承了AbstractCollection,構成了Set的最小骨幹

SortedSet

public interface SortedMap<K,V>
extends Map<K,V>

SortedSet接口在Set基礎之上進行排序,要實現此功能必須實現Comparable接口

部分接口方法

Comparator<? super E> comparator() 
//返回用於對該集合中的元素進行排序的比較器，或null，若是此集合使用其元素的natural ordering 。  
E first() 
//返回此集合中當前的第一個（最低）元素。  
SortedSet<E> headSet(E toElement) 
//返回該集合的部分的視圖，其元素嚴格小於 toElement 。  
E last() 
//返回此集合中當前的最後（最高）元素。  
default Spliterator<E> spliterator() 
//在此排序集中的元素上建立一個 Spliterator 。  
SortedSet<E> subSet(E fromElement, E toElement) 
//返回該集合的部分的視圖，其元素的範圍爲 fromElement （含），爲 toElement ，獨佔。  
SortedSet<E> tailSet(E fromElement) 
//返回此組件的元素大於或等於 fromElement的部分的視圖。

Set子類對比

Set子類	線程安全	迭代順序	存取效率
HashSet	否	規律	O(1)
TreeSet	否	天然順序	Olog(n)
LinkedhashSet	否	插入順序	O(1)

HashMap和HashSet

Map的鍵不能夠重複,Set的元素不能夠重複,這個特色是經過equals方法來判斷的,而在HashMap和HashSet中重複判斷稍稍不一樣

在HashMap和HashSet中每添加一個新元素會先調用hashCode()查看集合中是否有和新元素同樣哈希值的元素,若是沒有就將其添加;若是有再調用equals()來判斷二者是否相同,相同則不添加,反之添加.由於哈希值不一樣對象必定不一樣,哈希值相同對象可能不一樣)

必要時重寫equals()和hashCode()

graph TD 1(新元素)==>2(哈希值相同) 2==>|否|3(添加) 2==>|是|4(內容相同) 4==>|是|5(不添加) 4==>|否|3

import java.util.*;
class Cat{
    public int no;
    public String name;
    Cat(int no,String name){
        this.no=no;
        this.name=name;
    }
    Cat(){}
    @Override
    public String toString() {
        return "no:"+no+",name:"+name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cat cat = (Cat) o;
        return no == cat.no &&
                Objects.equals(name, cat.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(no, name);
    }
}
public class Demo {
    public static void main(String args[]){
        HashSet<Cat> hc=new HashSet<>();
        hc.add(new Cat(1,"花花"));
        hc.add(new Cat(2,"小黑"));
        for(Cat c:hc)
            System.out.println(c);
    }
}

TreeMap和TreeSet

TreeMap和TreeSet會對添加的元素進行排序,這依賴於Comparable接口的實現,或者在構造TreeMap或TreeSet時傳遞Comparator對象

後者是爲了解決某些類(final 類)不能實現Comparable接口

import java.util.*;
class Cat implements Comparable<Cat>{
    public int no;
    public String name;
    Cat(int no,String name){
        this.no=no;
        this.name=name;
    }
    Cat(){}
    @Override
    public String toString() {
        return "no:"+no+",name:"+name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cat cat = (Cat) o;
        return no == cat.no &&
                Objects.equals(name, cat.name);
    }

    @Override
    public int compareTo(Cat c) {
        //返回正數表示該對象大於c,返回0表示兩者相等,返回負數表述該對象小於c
        return no-c.no;
    }
}
public class Demo {
    public static void main(String args[]){
        TreeSet<Cat> hc=new TreeSet<>();
        hc.add(new Cat(1,"花花"));
        hc.add(new Cat(3,"大米"));
        hc.add(new Cat(2,"小黑"));
        for(Cat c:hc)
            System.out.println(c);
    }
}

Collections工具類

void reverse(List list)//反轉
void shuffle(List list)//隨機排序
void sort(List list)//按天然排序的升序排序
void sort(List list, Comparator c)//定製排序，由Comparator控制排序邏輯
void swap(List list, int i , int j)//交換兩個索引位置的元素
void rotate(List list, int distance)//旋轉。當distance爲正數時，將list後distance個元素總體移到前面。當distance爲負數時，將 list的前distance個元素總體移到後面。
int binarySearch(List list, Object key)//對List進行二分查找，返回索引，注意List必須是有序的
int max(Collection coll)//根據元素的天然順序，返回最大的元素。 類比int min(Collection coll)
int max(Collection coll, Comparator c)//根據定製排序，返回最大元素，排序規則由Comparatator類控制。類比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的全部元素。 
int frequency(Collection c, Object o)//統計元素出現次數
int indexOfSubList(List list, List target)//統計target在list中第一次出現的索引，找不到則返回-1，類比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal)//用新元素替換舊元素

Arrays工具類

sort()//排序
binarySearch()//二叉查找
equals()//比較
fill()//填充
static <T> List<T> asList(T... a) //返回由指定數組支持的固定大小的列表。 
toString()//轉字符串