Java集合框架

(本文轉載自：http://doc.okbase.net/DavidIsOK/archive/94766.html)

前言：數據結構對程序設計有着深遠的影響，在面向過程的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時，得到的記錄是排過序的。

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 遍歷的四種方法：

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);
  }
 }

3、其他特徵

List，Set，Map將持有對象一律視爲Object型別。

Collection、List、Set、Map都是接口，不能實例化。

繼承自它們的 ArrayList, Vector, HashTable, HashMap是具象class，這些纔可被實例化。

vector容器確切知道它所持有的對象隸屬什麼型別。vector不進行邊界檢查。

三、Collections

Collections是針對集合類的一個幫助類。提供了一系列靜態方法實現對各種集合的搜索、排序、線程完全化等操作。

相當於對Array進行類似操作的類——Arrays。

如，Collections.max(Collection coll); 取coll中最大的元素。

Collections.sort(List list); 對list中元素排序

四、如何選擇？

1、容器類和Array的區別、擇取

* 容器類僅能持有對象引用（指向對象的指針），而不是將對象信息copy一份至數列某位置。

* 一旦將對象置入容器內，便損失了該對象的型別信息。

2、

* 在各種Lists中，最好的做法是以ArrayList作爲缺省選擇。當插入、刪除頻繁時，使用LinkedList()；

Vector總是比ArrayList慢，所以要儘量避免使用。

* 在各種Sets中，HashSet通常優於TreeSet（插入、查找）。只有當需要產生一個經過排序的序列，才用TreeSet。

TreeSet存在的唯一理由：能夠維護其內元素的排序狀態。

* 在各種Maps中

HashMap用於快速查找。

* 當元素個數固定，用Array，因爲Array效率是最高的。

結論：最常用的是ArrayList，HashSet，HashMap，Array。而且，我們也會發現一個規律，用TreeXXX都是排序的。

注意：

1、Collection沒有get()方法來取得某個元素。只能通過iterator()遍歷元素。

2、Set和Collection擁有一模一樣的接口。

3、List，可以通過get()方法來一次取出一個元素。使用數字來選擇一堆對象中的一個，get(0)...。(add/get)

4、一般使用ArrayList。用LinkedList構造堆棧stack、隊列queue。

5、Map用 put(k,v) / get(k)，還可以使用containsKey()/containsValue()來檢查其中是否含有某個key/value。

HashMap會利用對象的hashCode來快速找到key。

* hashing

哈希碼就是將對象的信息經過一些轉變形成一個獨一無二的int值，這個值存儲在一個array中。

我們都知道所有存儲結構中，array查找速度是最快的。所以，可以加速查找。

發生碰撞時，讓array指向多個values。即，數組每個位置上又生成一個槤表。

6、Map中元素，可以將key序列、value序列單獨抽取出來。

使用keySet()抽取key序列，將map中的所有keys生成一個Set。

使用values()抽取value序列，將map中的所有values生成一個Collection。

爲什麼一個生成Set，一個生成Collection？那是因爲，key總是獨一無二的，value允許重複。

octopusflying

發佈了75 篇原創文章 · 獲贊 80 · 訪問量 22萬+

私信關注

Java複習筆記(8)——異常、斷言、日誌和調試

利用Java反射機制輸出類的信息

JSP2自定義標籤庫技術

Java複習筆記(7)——接口和內部類

Java複習筆記(5)——繼承

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結