java 集合總結

時間 2019-11-08

標籤 java 集合總結欄目 Java 简体版

原文原文鏈接

一、Collection集合算法

二、Map集合數組

* 圖片中略掉抽象類安全

Collection繼承接口Iterable，因此其子類均可經過迭代器遍歷元素。數據結構

Map 能夠經過entrySet()、keySet()方法，獲得一個Set集合進行迭代器遍歷。多線程

ListIterator能夠向前和向後進行迭代併發

1）ArrayList<E>ide

數據結構：數組（線性序列）優化

適合操做：根據數據結構，善於隨機訪問元素，可是在其中間插入和移除元素時較慢this

基本介紹：初始化時可設置數組容量大小，當實際元素個數size大於數組容量，對其進行擴容。由於其數spa

據結構是數組，每次查詢可根據下標直接查到元素。刪除一個元素時，後面元素統一貫前移

一位。

2）LinkedList<E>

數據結構：雙向鏈表

適合操做：根據數據結構，不善於隨機訪問元素，可是在其中間插入和移除元素時較快

基本介紹：每一個元素都是一個Node，除了元素值位，還有一個指向左右的引用。每次增刪Node，只須要改

變左右的引用指向便可，不用移動元素

Java代碼

private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}

3）Vector<E>

數據結構：跟ArrayList的數據結構同樣（數組）

適合操做：跟ArrayList同樣，因同步的，因此沒有ArrayList快

基本介紹：其方法與ArrayList也基本相同，只是在增、刪、改、查等方法前加了synchronized關鍵字。

單線程中不需使用，即便使用後臺的編譯期也會進行對其進行優化，消除同步代碼。多線程中

通常也不多使用，由於速度比較慢，並且組合操做（若是存在刪除）沒法實現線程安全。

4）Stack<E>棧

數據結構：繼承Vector （數組），可用LinkedList鏈表實現。

適合操做：「棧」，先進後出的容器，只有一個口，一端放入元素，同一端取出元素

應用：1）平衡符號：棧中：｛｛【｛（站外：）｝】｝｝，從棧中向外彈出元素作比較。

2）後綴表達式: 表達式a+b*c+(d*e+f)*g 轉成後綴：abc*+de*f+g*+ ,現將abc壓棧，遇到*，bc出棧作

乘法,,,,

基本介紹： LinkedList可以直接實現棧的全部功能的方法，所以能夠直接將LinkedList做爲棧使用。

Java代碼

public class StackLinked<T> {
private LinkedList<T> linked = new LinkedList<T>();
public T peek(){ return linked.getFirst(); }
public T pop(){ return linked.removeFirst(); }
public void push(T t){ linked.addFirst(t); }
public boolean isEntry(){ return linked.isEmpty(); }
@Override
public String toString() {return linked.toString();}
}

5）Queue<E> 隊列

數據結構：數組（ArrayDeque）、鏈表（LinkedList）

適合操做：隊列，先進先出的容器，從容器的一端放入事物，從另外一端取出

應用：併發（只是思想）

基本介紹：放入順序與取出順序相同。

Java代碼

Queue<String> queueLinked = new LinkedList<String>();
Queue<String> queueArray = new ArrayDeque<String>();

6）PriorityQueue<E> 優先隊列

數據結構：堆（數組）。

適合操做：優先隊列，聲明下一個彈出的元素是最須要的元素（最大值/最小值具備最高優先級）

基本介紹：根據堆的性質，每次在[0]位置的都是最大或最小的元素。由於要進行排序因此元素要實現接

口Comparator<T>

Java代碼

public static void main(String[] args) {
Queue<Integer> queue = new PriorityQueue<Integer>(Arrays.asList(1, 3,
5, 4, 6));
while (!queue.isEmpty()) {
System.err.println(queue.remove());// 1 3 4 5 6
}
}

7）Deque<E> 雙向隊列

數據結構：數組（ArrayDeque）、鏈表（LinkedList）

適合操做：雙向隊列，能夠在任何一端添加或刪除元素

基本介紹：由於ArrayDeque、LinkedList都實現了Deque接口，因此能夠經過向上轉型使用Deque

Java代碼

Deque<String> dequeLinked = new LinkedList<String>();
Deque<String> dequeArray = new ArrayDeque<String>();

8）HashMap<K,V>

數據結構：散列（數組+單向鏈表）

適合操做：當get()時使用線性搜索，執行速度會很慢，而HashMap經過散列碼能夠很快定位元素位置。

基本介紹：1）每一個元素都是一個Entry<K,V>對象，其底層經過Entry<K,V>數組來存儲元素，每

個Entry<K,V>對象中會有一個next屬性來實現單向鏈表

2）經過hash算法（利用K的hashCode）爲每一個Entry的K生成一個hash值，而後根據hash值

和數組length算出Entry在數組中的位置。

3）不一樣的K可能生成相同的hash值，即會存儲在數組的同一個位置，這時經過for循環用

equals比較當前位置的鏈表元素，若是是false將新插入的值放入計算出來的位置，

而後next指向oldEntry，若是是false，則替換value

4) 裝(負)載因子默認是075，即當數組75%的位置都有值時，對數組進行擴容length*2，而後從新

計算每一個元素在數組中的位置。

Java代碼

static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
void recordAccess(HashMap<K,V> m) {
}
void recordRemoval(HashMap<K,V> m) {
}
}

9）HashSet<E>

數據結構：散列

適合操做：無重複元素，能夠快速超找到對象。

基本介紹：HashSet的元素能夠看做是HashMap的key沒有重複元素，查找塊。因此HashSet的底層實現就

是HashMap

10）LinkedHashMap<K,V>

數據結構：散列，雙向鏈表

適合操做：具備HashMap的查詢速度，內部使用雙向鏈表維護順序（插入次序），迭代遍歷按插入順序顯

示，由於使用鏈表維護內部順序，因此迭代訪問很快。

基本介紹：繼承自HashMap，每一個元素Entry<K,V>多出兩個指向兩邊元素的引用來維護順序。

Java代碼

private static class Entry<K,V> extends HashMap.Entry<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
super(hash, key, value, next);
}
private void remove() {
before.after = after;
after.before = before;
}
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
if (lm.accessOrder) {
lm.modCount++;
remove();
addBefore(lm.header);
}
}
void recordRemoval(HashMap<K,V> m) {
remove();
}
}

11）LinkedHashSet<E>

數據結構：散列

適合操做：無重複元素，能夠快速超找到對象。迭代遍歷按插入順序顯示

基本介紹：LinkedHashSet的元素能夠看做是LinkedHashMap的key沒有重複的有序元素，

因此LinkedHashSet的底層實現就是LinkedHashMap

12）TreeMap<K,V>

數據結構：紅黑樹

適合操做：對元素自動排序

基本介紹：下面是Entry<K,V>的屬性。TreeMap會對K自動排序，次序由Comparable或Comparator決定，

TreeMap中的元素都是有序的，若是鍵被用於TreeMap，那麼必須實現Comparable

Java代碼

K key;
V value;
Entry<K,V> left = null; //左節點
Entry<K,V> right = null;//右節點
Entry<K,V> parent; //父節點
boolean color = BLACK;

13）TreeSet<E>

數據結構：紅黑樹

基本介紹：經過TreeMap實現，功能參照TreeMap

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。