java集合框架

時間 2019-11-29

標籤 java 集合框架欄目 Java 简体版

原文原文鏈接

java的集合框架最全詳解（圖）java

前言：數據結構對程序設計有着深遠的影響，在面向過程的C語言中，數據庫結構用struct來描述，而在面向對象的編程中，數據結構是用類來描述的，而且包含有對該數據結構操做的方法。程序員

在Java語言中，Java語言的設計者對經常使用的數據結構和算法作了一些規範（接口）和實現（具體實現接口的類）。全部抽象出來的數據結構和操做（算法）統稱爲Java集合框架（JavaCollectionFramework）。算法

Java程序員在具體應用時，沒必要考慮數據結構和算法實現細節，只須要用這些類建立出來一些對象，而後直接應用就能夠了，這樣就大大提升了編程效率。數據庫

1. 先說Set和List:編程

1.1. Set子接口:無序，不容許重複。List子接口:有序，能夠有重複元素。具體區別是數組

Set：檢索元素效率低下，刪除和插入效率高，插入和刪除不會引發元素位置改變。<對應類有 HashSet,TreeSet>安全

List：和數組相似，List能夠動態增加，查找元素效率高，插入刪除元素效率低，由於會引發其餘元素位置改變。<相應類有 ArrayList,LinkedList，Vector>數據結構

Set和List具體子類：框架

2.2. <實例比較>數據結構和算法

HashSet：以哈希表的形式存放元素，插入刪除速度很快。

ArrayList：動態數組，LinkedList：鏈表、隊列、堆棧。

Vector是一種老的動態數組，是線程同步的，效率很低，通常不同意使用

1.Collection接口

Collection是最基本的集合接口，一個Collection表明一組Object，即Collection的元素（Elements）。一些 Collection容許相同的元素而另外一些不行。一些能排序而另外一些不行。JavaSDK不提供直接繼承自Collection的類，JavaSDK提供的類都是繼承自Collection的「子接口」如List和Set。

全部實現Collection接口的類都必須提供兩個標準的構造函數：無參數的構造函數用於建立一個空的Collection，有一個 Collection參數的構造函數用於建立一個新的Collection，這個新的Collection與傳入的Collection有相同的元素。後一個構造函數容許用戶複製一個Collection。

如何遍歷Collection中的每個元素？不論Collection的實際類型如何，它都支持一個iterator()的方法，該方法返回一個迭代子，使用該迭代子便可逐一訪問Collection中每個元素。典型的用法以下：

Iteratorit=collection.iterator();//得到一個迭代子

while(it.hasNext()){

Objectobj=it.next();//獲得下一個元素

}

由Collection接口派生的兩個接口是List和Set。

2.List接口

List是有序的Collection，使用此接口可以精確的控制每一個元素插入的位置。用戶可以使用索引（元素在List中的位置，相似於數組下標）來訪問List中的元素，這相似於Java的數組。

和下面要提到的Set不一樣，List容許有相同的元素。

除了具備Collection接口必備的iterator()方法外，List還提供一個listIterator()方法，返回一個 ListIterator接口，和標準的Iterator接口相比，ListIterator多了一些add()之類的方法，容許添加，刪除，設定元素，還能向前或向後遍歷。

實現List接口的經常使用類有LinkedList，ArrayList，Vector和Stack。

2.1.LinkedList類

LinkedList實現了List接口，容許null元素。此外LinkedList提供額外的get，remove，insert方法在 LinkedList的首部或尾部。這些操做使LinkedList可被用做堆棧（stack），隊列（queue）或雙向隊列（deque）。

注意LinkedList沒有同步方法。若是多個線程同時訪問一個List，則必須本身實現訪問同步。一種解決方法是在建立List時構造一個同步的List：

Listlist=Collections.synchronizedList(newLinkedList(...));

2.2.ArrayList類

ArrayList實現了可變大小的數組。它容許全部元素，包括null。ArrayList沒有同步。

size，isEmpty，get，set方法運行時間爲常數。可是add方法開銷爲分攤的常數，添加n個元素須要O(n)的時間。其餘的方法運行時間爲線性。

每一個ArrayList實例都有一個容量（Capacity），即用於存儲元素的數組的大小。這個容量可隨着不斷添加新元素而自動增長，可是增加算法並無定義。當須要插入大量元素時，在插入前能夠調用ensureCapacity方法來增長ArrayList的容量以提升插入效率（自動增判斷長度後增加也會浪費時間的呀！）。

和LinkedList同樣，ArrayList也是非同步的（unsynchronized）。（擴展閱讀：在java.util.concurrent包中定義的CopyOnWriteArrayList提供了線程安全的Arraylist，可是當進行add和set等變化操做時它是經過爲底層數組建立新的副本實現的，因此比較耗費資源

（源碼在此：publicboolean add(E e) {

finalReentrantLock lock =this.lock;

lock.lock();

try {

Object[] elements = getArray();

int len = elements.length;

Object[] newElements = Arrays.copyOf(elements,len + 1);

newElements[len] = e;

setArray(newElements);

return true;

} finally {

lock.unlock();

}

}），

可是若是存在頻繁遍歷，遍歷操做比變化（寫入和修改）操做多的時候這種遍歷就相對於本身進行的同步遍歷效果要好，並且它也容許存在null元素）

2.3.Vector類

Vector很是相似ArrayList，可是Vector是同步的。由Vector建立的Iterator，雖然和ArrayList建立的 Iterator是同一接口，可是，由於Vector是同步的，當一個Iterator被建立並且正在被使用，另外一個線程改變了Vector的狀態（例如，添加或刪除了一些元素），這時調用Iterator的方法時將拋出ConcurrentModificationException，所以必須捕獲該異常。經過使用capacity和ensurecapacity操做以及capacityIncrement域能夠優化存儲操做，這個前面講過，（Vector的Iterator和listIterator方法翻譯的迭代器支持fail-fast機制，所以若是在使用迭代器的過程當中有其餘線程修改了map，那麼將拋出ConcurrentModificationException，這就是所謂fail-fast策略。官方對此的說明是 java.util 包中的集合類都返回 fail-fast迭代器，這意味着它們假設線程在集合內容中進行迭代時，集合不會更改它的內容。若是 fail-fast迭代器檢測到在迭代過程當中進行了更改操做，那麼它會拋出 ConcurrentModificationException，這是不可控異常。）

2.4.Stack類

Stack繼承自Vector，實現一個後進先出的堆棧。Stack提供5個額外的方法使得Vector得以被看成堆棧使用。基本的push和pop方法，還有peek方法獲得棧頂的元素，empty方法測試堆棧是否爲空，search方法檢測一個元素在堆棧中的位置。Stack剛建立後是空棧。

stack 有幾個比較實用的方法

boolean	empty() 測試堆棧是否爲空。
E	peek() 查看堆棧頂部的對象，但不從堆棧中移除它。
E	pop() 移除堆棧頂部的對象，並做爲此函數的值返回該對象。
E	push(Eitem) 把項壓入堆棧頂部。
int	search(Objecto) 返回對象在堆棧中的位置，以 1 爲基數。

3. set接口：

Set具備與Collection徹底同樣的接口，所以沒有任何額外的功能，不像前面有兩個不一樣的List。實際上Set就是Collection,只是行爲不一樣。(這是繼承與多態思想的典型應用：表現不一樣的行爲。)Set不保存重複的元素(至於如何判斷元素相同則較爲負責)
Set : 存入Set的每一個元素都必須是惟一的，由於Set不保存重複元素。加入Set的元素必須定義equals()方法以確保對象的惟一性。Set與Collection有徹底同樣的接口。Set接口不保證維護元素的次序。（我變換黃色背景那裏的名稱獲得以下特色）

HashSet : 它不容許出現重複元素；不保證和政集合中元素的順序，能夠本身作個例子能夠看出加入的字段順序跟遍歷出的不同，容許包含值爲null的元素，但最多隻能有一個null元素（不容許重複嘛！）。

TreeSet : 能夠實現排序等功能的集合，它在講對象元素添加到集合中時會自動按照某種比較規則將其插入到有序的對象序列中，並保證該集合元素組成按照「升序」排列。

a)（在對大量信息進行檢索的時候，TreeSet比AraayList更有效率，能保證在log(n)的時間內完成）。

b)TreeSet是實用樹形結構來存儲信息的，每一個節點都會保存一下指針對象，分別指向父節點，左分支，右分支，相比較而言，ArrayList就是一個含有元素的簡單數組了，正由於如此，它佔的內存也要比ArrayList多一些。

c)想TreeSet插入元素也比ArrayList要快一些，由於當元素插入到ArrayList的任意位置時，平均每次要移動一半的列表，須要O(n)的時間，而TreeSet深度遍歷查詢花費的實施只須要O(log(n))（廣泛的都是，set查詢慢，插入快，list查詢快，插入滿, .TODO:這一點我會寫一個算法測試文章具體分析一下…）

LinkedHashSet : 具備HashSet的查詢速度，且內部使用鏈表維護元素的順序(插入的次序)。因而在使用迭代器遍歷Set時，結果會按元素插入的次序顯示。

PS:set有幾個比較好的方法:

removeAll(Collection<?> c)

移除 set 中那些包含在指定 collection 中的元素（可選操做）。

boolean retainAll(Collection<?> c)

僅保留 set 中那些包含在指定 collection 中的元素（可選操做）。

containsAll(Collection<?> c)

若是此 set 包含指定 collection 的全部元素，則返回 true。

4.Queue數據結構

這方面知識涉及到線程比較多，有線程基礎的口語參考這篇文章

http://blog.csdn.net/a512592151/article/details/38454745

5.Map的功能方法

java爲數據結構中的映射定義了一個接口java.util.Map;它有四個實現類,分別是HashMap Hashtable LinkedHashMap 和TreeMap

Map主要用於存儲健值對，根據鍵獲得值，所以不容許鍵重複,但容許值重複。

Hashmap 是一個最經常使用的Map,它根據鍵的HashCode 值存儲數據,根據鍵能夠直接獲取它的值，具備很快的訪問速度。HashMap最多隻容許一條記錄的鍵爲Null;容許多條記錄的值爲 Null;HashMap不支持線程的同步，即任一時刻能夠有多個線程同時寫HashMap;可能會致使數據的不一致。若是須要同步，能夠用 Collections的synchronizedMap方法使HashMap具備同步的能力.

Hashtable 與HashMap相似,不一樣的是:它不容許記錄的鍵或者值爲空;它支持線程的同步，即任一時刻只有一個線程能寫Hashtable,所以也致使了Hashtale在寫入時會比較慢。

LinkedHashMap保存了記錄的插入順序，在用Iterator遍歷LinkedHashMap時，先獲得的記錄確定是先插入的.在遍歷的時候會比HashMap慢。

TreeMap可以把它保存的記錄根據鍵排序,默認是按升序排序，也能夠指定排序的比較器，當用Iterator 遍歷TreeMap時，獲得的記錄是排過序的。

Java代碼

package com.hxw.T2;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
public class MapTester {
public static void init(Map map) {
if (map != null) {
String key = null;
for (int i = 5; i > 0; i--) {
key = new Integer(i).toString() + ".0";
map.put(key, key.toString());
// Map中的鍵是不重複的，若是插入兩個鍵值同樣的記錄，
// 那麼後插入的記錄會覆蓋先插入的記錄
map.put(key, key.toString() + "0");
}
}
}
public static void output(Map map) {
if (map != null) {
Object key = null;
Object value = null;
// 使用迭代器遍歷Map的鍵，根據鍵取值
Iterator it = map.keySet().iterator();
while (it.hasNext()) {
key = it.next();
value = map.get(key);
System.out.println("key: " + key + "; value: " + value);
}
// 或者使用迭代器遍歷Map的記錄Map.Entry
Map.Entry entry = null;
it = map.entrySet().iterator();
while (it.hasNext()) {
// 一個Map.Entry表明一條記錄
entry = (Map.Entry) it.next();
// 經過entry能夠得到記錄的鍵和值
// System.out.println("key: " + entry.getKey() + "; value: " +
// entry.getValue());
}
}
}
public static boolean containsKey(Map map, Object key) {
if (map != null) {
return map.containsKey(key);
}
return false;
}
public static boolean containsValue(Map map, Object value) {
if (map != null) {
return map.containsValue(value);
}
return false;
}
public static void testHashMap() {
Map myMap = new HashMap();
init(myMap);
// HashMap的鍵能夠爲null
myMap.put(null, "ddd");
// HashMap的值能夠爲null
myMap.put("aaa", null);
output(myMap);
}
public static void testHashtable() {
Map myMap = new Hashtable();
init(myMap);
// Hashtable的鍵不能爲null
// myMap.put(null,"ddd");
// Hashtable的值不能爲null
// myMap.put("aaa", null);
output(myMap);
}
public static void testLinkedHashMap() {
Map myMap = new LinkedHashMap();
init(myMap);
// LinkedHashMap的鍵能夠爲null
myMap.put(null, "ddd");
// LinkedHashMap的值能夠爲null
myMap.put("aaa", null);
output(myMap);
}
public static void testTreeMap() {
Map myMap = new TreeMap();
init(myMap);
// TreeMap的鍵不能爲null
// myMap.put(null,"ddd");
// TreeMap的值不能爲null
// myMap.put("aaa", null);
output(myMap);
}
public static void main(String[] args) {
System.out.println("採用HashMap");
MapTester.testHashMap();
System.out.println("採用Hashtable");
MapTester.testHashtable();
System.out.println("採用LinkedHashMap");
MapTester.testLinkedHashMap();
System.out.println("採用TreeMap");
MapTester.testTreeMap();
Map myMap = new HashMap();
MapTester.init(myMap);
System.out.println("新初始化一個Map: myMap");
MapTester.output(myMap);
// 清空Map
myMap.clear();
System.out.println("將myMap clear後，myMap空了麼? " + myMap.isEmpty());
MapTester.output(myMap);
myMap.put("aaa", "aaaa");
myMap.put("bbb", "bbbb");
// 判斷Map是否包含某鍵或者某值
System.out.println("myMap包含鍵aaa? "
+ MapTester.containsKey(myMap, "aaa"));
System.out.println("myMap包含值aaaa? "
+ MapTester.containsValue(myMap, "aaaa"));
// 根據鍵刪除Map中的記錄
myMap.remove("aaa");
System.out.println("刪除鍵aaa後，myMap包含鍵aaa? "
+ MapTester.containsKey(myMap, "aaa"));
// 獲取Map的記錄數
System.out.println("myMap包含的記錄數: " + myMap.size());
}
}

附：map 遍歷的四種方法：

Java代碼

public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");
//第一種：廣泛使用，二次取值
System.out.println("經過Map.keySet遍歷key和value：");
for (String key : map.keySet()) {
System.out.println("key= "+ key + " and value= " + map.get(key));
}
//第二種
System.out.println("經過Map.entrySet使用iterator遍歷key和value：");
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//第三種：推薦，尤爲是容量大時
System.out.println("經過Map.entrySet遍歷key和value");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//第四種
System.out.println("經過Map.values()遍歷全部的value，但不能遍歷key");
for (String v : map.values()) {
System.out.println("value= " + v);
}
}