新集合

這張圖剛開始的時候可能讓人有點兒摸不著頭腦，相信大家會真正理解它實際只有三個集合組件： Map， List 和 Set。而且每個組件實際只有兩、三種實現方式
虛線框代表“接口”，點線框代表“抽象”類，而實線框代表普通（實際）類。點線箭頭表示一個特定的類準備實現一個接口（在抽象類的情況下，則是“部分”實現一個接口）。雙線箭頭表示一個類可生成箭頭指向的那個類的對象。
致力于容納對象的接口是 Collection， List， Set 和 Map。在傳統情況下，我們需要寫大量代碼才能同這些接口打交道。而且為了指定自己想使用的準確類型，必須在創建之初進行設置。所以可能創建下面這樣的一
個 List：

List x = new LinkedList();

當然，也可以決定將 x 作為一個 LinkedList 使用（而不是一個普通的 List），并用 x 負載準確的類型信息。使用接口的好處就是一旦決定改變自己的實施細節，要做的全部事情就是在創建的時候改變它，就象下面這樣：

List x = new ArrayList();

在類的分級結構中，可看到大量以“ Abstract ”（抽象）開頭的類，這剛開始可能會使人感覺迷惑。它們實際上是一些工具，用于“部分”實現一個特定的接口。舉個例子來說，假如想生成自己的Set，就不是從 Set接口開始，然后自行實現所有方法。相反，我們可以從 AbstractSet 繼承，只需極少的工作即可得到自己的新類。盡管如此，新集合庫仍然包含了足夠的功能，可滿足我們的幾乎所有需求。所以考慮到我們的目的，可忽略所有以“ Abstract”開頭的類。
因此，在觀看這張示意圖時，真正需要關心的只有位于最頂部的“接口”以及普通（實際）類—— 均用實線方框包圍。通常需要生成實際類的一個對象，將其上溯造型為對應的接口。以后即可在代碼的任何地方使用那個接口。下面是一個簡單的例子，它用 String 對象填充一個集合，然后打印出集合內的每一個元素：

public class SimpleCollection {public static void main(String[] args) {Collection c = new ArrayList();for (int i = 0; i < 10; i++)c.add(Integer.toString(i));Iterator it = c.iterator();while (it.hasNext())System.out.println(it.next());} }

main()的第一行創建了一個 ArrayList 對象，然后將其上溯造型成為一個集合。由于這個例子只使用了Collection 方法，所以從 Collection 繼承的一個類的任何對象都可以正常工作。但 ArrayList 是一個典型的 Collection，它代替了 Vector 的位置。
add()方法的作用是將一個新元素置入集合里。然而，用戶文檔謹慎地指出 add()“保證這個集合包含了指定的元素”。這一點是為 Set 作鋪墊的，后者只有在元素不存在的前提下才會真的加入那個元素。對于ArrayList 以及其他任何形式的 List， add()肯定意味著“直接加入”。
利用 iterator()方法，所有集合都能生成一個“反復器”（ Iterator）。反復器其實就象一個“枚舉”（ Enumeration），是后者的一個替代物，只是：
(1) 它采用了一個歷史上默認、而且早在 OOP 中得到廣泛采納的名字（反復器）。
(2) 采用了比 Enumeration 更短的名字： hasNext()代替了 hasMoreElement()，而 next()代替了nextElement()。
(3) 添加了一個名為 remove()的新方法，可刪除由 Iterator 生成的上一個元素。所以每次調用 next()的時候，只需調用 remove()一次

使用 C o l l e c t i o n s

下面這張表格總結了用一個集合能做的所有事情（亦可對 Set 和 List 做同樣的事情，盡管 List 還提供了一
些額外的功能）。 Map 不是從 Collection 繼承的，所以要單獨對待

boolean add(Object) ＊保證集合內包含了自變量。如果它沒有添加自變量，就返回 false（假）
boolean addAll(Collection) ＊添加自變量內的所有元素。如果沒有添加元素，則返回 true（真）
void clear() ＊刪除集合內的所有元素
boolean contains(Object) 若集合包含自變量，就返回“真”
boolean containsAll(Collection) 若集合包含了自變量內的所有元素，就返回“真”
boolean isEmpty() 若集合內沒有元素，就返回“真”
Iterator iterator() 返回一個反復器，以用它遍歷集合的各元素
boolean remove(Object) ＊如自變量在集合里，就刪除那個元素的一個實例。如果已進行了刪除，就返回
“真”
boolean removeAll(Collection) ＊刪除自變量里的所有元素。如果已進行了任何刪除，就返回“真”
boolean retainAll(Collection) ＊只保留包含在一個自變量里的元素（一個理論的“交集”）。如果已進
行了任何改變，就返回“真”
int size() 返回集合內的元素數量
Object[] toArray() 返回包含了集合內所有元素的一個數組
＊這是一個“可選的”方法，有的集合可能并未實現它。若確實如此，該方法就會遇到一個
UnsupportedOperatiionException，即一個“操作不支持”違例。

下面這個例子向大家演示了所有方法。同樣地，它們只對從集合繼承的東西有效，一個ArrayList 作為一種“不常用的分母”使用

public class Collection1 {// Fill with 'size' elements, start// counting at 'start':public static Collection fill(Collection c, int start, int size) {for (int i = start; i < start + size; i++)c.add(Integer.toString(i));return c;}// Default to a "start" of 0:public static Collection fill(Collection c, int size) {return fill(c, 0, size);}// Default to 10 elements:public static Collection fill(Collection c) {return fill(c, 0, 10);}// Create & upcast to Collection:public static Collection newCollection() {return fill(new ArrayList());// ArrayList is used for simplicity, but it's// only seen as a generic Collection// everywhere else in the program.}// Fill a Collection with a range of values:public static Collection newCollection(int start, int size) {return fill(new ArrayList(), start, size);}// Moving through a List with an iterator:public static void print(Collection c) {for (Iterator x = c.iterator(); x.hasNext();)System.out.print(x.next() + " ");System.out.println();}public static void main(String[] args) {Collection c = newCollection();c.add("ten");c.add("eleven");print(c);// Make an array from the List:Object[] array = c.toArray();// Make a String array from the List:String[] str = (String[]) c.toArray(new String[1]);// Find max and min elements; this means// different things depending on the way// the Comparable interface is implemented:System.out.println("Collections.max(c) = " + Collections.max(c));System.out.println("Collections.min(c) = " + Collections.min(c));// Add a Collection to another Collectionc.addAll(newCollection());print(c);c.remove("3"); // Removes the first oneprint(c);c.remove("3"); // Removes the second oneprint(c);// Remove all components that are in the// argument collection:c.removeAll(newCollection());print(c);c.addAll(newCollection());print(c);// Is an element in this Collection?System.out.println("c.contains(\"4\") = " + c.contains("4"));// Is a Collection in this Collection?System.out.println("c.containsAll(newCollection()) = "+ c.containsAll(newCollection()));Collection c2 = newCollection(5, 3);// Keep all the elements that are in both// c and c2 (an intersection of sets):c.retainAll(c2);print(c);// Throw away all the elements in c that// also appear in c2:c.removeAll(c2);System.out.println("c.isEmpty() = " + c.isEmpty());c = newCollection();print(c);c.clear(); // Remove all elementsSystem.out.println("after c.clear():");print(c);} }

newCollection()的兩個版本都創建了 ArrayList，用于包含不同的數據集，并將它們作為集合對象返回。所以很明顯，除了 Collection 接口之外，不會再用到其他什么。

使用 L i s t s

List（接口） 順序是 List 最重要的特性；它可保證元素按照規定的順序排列。 List 為 Collection 添加了大量方法，以便我們在 List 中部插入和刪除元素（只推薦對 LinkedList 這樣做）。 List 也會生成一個ListIterator（列表反復器），利用它可在一個列表里朝兩個方向遍歷，同時插入和刪除位于列表中部的元素（同樣地，只建議對 LinkedList 這樣做）
ArrayList 由一個數組后推得到的 List。作為一個常規用途的對象容器使用，用于替換原先的 Vector。允許我們快速訪問元素，但在從列表中部插入和刪除元素時，速度卻嫌稍慢。一般只應該用ListIterator 對一個 ArrayList 進行向前和向后遍歷，不要用它刪除和插入元素；與 LinkedList 相比，它的效率要低許多LinkedList 提供優化的順序訪問性能，同時可以高效率地在列表中部進行插入和刪除操作。但在進行隨機訪問時，速度卻相當慢，此時應換用 ArrayList。
也提供了 addFirst()， addLast()， getFirst()，getLast()， removeFirst() 以及 removeLast()（未在任何接口或基礎類中定義），以便將其作為一個規格、隊列以及一個雙向隊列使用

public class List1 {// Wrap Collection1.fill() for convenience:public static List fill(List a) {return (List) Collection1.fill(a);}// You can use an Iterator, just as with a// Collection, but you can also use random// access with get():public static void print(List a) {for (int i = 0; i < a.size(); i++)System.out.print(a.get(i) + " ");System.out.println();}static boolean b;static Object o;static int i;static Iterator it;static ListIterator lit;public static void basicTest(List a) {a.add(1, "x"); // Add at location 1a.add("x"); // Add at end// Add a collection:a.addAll(fill(new ArrayList()));// Add a collection starting at location 3:a.addAll(3, fill(new ArrayList()));b = a.contains("1"); // Is it in there?// Is the entire collection in there?b = a.containsAll(fill(new ArrayList()));// Lists allow random access, which is cheap// for ArrayList, expensive for LinkedList:o = a.get(1); // Get object at location 1i = a.indexOf("1"); // Tell index of object// indexOf, starting search at location 2:i = a.indexOf("1", 2);b = a.isEmpty(); // Any elements inside?it = a.iterator(); // Ordinary Iteratorlit = a.listIterator(); // ListIteratorlit = a.listIterator(3); // Start at loc 3i = a.lastIndexOf("1"); // Last matchi = a.lastIndexOf("1", 2); // ...after loc 2a.remove(1); // Remove location 1a.remove("3"); // Remove this objecta.set(1, "y"); // Set location 1 to "y"// Keep everything that's in the argument// (the intersection of the two sets):a.retainAll(fill(new ArrayList()));// Remove elements in this range:a.removeRange(0, 2);// Remove everything that's in the argument:a.removeAll(fill(new ArrayList()));i = a.size(); // How big is it?a.clear(); // Remove all elements}public static void iterMotion(List a) {ListIterator it = a.listIterator();b = it.hasNext();b = it.hasPrevious();o = it.next();i = it.nextIndex();o = it.previous();i = it.previousIndex();}public static void iterManipulation(List a) {ListIterator it = a.listIterator();it.add("47");// Must move to an element after add():it.next();// Remove the element that was just produced:it.remove();// Must move to an element after remove():it.next();// Change the element that was just produced:it.set("47");}public static void testVisual(List a) {print(a);List b = new ArrayList();fill(b);System.out.print("b = ");print(b);a.addAll(b);a.addAll(fill(new ArrayList()));print(a);// Shrink the list by removing all the// elements beyond the first 1/2 of the listSystem.out.println(a.size());System.out.println(a.size() / 2);a.removeRange(a.size() / 2, a.size() / 2 + 2);print(a);// Insert, remove, and replace elements// using a ListIterator:ListIterator x = a.listIterator(a.size() / 2);x.add("one");print(a);System.out.println(x.next());x.remove();System.out.println(x.next());x.set("47");print(a);// Traverse the list backwards:x = a.listIterator(a.size());while (x.hasPrevious())System.out.print(x.previous() + " ");System.out.println();System.out.println("testVisual finished");}// There are some things that only// LinkedLists can do:public static void testLinkedList() {LinkedList ll = new LinkedList();Collection1.fill(ll, 5);print(ll);// Treat it like a stack, pushing:ll.addFirst("one");ll.addFirst("two");print(ll);// Like "peeking" at the top of a stack:System.out.println(ll.getFirst());// Like popping a stack:System.out.println(ll.removeFirst());System.out.println(ll.removeFirst());// Treat it like a queue, pulling elements// off the tail end:System.out.println(ll.removeLast());// With the above operations, it's a dequeue!print(ll);}public static void main(String args[]) {// Make and fill a new list each time:basicTest(fill(new LinkedList()));basicTest(fill(new ArrayList()));iterMotion(fill(new LinkedList()));iterMotion(fill(new ArrayList()));iterManipulation(fill(new LinkedList()));iterManipulation(fill(new ArrayList()));testVisual(fill(new LinkedList()));testLinkedList();} }

在 basicTest()和 iterMotiion() 中，只是簡單地發出調用，以便揭示出正確的語法。而且盡管捕獲了返回
值，但是并未使用它。在某些情況下，之所以不捕獲返回值，是由于它們沒有什么特別的用處。在正式使用
它們前，應仔細研究一下自己的聯機文檔，掌握這些方法完整、正確的用法。

ArrayList使用實例

import java.awt.List; import java.util.ArrayList; import java.util.Iterator; /** * @author sihai * @time 2018/4/19 * ArrayList用法示例說明 * */ public class Main { public static void main(String[] args) { //ArrayList用法示例 ArrayList<String> m_ArrayList=new ArrayList<String>(); m_ArrayList.add("Evankaka"); m_ArrayList.add("sihai"); m_ArrayList.add("德德"); m_ArrayList.add("Evankaka"); m_ArrayList.add("小紅"); m_ArrayList.set(2,"sihai2");// 將索引位置為2的對象修改 m_ArrayList.add(3,"好好學java");// 將對象添加到索引位置為3的位置 //ArrayList遍歷方法1 Iterator<String> it_ArrayList = m_ArrayList.iterator(); System.out.println("ArrayList遍歷方法1"); while (it_ArrayList.hasNext()) { System.out.println(it_ArrayList.next()); } //ArrayList遍歷方法2 System.out.println("ArrayList遍歷方法2"); for(Object o:m_ArrayList){ System.out.println(o); } //ArrayList遍歷方法2 System.out.println("ArrayList遍歷方法3"); for(int i = 0; i<m_ArrayList.size(); i++){ System.out.println(m_ArrayList.get(i)); } //刪除元素 m_ArrayList.remove("Evankaka"); it_ArrayList = m_ArrayList.iterator(); System.out.println("ArrayList刪除元素后的遍歷"); while (it_ArrayList.hasNext()) { String m_String=it_ArrayList.next(); if(m_String.equals("好好學java")){ it_ArrayList.remove(); }else{ System.out.println(m_String); } } } }

輸出結果：

ArrayList遍歷方法1
Evankaka
sihai
sihai2
好好學java
Evankaka
小紅
ArrayList遍歷方法2
Evankaka
sihai
sihai2
好好學java
Evankaka
小紅
ArrayList遍歷方法3
Evankaka
sihai
sihai2
好好學java
Evankaka
小紅
ArrayList刪除元素后的遍歷
sihai
sihai2
Evankaka
小紅

ArrayList注意

（1）使用Iterator迭代集合過程中，不可修改集合元素，否則會引發異常。并且Iterator只能向后迭代
（2）如果你想在循環過程中去掉某個元素,只能調用it.remove方法, 不能使用list.remove方法, 否則一定出并發訪問的錯誤.

總結

以上是生活随笔為你收集整理的java基础系列：集合基础（3）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。