一、集合框架的由來

Java 集合框架主要包括兩種型別的容器，一種是集合（Collection），儲存一個元素集合，另一種是圖（Map），儲存鍵/值對對映。Collection 介面又有 3 種子型別，List、Set和Queue，再下面是一些抽象類，最後是具體實現類，常用的有ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

集合框架是一個用來代表和操縱集合的統一架構。所有的集合框架都包含如下內容：

• 介面：是代表集合的抽象資料型別。例如 Collection、List、Set、Map 等。之所以定義多個介面，是為了以不同的方式操作集合物件

• 實現（類）：是集合介面的具體實現。從本質上講，它們是可重複使用的資料結構，例如：ArrayList、LinkedList、HashSet、HashMap。

• 演算法：是實現集合介面的物件裡的方法執行的一些有用的計算，例如：搜尋和排序。這些演算法被稱為多型，那是因為相同的方法可以在相似的介面上有著不同的實現。

除了集合，該框架也定義了幾個 Map 介面和類。Map 裡儲存的是鍵/值對。儘管Map不是集合，但是它們完全整合在集合中。

二、陣列與集合的區別

陣列的特點：

1. 只能儲存同一種資料型別的資料。
2. 一旦初始化，長度固定。
3. 陣列中的元素與元素之間的記憶體地址是連續的。

注意： Object型別的陣列可以儲存任意型別的資料。

集合：集合是儲存物件資料的集合容器。

集合比陣列的優勢:

1. 集合可以儲存任意型別的物件資料，陣列只能儲存同一種資料型別 的資料。
2. 集合的長度是會發生變化的，陣列的長度是固定的

三、collection之繼承體系

Collection<E>介面是所有單列集合的共同父介面，下面列出了常用的Collection子類集合及其繼承關係。

集合框架概述

Collection   
    |-----List有序(儲存順序和取出順序一致)，可重複
    |----ArrayList，執行緒不安全，底層使用陣列實現，查詢快，增刪慢。效率高。
            每次容量不足時，自增長度的一半，如下原始碼可知
                  int newCapacity = oldCapacity + (oldCapacity >> 1);
    |----LinkedList ， 執行緒不安全，底層使用連結串列實現，查詢慢，增刪快。效率高
 
    |----Vector ， 執行緒安全，底層使用陣列實現，查詢快，增刪慢。效率低         每次容量不足時，預設自增長度的一倍（如果不指定增量的話），如下原始碼可知
                   int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    |-----Set   元素唯一一個不包含重複元素的 collection。更確切地講，set 不包含滿足 e1.equals(e2) 的元素對 e1 和 e2，並且最多包含一個 null 元素。
 
    |--HashSet 底層是由HashMap實現的，通過物件的hashCode方法與equals方法來保證插入元素的唯一性，無序(儲存順序和取出順序不一致)。
 
    |--LinkedHashSet 底層資料結構由雜湊表和連結串列組成。雜湊表保證元素的唯一性，連結串列保證元素有序。(儲存和取出是一致)
 
    |--TreeSet 基於 TreeMap 的 NavigableSet 實現。使用元素的自然順序對元素進行排序，或者根據建立 set 時提供的 Comparator 進行排序，具體取決於使用的構造方法。 元素唯一。
 

四、Collection泛型介面

boolean add(E e) 
             確保此 collection 包含指定的元素（可選操作）。    
    boolean addAll(Collection<? extends E> c) 
   將指定collection中的所有元素都新增到此collection 中（可選操作）。    
    void clear() 
             移除此 collection 中的所有元素（可選操作）。 
    boolean contains(Object o) 
             如果此 collection 包含指定的元素，則返回 true。 
    boolean containsAll(Collection<?> c) 
             如果此 collection 包含指定 collection 中的所有元素，則返回 true。 
    boolean equals(Object o) 
             比較此 collection 與指定物件是否相等。 
    int hashCode() 
             返回此 collection 的雜湊碼值。 
    boolean isEmpty() 
             如果此 collection 不包含元素，則返回 true。 
    Iterator<E> iterator() 
             返回在此 collection 的元素上進行迭代的迭代器。 
    boolean remove(Object o) 
             從此 collection 中移除指定元素的單個例項，如果存在的話（可選操作）。 
    boolean removeAll(Collection<?> c) 
             移除此 collection 中那些也包含在指定 collection 中的所有元素（可選操作）。 
    boolean retainAll(Collection<?> c) 
             僅保留此 collection 中那些也包含在指定 collection 的元素（可選操作）。 
    int size() 
             返回此 collection 中的元素數。 
    Object[] toArray() 
             返回包含此 collection 中所有元素的陣列。 
   <T> T[] 
    toArray(T[] a) 

collection方法簡單示例：

    //集合轉陣列遍歷
	public static void demo1() {
	Collection coll = new ArrayList();
			coll.add(new Student("張三",23));		//Object obj = new Student("張三",23);
			coll.add(new Student("李四",24));
			coll.add(new Student("王五",25));
			coll.add(new Student("趙六",26));
			
			Object[] arr = coll.toArray();				//將集合轉換成陣列
			for (int i = 0; i < arr.length; i++) {
				Student s = (Student)arr[i];			//強轉成Student
				System.out.println(s.getName() + "," + s.getAge());
			}
	} 
	
	//集合的遍歷之迭代器遍歷
	public static void demo2() {
	Collection c = new ArrayList();
			c.add("a");
			c.add("b");
			c.add("c");
			c.add("d");
			
			Iterator it = c.iterator();						//獲取迭代器的引用
			while(it.hasNext()) {							//集合中的迭代方法(遍歷)
				System.out.println(it.next());
			}
	}		

五、List泛型介面

public interface List<E>extends Collection<E>  //超級介面

方法概述：

 boolean add(E o) 
          向列表的尾部追加指定的元素（可選操作）。 
 void add(int index, E element) 
          在列表的指定位置插入指定元素（可選操作）。 
 boolean addAll(Collection<? extends E> c) 
          追加指定 collection 中的所有元素到此列表的結尾，順序是指定 collection 的迭代器返回這些元素的順序（可選操作）。 
 boolean addAll(int index, Collection<? extends E> c) 
          將指定 collection 中的所有元素都插入到列表中的指定位置（可選操作）。 
 void clear() 
          從列表中移除所有元素（可選操作）。 
 boolean contains(Object o) 
          如果列表包含指定的元素，則返回 true。 
 boolean containsAll(Collection<?> c) 
          如果列表包含指定 collection 的所有元素，則返回 true。 
 boolean equals(Object o) 
          比較指定的物件與列表是否相等。 
 E get(int index) 
          返回列表中指定位置的元素。 
 int hashCode() 
          返回列表的雜湊碼值。 
 int indexOf(Object o) 
          返回列表中首次出現指定元素的索引，如果列表不包含此元素，則返回 -1。 
 boolean isEmpty() 
          如果列表不包含元素，則返回 true。 
 Iterator<E> iterator() 
          返回以正確順序在列表的元素上進行迭代的迭代器。 
 int lastIndexOf(Object o) 
          返回列表中最後出現指定元素的索引，如果列表不包含此元素，則返回 -1。 
 ListIterator<E> listIterator() 
          返回列表中元素的列表迭代器（以正確的順序）。 
 ListIterator<E> listIterator(int index) 
          返回列表中元素的列表迭代器（以正確的順序），從列表的指定位置開始。 
 E remove(int index) 
          移除列表中指定位置的元素（可選操作）。 
 boolean remove(Object o) 
          移除列表中出現的首個指定元素（可選操作）。 
 boolean removeAll(Collection<?> c) 
          從列表中移除指定 collection 中包含的所有元素（可選操作）。 
 boolean retainAll(Collection<?> c) 
          僅在列表中保留指定 collection 中所包含的元素（可選操作）。 
 E set(int index, E element) 
          用指定元素替換列表中指定位置的元素（可選操作）。 
 int size() 
          返回列表中的元素數。 
 List<E> subList(int fromIndex, int toIndex) 
          返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分檢視。 
 Object[] toArray() 
          返回以正確順序包含列表中的所有元素的陣列。 
<T> T[] 
 toArray(T[] a) 
          返回以正確順序包含列表中所有元素的陣列；返回陣列的執行時型別是指定陣列的執行時型別。

list方法簡單示例：

	public static void demo2() {
		List list = new ArrayList();
		list.add(new Student("張三",23));
		list.add(new Student("李四",24));
		list.add(new Student("王五",25));
		list.add(new Student("趙六",26));
		
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			Student s = (Student) iterator.next(); //向下轉型
			System.out.println(s);
		}
	}
	
	public static void demo() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		Iterator iterator  = list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

併發修改異常產生的原因及解決方案

假設有一個集合，請問，我想判斷裡面有沒有"world"這個元素，如果有，我就新增一個"java"元素,具體程式碼如下：

public static void demo3() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("world");
		list.add("d");
		list.add("e");
		
		Iterator it = list.iterator();
		while(it.hasNext()) {
			String str = (String)it.next();
			if(str.equals("world")) {
				list.add("javaee");			//這裡會丟擲ConcurrentModificationException併發修改異常
			}
		}
	}

執行上面程式碼發生ConcurrentModificationException併發修改異常，檢視迭代器原始碼如下。
產生原因：迭代器是依賴於集合而存在的，在判斷成功後，集合的中新添加了元素，而迭代器卻不知道，迭代器的內容不發生改變。所以就報錯了，這個錯叫併發修改異常。

      final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

解決辦法及程式碼如下：
迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
集合遍歷元素，集合修改元素

    public static void demo() {
		ListIterator lit = list.listIterator();		//如果想在遍歷的過程中新增元素,可以用ListIterator中的add方法
			while(lit.hasNext()) {
				String str = (String)lit.next();
				if(str.equals("world")) {
					lit.add("javaee");	
					//list.add("javaee");
				}
            }	
		}

瞭解：(ListIterator)

1. boolean hasNext()是否有下一個
2. boolean hasPrevious()是否有前一個
3. Object next()返回下一個元素
4. Object previous();返回上一個元素

六、ArrayList類

方法摘要：

public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

構造方法摘要

ArrayList() 
          構造一個初始容量為 10 的空列表。 
ArrayList(Collection<? extends E> c) 
          構造一個包含指定 collection 的元素的列表，這些元素是按照該 collection 的迭代器返回它們的順序排列的。 
ArrayList(int initialCapacity) 
          構造一個具有指定初始容量的空列表。 
 

 boolean add(E o) 
          將指定的元素追加到此列表的尾部。 
 void add(int index, E element) 
          將指定的元素插入此列表中的指定位置。 
 boolean addAll(Collection<? extends E> c) 
          按照指定 Collection 的迭代器所返回的元素順序，將該 Collection 中的所有元素追加到此列表的尾部。 
 boolean addAll(int index, Collection<? extends E> c) 
          從指定的位置開始，將指定 Collection 中的所有元素插入到此列表中。 
 void clear() 
          移除此列表中的所有元素。 
 Object clone() 
          返回此 ArrayList 例項的淺表複製。 
 boolean contains(Object elem) 
          如果此列表中包含指定的元素，則返回 true。 
 void ensureCapacity(int minCapacity) 
          如有必要，增加此 ArrayList 例項的容量，以確保它至少能夠容納最小容量引數所指定的元素數。 
 E get(int index) 
          返回此列表中指定位置上的元素。 
 int indexOf(Object elem) 
          搜尋給定引數第一次出現的位置，使用 equals 方法進行相等性測試。 
 boolean isEmpty() 
          測試此列表中是否沒有元素。 
 int lastIndexOf(Object elem) 
          返回指定的物件在列表中最後一次出現的位置索引。 
 E remove(int index) 
          移除此列表中指定位置上的元素。 
 boolean remove(Object o) 
          從此列表中移除指定元素的單個例項（如果存在），此操作是可選的。 
protected  void removeRange(int fromIndex, int toIndex) 
          移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的所有元素。 
 E set(int index, E element) 
          用指定的元素替代此列表中指定位置上的元素。 
 int size() 
          返回此列表中的元素數。 
 Object[] toArray() 
          返回一個按照正確的順序包含此列表中所有元素的陣列。 
<T> T[] 
 toArray(T[] a) 
          返回一個按照正確的順序包含此列表中所有元素的陣列；返回陣列的執行時型別就是指定陣列的執行時型別。 
 void trimToSize() 
          將此 ArrayList 例項的容量調整為列表的當前大小。 
從類 java.util.AbstractList 繼承的方法 
equals, hashCode, iterator, listIterator, listIterator, subList 
  從類 java.util.AbstractCollection 繼承的方法 
containsAll, removeAll, retainAll, toString 
  從類 java.lang.Object 繼承的方法 
finalize, getClass, notify, notifyAll, wait, wait, wait 
  從介面 java.util.List 繼承的方法 
containsAll, equals, hashCode, iterator, listIterator, listIterator, removeAll, retainAll, subList  

ArrayList示例：

	public static void demo1() {
		ArrayList arr = new ArrayList();
		arr.add(new Student("張三", 23));
		arr.add(new Student("李四",24));
		
		System.out.println(arr);
		
		Iterator it = arr.iterator();
		while (it.hasNext()) {
			Student student = (Student) it.next();
			System.out.println(student.getName()+"..."+student.getAge());
		}
	}
 
	public static void demo() {
		ArrayList arr = new ArrayList();
		arr.add("a");
		arr.add("b");
		arr.add("c");
		arr.add("d");
		
		System.out.println(arr);
	}
 
}

七、LinkedList類

public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Queue<E>, Cloneable, Serializable

構造方法摘要

LinkedList() 
          構造一個空列表。 
LinkedList(Collection<? extends E> c) 
          構造一個包含指定集合中的元素的列表，這些元素按其集合的迭代器返回的順序排列。 

方法摘要

 boolean add(E o) 
          將指定元素追加到此列表的結尾。 
 void add(int index, E element) 
          在此列表中指定的位置插入指定的元素。 
 boolean addAll(Collection<? extends E> c) 
          追加指定 collection 中的所有元素到此列表的結尾，順序是指定 collection 的迭代器返回這些元素的順序。 
 boolean addAll(int index, Collection<? extends E> c) 
          將指定集合中的所有元素從指定位置開始插入此列表。 
 void addFirst(E o) 
          將給定元素插入此列表的開頭。 
 void addLast(E o) 
          將給定元素追加到此列表的結尾。 
 void clear() 
          從此列表中移除所有元素。 
 Object clone() 
          返回此 LinkedList 的淺表複製。 
 boolean contains(Object o) 
          如果此列表包含指定元素，則返回 true。 
 E element() 
          找到但不移除此列表的頭（第一個元素）。 
 E get(int index) 
          返回此列表中指定位置處的元素。 
 E getFirst() 
          返回此列表的第一個元素。 
 E getLast() 
          返回此列表的最後一個元素。 
 int indexOf(Object o) 
          返回此列表中首次出現的指定元素的索引，如果列表中不包含此元素，則返回 -1。 
 int lastIndexOf(Object o) 
          返回此列表中最後出現的指定元素的索引，如果列表中不包含此元素，則返回 -1。 
 ListIterator<E> listIterator(int index) 
          返回此列表中的元素的列表迭代器（按適當順序），從列表中指定位置開始。 
 boolean offer(E o) 
          將指定元素新增到此列表的末尾（最後一個元素）。 
 E peek() 
          找到但不移除此列表的頭（第一個元素）。 
 E poll() 
          找到並移除此列表的頭（第一個元素）。 
 E remove() 
          找到並移除此列表的頭（第一個元素）。 
 E remove(int index) 
          移除此列表中指定位置處的元素。 
 boolean remove(Object o) 
          移除此列表中首次出現的指定元素。 
 E removeFirst() 
          移除並返回此列表的第一個元素。 
 E removeLast() 
          移除並返回此列表的最後一個元素。 
 E set(int index, E element) 
          將此列表中指定位置的元素替換為指定的元素。 
 int size() 
          返回此列表的元素數。 
 Object[] toArray() 
          以正確順序返回包含此列表中所有元素的陣列。 
<T> T[] 
 toArray(T[] a) 
          以正確順序返回包含此列表中所有元素的陣列；返回陣列的執行時型別即為指定陣列的類。

八、vector

public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

構造方法摘要

Vector() 
          構造一個空向量，使其內部資料陣列的大小為 10，其標準容量增量為零。 
Vector(Collection<? extends E> c) 
          構造一個包含指定集合中的元素的向量，這些元素按其集合的迭代器返回元素的順序排列。 
Vector(int initialCapacity) 
          使用指定的初始容量和等於零的容量增量構造一個空向量。 
Vector(int initialCapacity, int capacityIncrement) 
          使用指定的初始容量和容量增量構造一個空的向量 

特有方法摘要

 boolean add(E o) 
          將指定元素追加到此向量的末尾。 
 void add(int index, E element) 
          在此向量的指定位置插入指定的元素。 
 boolean addAll(Collection<? extends E> c) 
          將指定 Collection 中的所有元素追加到此向量的末尾，按照指定集合的迭代器所返回的順序追加這些元素。 
 boolean addAll(int index, Collection<? extends E> c) 
          在指定位置將指定 Collection 中的所有元素插入到此向量中。 
 void addElement(E obj) 
          將指定的元件新增到此向量的末尾，將其大小增加 1。 
 int capacity() 
          返回此向量的當前容量。 
 void clear() 
          從此向量中移除所有元素。 
 Object clone() 
          返回向量的一個副本。 
 boolean contains(Object elem) 
          測試指定的物件是否為此向量中的元件。 
 boolean containsAll(Collection<?> c) 
          如果此向量包含指定 Collection 中的所有元素，則返回 true。 
 void copyInto(Object[] anArray) 
          將此向量的元件複製到指定的陣列中。 
 E elementAt(int index) 
          返回指定索引處的元件。 
 Enumeration<E> elements() 
          返回此向量的元件的列舉。 
 void ensureCapacity(int minCapacity) 
          增加此向量的容量（如有必要），以確保其至少能夠儲存最小容量引數指定的元件數。 
 boolean equals(Object o) 
          比較指定物件與此向量的相等性。 
 E firstElement() 
          返回此向量的第一個元件（位於索引 0 處的項）。 
 E get(int index) 
          返回向量中指定位置的元素。 
 int hashCode() 
          返回此向量的雜湊碼值。 
 int indexOf(Object elem) 
          搜尋給定引數的第一個匹配項，使用 equals 方法測試相等性。 
 int indexOf(Object elem, int index) 
          搜尋給定引數的第一個匹配項，從 index 處開始搜尋，並使用 equals 方法測試其相等性。 
 void insertElementAt(E obj, int index) 
          將指定物件作為此向量中的元件插入到指定的 index 處。 
 boolean isEmpty() 
          測試此向量是否不包含元件。 
 E lastElement() 
          返回此向量的最後一個元件。 
 int lastIndexOf(Object elem) 
          返回指定的物件在此向量中最後一個匹配項的索引。 
 int lastIndexOf(Object elem, int index) 
          向後搜尋指定的物件，從指定的索引處開始搜尋，並返回一個索引。 
 E remove(int index) 
          移除此向量中指定位置的元素。 
 boolean remove(Object o) 
          移除此向量中指定元素的第一個匹配項，如果向量不包含該元素，則元素保持不變。 
 boolean removeAll(Collection<?> c) 
          從此向量中移除包含在指定 Collection 中的所有元素。 
 void removeAllElements() 
          從此向量中移除全部元件，並將其大小設定為零。 
 boolean removeElement(Object obj) 
          從此向量中移除變數的第一個（索引最小的）匹配項。 
 void removeElementAt(int index) 
          刪除指定索引處的元件。 
protected  void removeRange(int fromIndex, int toIndex) 
          從此 List 中移除其索引位於 fromIndex（包括）與 toIndex（不包括）之間的所有元素。 
 boolean retainAll(Collection<?> c) 
          在此向量中僅保留包含在指定 Collection 中的元素。 
 E set(int index, E element) 
          用指定的元素替換此向量中指定位置處的元素。 
 void setElementAt(E obj, int index) 
          將此向量指定 index 處的元件設定為指定的物件。 
 void setSize(int newSize) 
          設定此向量的大小。 
 int size() 
          返回此向量中的元件數。 
 List<E> subList(int fromIndex, int toIndex) 
          返回此 List 的部分檢視，元素範圍為從 fromIndex（包括）到 toIndex（不包括）。 
 Object[] toArray() 
          返回一個數組，包含此向量中以正確順序存放的所有元素。 
<T> T[] 
 toArray(T[] a) 
          返回一個數組，包含此向量中以正確順序存放的所有元素；返回陣列的執行時型別為指定陣列的型別。 
 String toString() 
          返回此向量的字串表示形式，其中包含每個元素的 String 表示形式。 
 void trimToSize() 
          對此向量的容量進行微調，使其等於向量的當前大小。

vector 使用示例：

	public static void demo1() {
		Vector v = new Vector();
		v.add(new Student("張三", 23));
		v.add(new Student("李四", 24));
		v.add(new Student("王五", 25));
		
		Iterator it = v.iterator();
		while (it.hasNext()) {
			Object s = (Student) it.next();
			System.out.println(s);
		}
	}
	
	public static void demo() {
		Vector v = new Vector();
		v.add("a");
		v.add("b");
		v.add("c");
		v.add("d");
		
		System.out.println(v);
		System.out.println(v.capacity());
		System.out.println(v.size());
		System.out.println(v.contains("a"));
	}