java集合框架源碼
① java中的集合分類
JAVA集合框架特徵介紹(詳細的去看看動力節點的java基礎大全301集就知道了）
Collection介面結構
其中，有幾個比較常用的方法，比如方法add()添加一個元素到集合中，addAll()將指定集合中的所有元素添加到集合中，contains()方法檢測集合中是否包含指定的元素，toArray()方法返回一個表示集合的數組。Collection介面有三個子介面，下面詳細介紹。
1.List
List介面擴展自Collection，它可以定義一個允許重復的有序集合，從List介面中的方法來看，List介面主要是增加了面向位置的操作，允許在指定位置上操作元素，同時增加了一個能夠雙向遍歷線性表的新列表迭代器ListIterator。AbstractList類提供了List介面的部分實現，AbstractSequentialList擴展自AbstractList，主要是提供對鏈表的支持。下面介紹List介面的兩個重要的具體實現類，也是我們可能最常用的類，ArrayList和LinkedList。
ArrayList
通過閱讀ArrayList的源碼，我們可以很清楚地看到裡面的邏輯，它是用數組存儲元素的，這個數組可以動態創建，如果元素個數超過了數組的容量，那麼就創建一個更大的新數組，並將當前數組中的所有元素都復制到新數組中。假設第一次是集合沒有任何元素，下面以插入一個元素為例看看源碼的實現。
1、方法add(E e)向集合中添加指定元素。 public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e; return true;
}2、此方法主要是確定將要創建的數組大小。 private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
} private void ensureExplicitCapacity(int minCapacity) {
modCount++; if (minCapacity - elementData.length > 0)
grow(minCapacity);
}3、最後是創建數組，可以明顯的看到先是確定了添加元素後的大小之後將元素復制到新數組中。 private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0)
newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win:
elementData = Arrays.Of(elementData, newCapacity);
}
LinkedList
同樣，我們打開LinkedList的源文件，不難看到LinkedList是在一個鏈表中存儲元素。
在學習數據結構的時候，我們知道鏈表和數組的最大區別在於它們對元素的存儲方式的不同導致它們在對數據進行不同操作時的效率不同，同樣，ArrayList與LinkedList也是如此，實際使用中我們需要根據特定的需求選用合適的類，如果除了在末尾外不能在其他位置插入或者刪除元素，那麼ArrayList效率更高，如果需要經常插入或者刪除元素，就選擇LinkedList。
2.Set
Set介面擴展自Collection，它與List的不同之處在於，規定Set的實例不包含重復的元素。在一個規則集內，一定不存在兩個相等的元素。AbstractSet是一個實現Set介面的抽象類，Set介面有三個具體實現類，分別是散列集HashSet、鏈式散列集LinkedHashSet和樹形集TreeSet。
散列集HashSet
散列集HashSet是一個用於實現Set介面的具體類，可以使用它的無參構造方法來創建空的散列集，也可以由一個現有的集合創建散列集。在散列集中，有兩個名詞需要關注，初始容量和客座率。客座率是確定在增加規則集之前，該規則集的飽滿程度，當元素個數超過了容量與客座率的乘積時，容量就會自動翻倍。
② java集合框架的底層原理（內存指針那一層），以及集合的最底層原理由來。謝謝
在底層要麼數組，要麼鏈表，只是在訪問方式上做了封裝，沒有什麼高深的原理。不必去了解內存指針什麼的，了解了也沒什麼用。如果你實在想看，有源碼。或者自己用數組實現一個集合類型，一切都明白了。
不光JAVA，其它的如C++，C# ，本質上都是一樣的。其中，C#封裝的最為優雅。
③ java集合類哪個函數可以
java集合裡面的函數
java集合裡面的函數_java集合【1】——— 從集合介面框架說起
百里方欣
原創
關注
0點贊·155人閱讀
(一) java集合分類
之前大概分為三種，Set，List，Map三種，JDK5之後，增加Queue.主要由Collection和Map兩個介面衍生出來,同時Collection介面繼承Iterable介面，所以我們也可以說java裡面的集合類主要是由Iterable和Map兩個介面以及他們的子介面或者其實現類組成。我們可以認為Collection介面定義了單列集合的規范，每次只能存儲一個元素，而Map介面定義了雙列集合的規范，每次能存儲一對元素。
Iterable介面:主要是實現遍歷功能
Collection介面: 允許重復
Set介面：無序，元素不可重復,訪問元素只能通過元素本身來訪問。
List介面：有序且可重復，可以根據元素的索引來訪問集合中的元素。
Queue介面：隊列集合
Map介面：映射關系，簡單理解為鍵值對，Key不可重復，與Collection介面關系不大，只是個別函數使用到。
整個介面框架關系如下(來自網路)：
(1) Iterable介面
1. 內部定義的方法
java集合最源頭的介面，實現這個介面的作用主要是集合對象可以通過迭代器去遍歷每一個元素。
源碼如下：
// 返回一個內部元素為T類型的迭代器(JDK1.5隻有這個介面)
Iterator iterator();
// 遍歷內部元素，action意思為動作，指可以對每個元素進行操作(JDK1.8添加)
default void forEach(Consumer super T> action) {}
// 創建並返回一個可分割迭代器(JDK1.8添加)，分割的迭代器主要是提供可以並行遍歷元素的迭代器，可以適應現在cpu多核的能力，加快速度。
default Spliterator spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
從上面可以看出，foreach迭代以及可分割迭代，都加了default關鍵字，這個是Java 8 新的關鍵字，以前介面的所有介面，具體子類都必須實現，而對於deafult關鍵字標識的方法，其子類可以不用實現，這也是介面規范發生變化的一點。
下面我們分別展示三個介面的調用：
1.1 iterator方法
public static void iteratorHasNext(){
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
// 返回迭代器
Iterator iterator=list.iterator();
// hashNext可以判斷是否還有元素
while(iterator.hasNext()){
//next()作用是返回當前指針指向的元素,之後將指針移向下個元素
System.out.println(iterator.next());
}
}
當然也可以使用for-each loop方式遍歷
for (String item : list) {
System.out.println(item);
}
但是實際上，這種寫法在class文件中也是會轉成迭代器形式，這只是一個語法糖。class文件如下：
public class IterableTest {
public IterableTest() { }
public static void main(String[] args) {
iteratorHasNext();
}
public static void iteratorHasNext() {
List list = new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
Iterator iterator = list.iterator();
Iterator var2 = list.iterator();
while(var2.hasNext()) {
String item = (String)var2.next();
System.out.println(item);
}
}
}
需要注意的一點是，迭代遍歷的時候，如果刪除或者添加元素，都會拋出修改異常，這是由於快速失敗【fast-fail】機制。
public static void iteratorHasNext(){
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
for (String item : list) {
if(item.equals("Jam")){
list.remove(item);
}
System.out.println(item);
}
}
從下面的錯誤我們可以看出，第一個元素是有被列印出來的，也就是remove操作是成功的，只是遍歷到第二個元素的時候，迭代器檢查，發現被改變了，所以拋出了異常。
Jam
Exception in thread "main" java.util.
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at IterableTest.iteratorHasNext(IterableTest.java:15)
at IterableTest.main(IterableTest.java:7)
1.2 forEach方法
其實就是把對每一個元素的操作當成了一個對象傳遞進來，對每一個元素進行處理。
default void forEach(Consumer super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
```java
當然像ArrayList自然也是有自己的實現的，那我們就可以使用這樣的寫法,簡潔優雅。forEach方法在java8中參數是`java.util.function.Consumer`,可以稱為**消費行為**或者說**動作**類型。
```java
list.forEach(x -> System.out.print(x));
同時，我們只要實現Consumer介面，就可以自定義動作，如果不自定義，默認迭代順序是按照元素的順序。
public class ConsumerTest {
public static void main(String[] args) {
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
MyConsumer myConsumer = new MyConsumer();
Iterator it = list.iterator();
list.forEach(myConsumer);
}
static class MyConsumer implements Consumer {
@Override
public void accept(Object t) {
System.out.println("自定義列印：" + t);
}
}
}
輸出的結果：
自定義列印：Jam
自定義列印：Jane
自定義列印：Sam
1.3 spliterator方法
這是一個為了並行遍歷數據元素而設計的迭代方法，返回的是Spliterator，是專門並行遍歷的迭代器。以發揮多核時代的處理器性能，java默認在集合框架中提供了一個默認的Spliterator實現，底層也就是Stream.isParallel()實現的，我們可以看一下源碼：
// stream使用的就是spliterator
default Stream stream() {
return StreamSupport.stream(spliterator(), false);
}
default Spliterator spliterator() {
return Spliterators.spliterator(this, 0);
}
public static Stream stream(Spliterator spliterator, boolean parallel) {
Objects.requireNonNull(spliterator);
return new ReferencePipeline.Head<>(spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
parallel);
}
使用的方法如下：
public static void spliterator(){
List list = Arrays.asList("1", "2", "3","4","5","6","7","8","9","10");
// 獲取可迭代器
Spliterator spliterator = list.spliterator();
// 一個一個遍歷
System.out.println("tryAdvance: ");
spliterator.tryAdvance(item->System.out.print(item+" "));
spliterator.tryAdvance(item->System.out.print(item+" "));
System.out.println("\n-------------------------------------------");
// 依次遍歷剩下的
System.out.println("forEachRemaining: ");
spliterator.forEachRemaining(item->System.out.print(item+" "));
System.out.println("\n------------------------------------------");
// spliterator1:0~10
Spliterator spliterator1 = list.spliterator();
// spliterator1:6~10 spliterator2:0~5
Spliterator spliterator2 = spliterator1.trySplit();
// spliterator1:8~10 spliterator3:6~7
Spliterator spliterator3 = spliterator1.trySplit();
System.out.println("spliterator1: ");
spliterator1.forEachRemaining(item->System.out.print(item+" "));
System.out.println("\n------------------------------------------");
System.out.println("spliterator2: ");
spliterator2.forEachRemaining(item->System.out.print(item+" "));
System.out.println("\n------------------------------------------");
System.out.println("spliterator3: ");
spliterator3.forEachRemaining(item->System.out.print(item+" "));
}
tryAdvance() 一個一個元素進行遍歷
forEachRemaining() 順序地分塊遍歷
trySplit()進行分區形成另外的 Spliterator，使用在並行操作中，分出來的是前面一半，就是不斷把前面一部分分出來
結果如下：
tryAdvance:
1 2
-------------------------------------------
forEachRemaining:
3 4 5 6 7 8 9 10
------------------------------------------
spliterator1:
8 9 10
------------------------------------------
spliterator2:
1 2 3 4 5
------------------------------------------
spliterator3:
6 7
還有一些其他的用法在這里就不列舉了，主要是trySplit()之後，可以用於多線程遍歷。理想的時候，可以平均分成兩半，有利於並行計算，但是不是一定平分的。
2. Collection介面 extend Iterable
Collection介面可以算是集合類的一個根介面之一，一般不能夠直接使用，只是定義了一個規范，定義了添加，刪除等管理數據的方法。繼承Collection介面的有List，Set,Queue,不過Queue定義了自己的一些介面，相對來說和其他的差異比較大。
2.1 內部定義的方法
源碼如下：
boolean add(Object o) //添加元素
boolean remove(Object o) //移除元素
boolean addAll(Collection c) //批量添加
boolean removeAll(Collection c) //批量移除
void retainAll(Collection c) // 移除在c中不存在的元素
void clear() //清空集合
int size() //集合大小
boolean isEmpty() //是否為空
boolean contains(Object o) //是否包含在集合中
boolean containsAll(Collection c) //是否包含所有的元素
Iterator iterator() // 獲取迭代器
Object[] toArray() // 轉成數組
default boolean removeIf(Predicate super E> filter) {} // 刪除集合中復合條件的元素，刪除成功返回true
boolean equals(Object o)
int hashCode()
default Spliterator spliterator() {} //獲取可分割迭代器
default Stream stream() {} //獲取流
default Stream parallelStream() {} //獲取並行流
裡面獲取並行流的方法parallelStream(),其實就是通過默認的ForkJoinPool(主要用來使用分治法(Divide-and-Conquer Algorithm)來解決問題)，提高多線程任務的速度。我們可以使用ArrayList來演示一下平行處理能力。例如下面的例子，輸出的順序就不一定是1,2,3...，可能是亂序的，這是因為任務會被分成多個小任務，任務執行是沒有特定的順序的。
List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
list.parallelStream()
.forEach(out::println);
2.2 繼承Collection的主要介面
graph LR;
Collection -->List-有順序,可重復
List-有順序,可重復 -->LinkedList-使用鏈表實現,線程不安全
List-有順序,可重復 -->ArrayList-數組實現,線程不安全
List-有順序,可重復 -->Vector-數組實現,線程安全
Vector-數組實現,線程安全 -->Stack-堆棧,先進後出
Collection-->Set-不可重復,內部排序
Set-不可重復,內部排序-->HashSet-hash表存儲
HashSet-hash表存儲-->LinkHashSet-鏈表維護插入順序
Set-不可重復,內部排序-->TreeSet-二叉樹實現,排序
Collection-->Queue-隊列,先進先出
2.2.1 List extend Collection
繼承於Collection介面，有順序，取出的順序與存入的順序一致，有索引，可以根據索引獲取數據，允許存儲重復的元素，可以放入為null的元素。
最常見的三個實現類就是ArrayList，Vector,LinkedList，ArrayList和Vector都是內部封裝了對數組的操作，唯一不同的是，Vector是線程安全的，而ArrayList不是，理論上ArrayList操作的效率會比Vector好一些。
裡面是介面定義的方法：
int size(); //獲取大小
boolean isEmpty(); //判斷是否為空
boolean contains(Object o); //是否包含某個元素
Iterator iterator(); //獲取迭代器
Object[] toArray(); // 轉化成為數組(對象)
T[] toArray(T[] a); // 轉化為數組(特定位某個類)
boolean add(E e); //添加
boolean remove(Object o); //移除元素
boolean containsAll(Collection> c); // 是否包含所有的元素
boolean addAll(Collection extends E> c); //批量添加
boolean addAll(int index, Collection extends E> c); //批量添加，指定開始的索引
boolean removeAll(Collection> c); //批量移除
boolean retainAll(Collection> c); //將c中不包含的元素移除
default void replaceAll(UnaryOperator operator) {}//替換
default void sort(Comparator super E> c) {}// 排序
void clear();//清除所有的元素
boolean equals(Object o);//是否相等
int hashCode(); //計算獲取hash值
E get(int index); //通過索引獲取元素
E set(int index, E element);//修改元素
void add(int index, E element);//在指定位置插入元素
E remove(int index);//根據索引移除某個元素
int indexOf(Object o); //根據對象獲取索引
int lastIndexOf(Object o); //獲取對象元素的最後一個元素
ListIterator listIterator(); // 獲取List迭代器
ListIterator listIterator(int index); // 根據索引獲取當前的位置的迭代器
List subList(int fromIndex, int toIndex); //截取某一段數據
default Spliterator spliterator(){} //獲取可切分迭代器
上面的方法都比較簡單，值得一提的是裡面出現了ListIterator，這是一個功能更加強大的迭代器，繼承於Iterator,只能用於List類型的訪問，拓展功能例如：通過調用listIterator()方法獲得一個指向List開頭的ListIterator，也可以調用listIterator(n)獲取一個指定索引為n的元素的ListIterator,這是一個可以雙向移動的迭代器。
操作數組索引的時候需要注意，由於List的實現類底層很多都是數組，所以索引越界會報錯IndexOutOfBoundsException。
說起List的實現子類：
ArrayList：底層存儲結構是數組結構，增加刪除比較慢，查找比較快，是最常用的List集合。線程不安全。
LinkedList：底層是鏈表結構，增加刪除比較快，但是查找比較慢。線程不安全。
Vector：和ArrayList差不多，但是是線程安全的，即同步。
2.2.2 Set extend Collection
Set介面，不允許放入重復的元素，也就是如果相同，則只存儲其中一個。
下面是源碼方法：
int size(); //獲取大小
boolean isEmpty(); //是否為空
boolean contains(Object o); //是否包含某個元素
Iterator iterator(); //獲取迭代器
Object[] toArray(); //轉化成為數組
T[] toArray(T[] a); //轉化為特定類的數組
boolean add(E e); //添加元素
boolean remove(Object o); //移除元素
boolean containsAll(Collection> c); //是否包含所有的元素
boolean addAll(Collection extends E> c); //批量添加
boolean retainAll(Collection> c); //移除所有不存在於c集合中的元素
boolean removeAll(Collection> c); //移除所有在c集合中存在的元素
void clear(); //清空集合
boolean equals(Object o); //是否相等
int hashCode(); //計算hashcode
default Spliterator spliterator() {} //獲取可分割迭代器
主要的子類：
HashSet
允許空值
通過HashCode方法計算獲取hash值，確定存儲位置，無序。
LinkedHashSet
HashSet的子類
有順序
TreeSet
如果無參數構建Set，則需要實現Comparable方法。
亦可以創建時傳入比較方法，用於排序。
2.2.3 Queue extend Collection
隊列介面，在Collection介面的接觸上添加了增刪改查介面定義，一般默認是先進先出，即FIFO，除了優先隊列和棧，優先隊列是自己定義了排序的優先順序，隊列中不允許放入null元素。
下面是源碼：
boolean add(E e); //插入一個元素到隊列，失敗時返回IllegalStateException (如果隊列容量不夠)
boolean offer(E e); //插入一個元素到隊列，失敗時返回false
E remove(); //移除隊列頭的元素並移除
E poll(); //返回並移除隊列的頭部元素，隊列為空時返回null
E element(); //返回隊列頭元素
E peek(); //返回隊列頭部的元素，隊列為空時返回null
主要的子介面以及實現類有：
Deque(介面):Queue的子介面，雙向隊列，可以從兩邊存取
ArrayDeque：Deque的實現類，底層用數組實現，數據存貯在數組中
AbstractQueue：Queue的子介面，僅實現了add、remove和element三個方法
PriorityQueue：按照默認或者自己定義的順序來排序元素，底層使用堆(完全二叉樹)實現，使用動態數組實現，
BlockingQueue： 在java.util.concurrent包中，阻塞隊列，滿足當前無法處理的操作。
(2) Map介面
定義雙列集合的規范Map，每次存儲一對元素，即key和value。
key的類型可以和value的類型相同，也可以不同，任意的引用類型都可以。
key是不允許重復的，但是value是可以重復的，所謂重復是指計算的hash值系統。
下面的源碼的方法：
V put(K key, V value); // 添加元素
V remove(Object key); // 刪除元素
void putAll(Map extends K, ? extends V> m); // 批量添加
void clear() // 移除所有元素
V get(Object key); // 通過key查詢元素
int size(); // 查詢集合大小
boolean isEmpty(); // 集合是否為空
boolean containsKey(Object key); // 是否包含某個key
boolean containsValue(Object value); // 是否包含某個value
Set keySet(); // 獲取所有key的set集合
Collection values(); // 獲取所有的value的set集合
Set> entrySet(); // 返回鍵值對的set，每一個鍵值對是一個entry對象
boolean equals(Object o); // 用於比較的函數
int hashCode(); // 計算hashcode
default V getOrDefault(Object key, V defaultValue) // 獲取key對應的Value，沒有則返回默認值()
default void forEach(BiConsumer super K, ? super V> action) {} // 遍歷
default void replaceAll(BiFunction super K, ? super V, ? extends V> function) {} // 批量替換
// 缺少這個key的時候才會添加進去
// 返回值是是key對應的value值，如果不存在，則返回的是剛剛放進去的value
default V putIfAbsent(K key, V value) {}
default boolean remove(Object key, Object value) {} // 移除元素
default boolean replace(K key, V oldValue, V newValue) {} // 替換
default V replace(K key, V value) {} //替換
// 和putIfAbsent有點像，只不過傳進去的mappingFunction是映射函數，也就是如果不存在key對應的value，將會執行函數，函數返回值會被當成value添加進去，同時返回新的value值
default V computeIfAbsent(K key,Function super K, ? extends V> mappingFunction) {}
// 和computeIfAbsent方法相反，只有key存在的時候，才會執行函數，並且返回
default V computeIfPresent(K key,BiFunction super K, ? super V, ? extends V> remappingFunction) {}
// 不管如何都會執行映射函數，返回value
default V compute(K key,BiFunction super K, ? super V, ? extends V> remappingFunction) {}
default V merge(K key, V value,BiFunction super V, ? super V, ? extends V> remappingFunction) {}
值得注意的是，Map裡面定義了一個Entry類，其實就是定義了一個存儲數據的類型，一個entry就是一個.
Map的常用的實現子類：
HashMap：由數組和鏈表組成，線程不安全，無序。
LinkedHashMap：如果我們需要是有序的，那麼就需要它，時間和空間效率沒有HashMap那麼高，底層是維護一條雙向鏈表，保證了插入的順序。
ConcurrentHashMap：線程安全，1.7JDK使用鎖分離，每一段Segment都有自己的獨立鎖，相對來說效率也比較高。JDK1.8拋棄了Segment，使用Node數組+鏈表和紅黑樹實現，在線程安全控制上使用Synchronize和CAS，可以認為是優化的線程安全的HashMap。
HashTable：對比與HashMap主要是使用關鍵字synchronize，加上同步鎖，線程安全。
(二)總結
這些集合原始介面到底是什麼？為什麼需要？
我想，這些介面其實都是一種規則/規范的定義，如果不這么做也可以，所有的子類自己實現，但是從迭代以及維護的角度來說，這就是一種抽象或者分類，比如定義了Iterator介面，某一些類就可以去繼承或者實現，那就得遵守這個規范/契約。可以有所拓展，每個子類的拓展不一樣，所以每個類就各有所長，但是都有一個中心，就是原始的集合介面。比如實現Map介面的所有類的中心思想都不變，只是各有所長，各分千秋，形成了大千集合世界。
【作者簡介】：
秦懷，公眾號【秦懷雜貨店】作者，技術之路不在一時，山高水長，縱使緩慢，馳而不息。個人寫作方向：Java源碼解析，JDBC，Mybatis，Spring，redis，分布式，劍指Offer，LeetCode等，認真寫好每一篇文章，不喜歡標題黨，不喜歡花里胡哨，大多寫系列文章，不能保證我寫的都完全正確，但是我保證所寫的均經過實踐或者查找資料。遺漏或者錯誤之處，還望指正。
平日時間寶貴，只能使用晚上以及周末時間學習寫作，關注我，我們一起成長吧~
④ JAVA集合框架的總結
1.數組把對象和數字形式的下標聯系起來。它持有的是類型確定的對象，這樣提取對象的時候就不用再作類型傳遞了。它可以是多維的，也可以持有primitive。但是創建之後它的容量不能改了。
2.Collection持有單個元素，而Map持有相關聯的pair。
3.和數組一樣，List也把數字下標同對象聯系起來，你可以把數組和List想成有序的容器。List會隨元素的增加自動調整容量。但是List只能持有Objectreference，所以不能存放primitive，而且把Object提取出來之後，還要做類型傳遞。
4.如果要做很多隨機訪問，那麼請用ArrayList，但是如果要再List的中間做很多插入和刪除的話，就應該用LinkedList了。
5.LinkedList能提供隊列，雙向隊列和棧的功能。
6.Map提供的不是對象與數組的關聯，而是對象和對象的關聯。
HashMap看重的是訪問速度，而TreeMap看重鍵的順序，因而它不如HashMap那麼快。而LinkedHashMap則保持對象插入的順序，但是也可以用LRU演算法為它重新排序。
7.Set只接受不重復的對象。HashSet提供了最快的查詢速度。而TreeSet則保持元素有序。LinkedHashSet保持元素的插入順序。
8.沒必要再在新代碼里使用舊類庫留下來的Vector，Hashtable和Stack了。
容器類庫是你每天都會用到的工具，它能使程序更簡潔，更強大並且更高效。
隨著Java的進一步完善，它的功能和易用性也得到提高，我有理由相信Java在計算機語言中所佔的位置也會更加牢固，讓喜愛Java的人更加喜愛它。祝願Java一路順風！
⑤ java.util的集合框架集合
java的集合框架為程序提供了一種處理對象組的標准方式。設計了一系列標准泛型介面：
⑴Collection （）介面，擴展了Iterable介面，位於集合層次結構的頂部，因此所有的集合都實現Collection介面，並提供了iterator（）方法來返回一個迭代器。用add（）方法添加對象，remove方法（）刪除元素，clear（）刪除集合所有元素（size=0），contains（）方法查看集合是否包含對象，toArray（）方法返回集合元素數組，equals（）方法比較兩個集合是否相等，size（）方法返回集合中元素的數目，isEmpty（）判斷集合是否為空，hashCode（）返回調用集合的散列碼，iterator（）返回調用集合的迭代器。
⑵List（）介面，擴展了Collection介面，存儲一個序列的元素（列表基於0的索引），可以包含重復的元素，但不能有null值。獲得特定位置的對象調用get（）方法，用set（）方法給特定位置元素賦值，用indexOf（）或lastIndexOf（）方法分別獲得對象的第一個實例或最後一個實例所在的位置，subList（）方法取子列表，listIterator（）返回一個迭代器。
⑶Set介面，擴展了Collection介面，該集合不允許存在相同的元素（包括唯一null值）。SortedSet介面，擴展了Set介面並聲明自已是升序的集合。First（）或Last（）方法分別獲得第一或最後一個對象，subSet（）獲得子集，headSet（）和tailSet（）方法分別獲得從頭開始或直到末尾的子集。
⑷Queue（隊列）介面，擴展了Collection介面，並聲明一個隊列行為（FIFO,先進先出列表）。Offer（）方法在隊列尾插入元素。element（）和peek（）方法獲得但不移除隊列的第一個元素，如果隊列為空，element（）拋出NoSuchElementException異常，peek（）返回null。poll（）和remove（）方法獲得並移除隊列的第一個元素，如果隊列為空，poll（）返回null，remove（）拋出異常。
⑸Comparator（比較器）介面，定義了兩個方法：compare（）和equals（）方法，通過改寫compare（）方法，能夠改變對象排序的方式。
⑹Iterator（迭代器）介面、ListIterator（列表迭代器，可進行雙向遍歷）介面，一般來說，使用迭代器在集合中遍歷時應遵循下面的步驟：一通過集合的iterator（）得到一個指向集合開始處的迭代器：Iterator itr=collectionObject.iterator（）；二設置一個判斷是否有下一個元素的循環：如while（itr.hasNext（））{。三在循環中取出下一個元素：如Object element=itr.next（）；
⑺RandomAccess（隨機訪問）介面。被ArrayList類和遺留的Vector類實現。
⑻Map（映射）介面、Map.Entry （Map的嵌套類、內部類）介面、SortedMap（默認按key鍵升序排列的映射）介面。映射是將鍵映射到值的對象，一個映射不能包含重復的鍵；每個鍵最多隻能映射一個值。Map介面提供三種collection 視圖：鍵集、值集合或鍵-值映射關系集。映射不是集合，因為它們不實現Collection介面，但是可以通過使用entrySet（）方法獲得鍵-值映射關系的集合視圖跟效果，或使用keySet（）方法獲得鍵的集合視圖，使用values（）方法獲得值的集合視圖。put（）方法將值放入映射中，get（）得到與鍵k相關聯的值。SortedMap介面增加了獲取子映射的headMap（）、tailMap（）、subMap（）方法和獲取首尾鍵的firstKey（）、lastKey（）方法。Map.Entry介面定義了獲取鍵值的getKey（）、getValue（）方法和替換值的setValue（）方法。
Collection集合的有序是Set，Map的有序是TreeMap。
異常：試圖增加一個不兼容的對象到集合或映射中，將拋出ClassCastException；如果使用無效索引，拋出IndexOutOfBoundException；null不允許存在於集合或映射中，如果試圖使用null對象，拋出NullPointException；當修改不可改變的集合或映射時，拋出UnsupportedOperationException；當調用下一個對象不存在時，拋出NoSuchElementException；集合框架介面示意（父類∈子類）：1、Collection∈⑴List,⑵Set∈SortedSet。2、Map∈SortedMap。
⑥ JAVA集合框架的介紹
Java，是由Sun公司於1995年推出的編程語言。用Java實現的HotJava瀏覽器（支持Java applet）顯示了Java的魅力：跨平台、動態的Web、Internet計算。從此，Java被廣泛接受並推動了Web的迅速發展，常用的瀏覽器現在均支持Java applet。集合框架是為表示和操作集合而規定的一種統一的標準的體系結構。任何集合框架都包含三大塊內容：對外的介面、介面的實現和對集合運算的演算法。