1累贤、java.util.Collection 是一個集合接口（集合類的一個頂級接口）胚吁。它提供了對集合對象進(jìn)行基本操作的通用接口方法冷离。Collection接口在Java 類庫中有很多具體的實(shí)現(xiàn)近速。Collection接口的意義是為各種具體的集合提供了最大化的統(tǒng)一操作方式扭屁，其直接繼承接口有List與Set低缩。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set

Collection.png

1嘉冒、Collection接口
Collection是最基本集合接口，它定義了一組允許重復(fù)的對象咆繁。Collection接口派生了兩個子接口Set和List讳推，分別定義了兩種不同的存儲方式，如下：

2玩般、 Set接口
Set接口繼承于Collection接口银觅，它沒有提供額外的方法，但實(shí)現(xiàn)了Set接口的集合類中的元素是無序且不可重復(fù)坏为。
特征：無序且不可重復(fù)究驴。

3镊绪、 List接口
List接口同樣也繼承于Collection接口，但是與Set接口恰恰相反纳胧，List接口的集合類中的元素是對象有序且可重復(fù)镰吆。
特征：有序且可重復(fù)。
兩個重要的實(shí)現(xiàn)類：ArrayList和LinkedList
1.ArrayList特點(diǎn)是有序可重復(fù)的
2.LinkedList是一個雙向鏈表結(jié)構(gòu)的跑慕。

4万皿、Map接口
Map也是接口，但沒有繼承Collection接口核行。該接口描述了從不重復(fù)的鍵到值的映射牢硅。Map接口用于維護(hù)鍵/值對（key/value pairs）。
特征：它描述了從不重復(fù)的鍵到值的映射芝雪。
兩個重要的實(shí)現(xiàn)類：HashMap和TreeMap
1.HashMap减余，中文叫散列表，基于哈希表實(shí)現(xiàn)惩系，特點(diǎn)就是鍵值對的映射關(guān)系位岔。一個key對應(yīng)一個Value。HashMap中元素的排列順序是不固定的堡牡。更加適合于對元素進(jìn)行插入抒抬、刪除和定位。
2.TreeMap晤柄，基于紅黑書實(shí)現(xiàn)擦剑。TreeMap中的元素保持著某種固定的順序。更加適合于對元素的順序遍歷芥颈。

5惠勒、Iterator接口
Iterator接口，在C#里有例外一種說法IEnumerator爬坑，他們都是集合訪問器纠屋，用于循環(huán)訪問集合中的對象。 所有實(shí)現(xiàn)了Collection接口的容器類都有iterator方法妇垢，用于返回一個實(shí)現(xiàn)了Iterator接口的對象巾遭。Iterator對象稱作迭代器，Iterator接口方法能以迭代方式逐個訪問集合中各個元素闯估，并可以從Collection中除去適當(dāng)?shù)脑亍?/p>

2灼舍、java.util.Collections 是一個包裝類（工具類/幫助類）。它包含有各種有關(guān)集合操作的靜態(tài)多態(tài)方法涨薪。此類不能實(shí)例化骑素，就像一個工具類，用于對集合中元素進(jìn)行排序刚夺、搜索以及線程安全等各種操作献丑，服務(wù)于Java的Collection框架挤悉。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class TestCollections {
   
    public static void main(String args[]) {
        //注意List是實(shí)現(xiàn)Collection接口的
        List list = new ArrayList();
        double array[] = { 112, 111, 23, 456, 231 };
        for (int i = 0; i < array.length; i++) {
            list.add(new Double(array[i]));
        }
        Collections.sort(list);
        for (int i = 0; i < array.length; i++) {
            System.out.println(list.get(i));
        }
        // 結(jié)果：23.0 111.0 112.0 231.0 456.0
    }
}

Collections類里面包括動態(tài)盅视、有序汹粤、可變大小的一維數(shù)組Vector與ArrayList虫腋。
Vector與ArrayList，兩者唯一的差別是：vector自帶線程互斥妥畏，多個線程對其讀寫會拋出異常邦邦，而arraylist則允許多個線程讀寫，其他部分是一模一樣的醉蚁，換句話說燃辖，如果是單線程在讀寫，使用Vector與ArrayList沒有任何區(qū)別网棍，但現(xiàn)在編程基本都用ArrayList黔龟，使用Vector有點(diǎn)非主流了
1、Vector的使用如下：

public static void Vectortest() {
// Vector<Double>表示這個vector只能存放double
// Vector<String>表示這個vector只能存String
// 雖然Vector<Object> vector=new Vector<Object>();等價于Vector vector=new
// Vector();但是滥玷，eclipse中這樣寫會警告氏身，表示你這個Vector不規(guī)范，╮(╯▽╰)╭
Vector<Object> vector = new Vector<Object>();
vector.add(1.6);
vector.add(2.06);
vector.add(1);
System.out.println("單純的add表示從結(jié)尾加入元素：" + vector);
System.out.println("size()能求出vector的所含元素的個數(shù)：" + vector.size());
vector.remove(1);
System.out.println("remove(1)表示刪去第1個元素惑畴，由于計(jì)數(shù)從0開始观谦，也就是2.06這個元素：" + vector);
vector.remove(vector.lastElement());
System.out.println("刪去最后一個元素的vector為：" + vector);
vector.add(0, 1.8888);
System.out.println("在第0個位置加入1.8888這個元素：" + vector);
vector.set(0, "a");
System.out.println("把第0個位置這個元素改為a：" + vector);
}

這段方法如果在主函數(shù)調(diào)用：

System.out.println("======Vector數(shù)據(jù)結(jié)構(gòu)的測試開始======");
 Vectortest();
System.out.println("======Vector數(shù)據(jù)結(jié)構(gòu)的測試結(jié)束======");

運(yùn)行結(jié)果如下：
======Vector數(shù)據(jù)結(jié)構(gòu)的測試開始======
單純的add表示從結(jié)尾加入元素：[1.6, 2.06, 1]
size()能求出vector的所含元素的個數(shù)：3
remove(1)表示刪去第1個元素，由于計(jì)數(shù)從0開始桨菜，也就是2.06這個元素：[1.6, 1]
刪去最后一個元素的vector為：[1.6]
在第0個位置加入1.8888這個元素：[1.8888, 1.6]
把第0個位置這個元素改為a：[a, 1.6]
======Vector數(shù)據(jù)結(jié)構(gòu)的測試結(jié)束======

2、ArrayList

public static void ArrayListtest() {
ArrayList<Double> arraylist = new ArrayList<Double>();
arraylist.add(1.0);
arraylist.add(4.0);
arraylist.add(5.0);
arraylist.add(2.3);
System.out.println("單純的add表示從結(jié)尾加入元素：" + arraylist);
System.out.println("size()能求出所含元素的個數(shù)：" + arraylist.size());
arraylist.remove(1);
System.out.println("remove(1)表示刪去第1個元素捉偏，由于計(jì)數(shù)從0開始倒得，也就是4這個元素：" + arraylist);
arraylist.remove(arraylist.size() - 1);
System.out.println("刪去最后一個元素的arraylist為：" + arraylist);
arraylist.add(0, 1.8888);
System.out.println("在第0個位置加入1.8888這個元素：" + arraylist);
arraylist.set(0, 9.0);
System.out.println("把第0個位置這個元素改為a：" + arraylist);
Collections.sort(arraylist);
System.out.println("如果arraylist不是抽象類型，則支持排序" + arraylist);
 
}

這里可以看到ArrayList刪除最后一個元素的方式與Vector有所不同夭禽，主要是ArrayList沒有l(wèi)astElement()這個方法來取出最后一個元素remove()掉霞掺，只能用arraylist.size() - 1來確定最后一個元素的位置。如果在主函數(shù)這樣調(diào)用這段方法：

System.out.println("======ArrayList數(shù)據(jù)結(jié)構(gòu)的測試開始======");
ArrayListtest();
System.out.println("======ArrayList數(shù)據(jù)結(jié)構(gòu)的測試結(jié)束======");

則得到如下的運(yùn)行結(jié)果：
======ArrayList數(shù)據(jù)結(jié)構(gòu)的測試開始======
單純的add表示從結(jié)尾加入元素：[1.0, 4.0, 5.0, 2.3]
size()能求出所含元素的個數(shù)：4
remove(1)表示刪去第1個元素讹躯，由于計(jì)數(shù)從0開始菩彬，也就是4這個元素：[1.0, 5.0, 2.3]
刪去最后一個元素的arraylist為：[1.0, 5.0]
在第0個位置加入1.8888這個元素：[1.8888, 1.0, 5.0]
把第0個位置這個元素改為a：[9.0, 1.0, 5.0]
如果arraylist不是抽象類型，則支持排序[1.0, 5.0, 9.0]
======ArrayList數(shù)據(jù)結(jié)構(gòu)的測試結(jié)束======

從上面的兩個例子潮梯，可以看到Vector與ArrayList比一個普通的數(shù)組骗灶，也就是課本上所教的一維數(shù)組int array[] = { 8, 7, 100, 88, 6, 4, 5, 33, 7 };強(qiáng)大很多，可以在任意位置插入元素秉馏，也可以不用遍歷數(shù)組就能夠用一個方法刪除指定位置的元素耙旦，當(dāng)然為你考試你還是要知道這個數(shù)組是怎么遍歷的。其實(shí)萝究，ArrayList與普通的一維數(shù)組完全可以實(shí)現(xiàn)互轉(zhuǎn)免都，而且利用ArrayList還能夠直接對array進(jìn)行排序锉罐，而不用再對array寫一個冒泡排序之類的，直接用Collections.sort();就能夠排序數(shù)組绕娘，然后再用Collections.reverse();就能實(shí)現(xiàn)逆排序脓规，當(dāng)然還是那句，為你考試你還是要知道這個數(shù)組是怎么排序的险领。
比如如下的方法侨舆，實(shí)現(xiàn)了對一維數(shù)組int array[] = { 8, 7, 100, 88, 6, 4, 5, 33, 7 };的排序與逆排序，先把數(shù)組轉(zhuǎn)化成ArrayList再用Collections.sort();與Collections.reverse();排序舷暮，最后再把ArrayList內(nèi)容轉(zhuǎn)化回一維數(shù)組：

public static void arrayListSort() {
int array[] = { 8, 7, 100, 88, 6, 4, 5, 33, 7 };
ArrayList<Integer> arraylist = new ArrayList<Integer>();
for (int i = 0; i < array.length; i++)
System.out.print(array[i] + ",");
for (int i = 0; i < array.length; i++)
arraylist.add(array[i]);
Collections.sort(arraylist);
for (int i = 0; i < array.length; i++)
array[i] = arraylist.get(i);
System.out.print("排序后的數(shù)組：");
for (int i = 0; i < array.length; i++)
System.out.print(array[i] + ",");
Collections.reverse(arraylist);
for (int i = 0; i < array.length; i++)
array[i] = arraylist.get(i);
System.out.print("逆排序后的數(shù)組：");
for (int i = 0; i < array.length; i++)
System.out.print(array[i] + ",");
//排序之后把a(bǔ)rraylist銷毀
arraylist = null;
//這句是建議Java馬上回收垃圾态罪，當(dāng)然這句有沒有都行，Java在運(yùn)行的過程中會自動清除垃圾的
System.gc();
}

在主函數(shù)中這樣調(diào)用方法：

System.out.println("======Java數(shù)組排序開始======");
arrayListSort();
System.out.println("======Java數(shù)組排序結(jié)束======");

就能夠得到如下的運(yùn)行結(jié)果： ======Java數(shù)組排序開始====== 8,7,100,88,6,4,5,33,7,排序后的數(shù)組：4,5,6,7,7,8,33,88,100,逆排序后的數(shù)組：100,88,33,8,7,7,6,5,4, ======Java數(shù)組排序結(jié)束====== 另外下面，之前說的《Java中List的使用方法簡單介紹》（點(diǎn)擊打開鏈接）也是同樣的道理 复颈。
二、集合HashSet
另外沥割，還有集合HashSet耗啦，HashSet與數(shù)學(xué)上的集合概念一模一樣。由一個或多個元素所構(gòu)成的叫做集合机杜。HashSet具有：
1.確定性帜讲，集合中的元素必須是確定的，這個是廢話椒拗，必須確定似将，難道我還可以在里面放一個不確定的東西進(jìn)去嗎？
2.互異性蚀苛，集合中的元素互不相同在验。例如：集合A={1，a}堵未，則a不能等于1腋舌，也就是如果你把兩個1放進(jìn)HashSet會自動變?yōu)橐粋€1
3.無序性，集合中的元素沒有先后之分渗蟹。因此HashSet也不得進(jìn)行排序操作
例如如下的一段方法：

public static void HashSettest() {
HashSet<Object> hashset = new HashSet<Object>();
hashset.add(1);
hashset.add(1);
hashset.add(5);
hashset.add(2.3);
System.out.println("單純的add表示從結(jié)尾加入元素：" + hashset);
System.out.println("size()能求出所含元素的個數(shù)：" + hashset.size());
hashset.remove(1);
System.out.println("remove(1)表示刪去'1'這個元素：" + hashset);
hashset.remove("asd");
System.out.println("如果沒有'asd'這個元素則remove什么都不做：" + hashset);
hashset.add(1.8888);
System.out.println("加入1.8888這個元素：" + hashset);
}

在主函數(shù)中块饺，調(diào)用這個方法：

System.out.println("======HashSet數(shù)據(jù)結(jié)構(gòu)的測試開始======");
HashSettest();
System.out.println("======HashSet數(shù)據(jù)結(jié)構(gòu)的測試結(jié)束======"); 

結(jié)果如下：
======HashSet數(shù)據(jù)結(jié)構(gòu)的測試開始======
單純的add表示從結(jié)尾加入元素：[1, 5, 2.3]
size()能求出所含元素的個數(shù)：3
remove(1)表示刪去'1'這個元素：[5, 2.3]
如果沒有'asd'這個元素則remove什么都不做：[5, 2.3]
加入1.8888這個元素：[5, 1.8888, 2.3]
======HashSet數(shù)據(jù)結(jié)構(gòu)的測試結(jié)束======
HashSet有add()方法與remove()方法，add()所加的元素沒有順序雌芽，每次用System.out.println()打印的結(jié)果可能順序不一樣授艰，也不能向上面Vector與ArrayList一樣，只要所存的元素不是Object膘怕，就能使用Collections.sort(arraylist);來排序

三想诅、二元組HashMap
這里的使用方法和上面的數(shù)據(jù)基本相同，也很簡單，就是put方法來對象進(jìn)去map来破，而get能夠取走map中的對象篮灼，但是試圖把二元組HashMap用成三元組是錯誤的，如果一個對象中含有元素過多徘禁，那你應(yīng)該考慮用類诅诱。而不是還在迷戀Java中介乎于普通變量與Class類之間的Collections類。
比如如下方法就展示了試圖把HashMap改成三元組的錯誤操作：

public static void Maptest(){
System.out.println("======Map錯誤的使用開始======");
HashMap<String,String> map=new HashMap<String, String>();
HashMap<String,HashMap<String, String>> bigmap=new HashMap<String, HashMap<String, String>>();
map.put("key1","1");
map.put("key2","2"); 
bigmap.put("test1",map);
map.clear();
map.put("key1","3");
map.put("key2","4"); 
bigmap.put("test2",map);
System.out.println(bigmap);
System.out.println(bigmap.get("test1").get("key1"));
System.out.println(bigmap.get("test1").get("key2"));
System.out.println(bigmap.get("test2").get("key1"));
System.out.println(bigmap.get("test2").get("key2"));
System.out.println("======Map錯誤的使用結(jié)束======");
System.out.println("======Map正確的使用開始======");
map.clear();
bigmap=null;
map.put("key1","1");
map.put("key2","2");
map.put("key3","3");
System.out.println(map);
System.out.println("======Map正確的使用結(jié)束======");
}

在主函數(shù)調(diào)用這段代碼送朱，得到下面的運(yùn)行結(jié)果：
======Map數(shù)據(jù)結(jié)構(gòu)的測試開始======
======Map錯誤的使用開始======
{test1={key2=4, key1=3}, test2={key2=4, key1=3}}
3
4
3
4
======Map錯誤的使用結(jié)束======
======Map正確的使用開始======
{key3=3, key2=2, key1=1}
======Map正確的使用結(jié)束======
======Map數(shù)據(jù)結(jié)構(gòu)的測試結(jié)束======
這段程序本來用意是很明顯娘荡，試圖構(gòu)造出一個{test1,key1,1},{test1,key2,2},{test2,key3,3},{test2,key4,4}
然而，每個bigmap中還是存得都是那個map驶沼，你一旦把map清空炮沐，原來test1中的那個map也同樣被清空， 有人試圖創(chuàng)造多個map1,map2,...那你還不如用一個簡單的類回怜，看起來更加明確大年，而且類中以后還能寫方法，被繼承