背景
所有集合類都位于java.util包下。集合中隻能儲存對象（儲存對象的引用變量）。當我們把一個對象放入集合中後，系統會把所有集合元素都當成Object類的執行個體進行處理。
Java的集合類主要由兩個接口派生而出：Collection和Map，Collection和Map是Java集合架構的根接口，這兩個接口又包含了一些接口或實作類。
Map實作類用于儲存具有映射關系的資料（key-value）。
Set、List和Map可以看做集合的三大類。
- List集合是有序集合，集合中的元素可以重複，通路集合中的元素可以根據元素的索引來通路。
- Set集合是無序集合，集合中的元素不可以重複，通路集合中的元素隻能根據元素本身來通路（也是不能集合裡元素不允許重複的原因）。
- Map集合中儲存Key-value對形式的元素，通路時隻能根據每項元素的key來通路其value。
| 接口 | 實作 | 曆史集合類 |
| Set | HashSet | |
| TreeSet | ||
| List | ArrayList | Vector |
| LinkedList | Stack | |
| Map | HashMap | Hashtable |
| TreeMap | Properties |
Collection
Collection接口支援如添加和除去等基本操作。設法除去一個元素時，如果這個元素存在，除去的僅僅是集合中此元素的一個執行個體。
- boolean add(Object element)
- boolean remove(Object element)
- int size()
- boolean isEmpty()
- boolean contains(Object element)
- Iterator iterator()
- boolean containsAll(Collection collection)
- boolean addAll(Collection collection)
- void clear()
- void removeAll(Collection collection)
- void retainAll(Collection collection)
containsAll() 方法允許您查找目前集合是否包含了另一個集合的所有元素，即另一個集合是否是目前集合的子集。其餘方法是可選的，因為特定的集合可能不支援集合更改。 addAll() 方法確定另一個集合中的所有元素都被添加到目前的集合中，通常稱為并。 clear() 方法從目前集合中除去所有元素。 removeAll() 方法類似于 clear() ，但隻除去了元素的一個子集。 retainAll() 方法類似于 removeAll() 方法，不過可能感到它所做的與前面正好相反：它從目前集合中除去不屬于另一個集合的元素，即交。
import java.util.*;
public class CollectionToArray {
public static void main(String[] args) {
Collection collection1=new ArrayList();//建立一個集合對象
collection1.add("000");//添加對象到Collection集合中
collection1.add("111");
collection1.add("222");
System.out.println("集合collection1的大小："+collection1.size());
System.out.println("集合collection1的内容："+collection1);
collection1.remove("000");//從集合collection1中移除掉 "000" 這個對象
System.out.println("集合collection1移除 000 後的内容："+collection1);
System.out.println("集合collection1中是否包含000 ："+collection1.contains("000"));
System.out.println("集合collection1中是否包含111 ："+collection1.contains("111"));
Collection collection2=new ArrayList();
collection2.addAll(collection1);//将collection1 集合中的元素全部都加到collection2中
System.out.println("集合collection2的内容："+collection2);
collection2.clear();//清空集合 collection2 中的元素
System.out.println("集合collection2是否為空 ："+collection2.isEmpty());
//将集合collection1轉化為數組
Object s[]= collection1.toArray();
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
}
}
} 運作結果為：
集合collection1的大小：3
集合collection1的内容：[000, 111, 222]
集合collection1移除 000 後的内容：[111, 222]
集合collection1中是否包含000 ：false
集合collection1中是否包含111 ：true
集合collection2的内容：[111, 222]
集合collection2是否為空 ：true
111
222 Iterator
Collection 接口的 iterator() 方法傳回一個 Iterator。
Collection books = new HashSet();
books.add("Java jichu");
books.add("Java web");
Iterator it = books.iterator();
while (it.hasNext()) {
String book = (String) it.next();
System.out.println(book);
if(book.equals("Java web"))
{
books.remove(book);
}
}
Iterator it2 = books.iterator();
while (it2.hasNext()) {
String book = (String) it2.next();
System.out.println(book);
} 運作結果：
Java jichu
Java web
Java jichu 1) 使用方法 iterator() 要求容器傳回一個Iterator .第一次調用Iterator 的next() 方法時，它傳回集合序列的第一個元素。
2)使用next() 獲得集合序列的中的下一個元素。
3)使用hasNext()檢查序列中是否元素。
4) 使用remove()将疊代器新傳回的元素删除
Set
Set最大的特性就是不允許在其中存放的元素是重複的。
- public int size() ：傳回set中元素的數目，如果set包含的元素數大于Integer.MAX_VALUE，傳回Integer.MAX_VALUE
- public boolean isEmpty() ：如果set中不含元素，傳回true
- public boolean contains(Object o) ：如果set包含指定元素，傳回true
- public Iterator iterator()：傳回set中元素的疊代器
- public Object[] toArray() ：傳回包含set中所有元素的數組
- public Object[] toArray(Object[] a) ：傳回包含set中所有元素的數組，傳回數組的運作時類型是指定數組的運作時類型
- public boolean add(Object o) ：如果set中不存在指定元素，則向set加入
- public boolean remove(Object o) ：如果set中存在指定元素，則從set中删除
- public boolean removeAll(Collection c) ：如果set包含指定集合，則從set中删除指定集合的所有元素
- public boolean containsAll(Collection c) ：如果set包含指定集合的所有元素，傳回true。如果指定集合也是一個set，隻有是目前set的子集時，方法傳回true
- public boolean addAll(Collection c) ：如果set中中不存在指定集合的元素，則向set中加入所有元素
- public boolean retainAll(Collection c) ：隻保留set中所含的指定集合的元素（可選操作）。換言之，從set中删除所有指定集合不包含的元素。 如果指定集合也是一個set，那麼該操作修改set的效果是使它的值為兩個set的交集
- public void clear() ：從set中删除所有元素
Set set1 = new HashSet();
if(set1.add("a"))
{
System.out.println("OK");
}
if (set1.add("a")) {
System.out.println("OK2");
}
else
{
System.out.println("BAD2");
}
set1.add("000");
set1.add("111");
set1.add("222");
System.out.println("集合set1的内容："+set1);
System.out.println("集合set1的大小："+set1.size());
set1.remove("000");
System.out.println("集合set1的内容："+set1);
System.out.println("集合set1中是否包含000 ："+set1.contains("000"));
System.out.println("集合set1中是否包含111 ："+set1.contains("111"));
Set set2=new HashSet();
set2.add("111");
set2.addAll(set1);//将set1 集合中的元素全部都加到set2中
System.out.println("集合set2的内容："+set2);
Iterator iterator = set1.iterator();//得到一個疊代器
while (iterator.hasNext()) {//周遊
String element =(String) iterator.next();
System.out.println("iterator = " + element);
}
//将集合set1轉化為數組
Object s[]= set1.toArray();
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
} 運作結果：
OK
BAD2
集合set1的内容：[222, 111, a, 000]
集合set1的大小：4
集合set1的内容：[222, 111, a]
集合set1中是否包含000 ：false
集合set1中是否包含111 ：true
集合set2的内容：[222, a, 111]
iterator = 222
iterator = 111
iterator = a
222
111
a HashSet、LinkedHashSet、TreeSet
Set set1 = new HashSet();
Set set2 = new LinkedHashSet();
for(int i =0 ; i<5 ;i++)
{
int s = (int)(Math.random()*100);
set1.add(new Integer(s));
set2.add(new Integer(s));
System.out.println("第 "+i+" 次随機數産生為："+s);
}
System.out.println("未排序前HashSet："+set1);
System.out.println("未排序前LinkedHashSet："+set2);
//使用TreeSet來對另外的Set進行重構和排序
Set sortedSet = new TreeSet(set1);
System.out.println("排序後 TreeSet ："+sortedSet); 運作結果：
第 0 次随機數産生為：85
第 1 次随機數産生為：41
第 2 次随機數産生為：81
第 3 次随機數産生為：49
第 4 次随機數産生為：99
未排序前HashSet：[85, 49, 81, 99, 41]
未排序前LinkedHashSet：[85, 41, 81, 49, 99]
排序後 TreeSet ：[41, 49, 81, 85, 99] List
當我們不知道存儲的資料有多少的情況，我們就可以使用List 來完成存儲資料的工作。例如前面提到的一種場景。我們想要在儲存一個應用系統目前的線上使用者的資訊。我們就可以使用一個List來存儲。因為List的最大的特點就是能夠自動的根據插入的資料量來動态改變容器的大小。在 List 中搜尋元素可以從清單的頭部或尾部開始，如果找到元素，還将報告元素所在的位置。
- void add(int index, Object element) ：添加對象element到位置index上
- boolean addAll(int index, Collection collection) ：在index位置後添加容器collection中所有的元素
- Object get(int index) ：取出下标為index的位置的元素
- int indexOf(Object element) ：查找對象element 在List中第一次出現的位置
- int lastIndexOf(Object element) ：查找對象element 在List中最後出現的位置
- Object remove(int index) ：删除index位置上的元素
- Object set(int index, Object element) ：将index位置上的對象替換為element 并傳回老的元素。
LinkedList queue = new LinkedList();
queue.addFirst("Bernadine");
queue.addFirst("Elizabeth");
queue.addFirst("Gene");
queue.addFirst("Elizabeth");
queue.addFirst("Clara");
System.out.println(queue);
queue.removeLast();
queue.removeLast();
System.out.println(queue); 運作結果：
[Clara, Elizabeth, Gene, Elizabeth, Bernadine]
[Clara, Elizabeth, Gene] Stack<String> v = new Stack<String>();
v.push("111");
v.push("222");
v.push("333");
System.out.println(v);
System.out.println(v.peek());
System.out.println(v);
System.out.println(v.pop());
System.out.println(v); 運作結果：
[111, 222, 333]
333
[111, 222, 333]
333
[111, 222] List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
System.out.println("下标0開始："+list.listIterator(0).next());//next()
System.out.println("下标1開始:"+list.listIterator(1).next());
System.out.println("子List 1-3:"+list.subList(1,3));//子清單
ListIterator it = list.listIterator();//預設從下标0開始
//隐式光标屬性add操作 ,插入到目前的下标的前面
it.add("sss");
while(it.hasNext()){
System.out.println("next Index="+it.nextIndex()+",Object="+it.next());
}
//set屬性
ListIterator it1 = list.listIterator();
it1.next();
it1.set("ooo");
ListIterator it2 = list.listIterator(list.size());//下标
while(it2.hasPrevious()){
System.out.println("previous Index="+it2.previousIndex()+",Object="+it2.previous());
} 運作結果：
下标0開始：aaa
下标1開始:bbb
子List 1-3:[bbb, ccc]
next Index=1,Object=aaa
next Index=2,Object=bbb
next Index=3,Object=ccc
next Index=4,Object=ddd
previous Index=4,Object=ddd
previous Index=3,Object=ccc
previous Index=2,Object=bbb
previous Index=1,Object=aaa
previous Index=0,Object=ooo ListIterator
接口繼承
Iterator
接口以支援添加或更改底層集合中的元素，還支援雙向通路。
Map
數學中的映射關系在Java中就是通過Map來實作的。它表示，裡面存儲的元素是一個對（pair）,我們通過一個對象，可以在這個映射關系中找到另外一個和這個對象相關的東西。
-
Object put(Object key,Object value)
：用來存放一個鍵
-
值對
Map
中
-
Object remove(Object key)
：根據
key(
鍵
)
，移除一個鍵
-
值對，并将值傳回
-
void putAll(Map mapping)
：将另外一個
Map
中的元素存入目前的
Map
中
-
void clear()
：清空目前
Map
中的元素
-
Object get(Object key)
：根據
key(
鍵
)
取得對應的值
-
boolean containsKey(Object key)
：判斷
Map
中是否存在某鍵（
key
）
-
boolean containsValue(Object value):
判斷
Map
中是否存在某值
(value)
-
int size():
傳回
Map
中
-
boolean isEmpty()
：判斷目前
Map
是否為空
-
public Set keySet()
：傳回所有的鍵（
key
），并使用
Set
容器存放
-
public Collection values()
：傳回所有的值（
Value
），并使用
Collection
存放
-
public Set entrySet()
：
HashMap<String, String> hm = new HashMap<String, String>();
//試圖将2個key為null的key-value對放入HashMap中
hm.put(null , null);
hm.put(null , null);
//将一個value為null的key-value對放入HashMap中
hm.put("a" , null);
hm.put("a" , "b");
//輸出Map對象
System.out.println(hm); 運作結果：
{null=null, a=b} HashMap若遇到重複的key，覆寫掉以前的
Map<String, String> map1 = new HashMap<String, String>();
Map<String, String> map2 = new HashMap<String, String>();
map1.put("1","aaa1");
map1.put("2","bbb2");
map2.put("10","aaaa10");
map2.put("11","bbbb11");
//根據鍵 "1" 取得值："aaa1"
System.out.println("map1.get(\"1\")="+map1.get("1"));
// 根據鍵 "1" 移除鍵值對"1"-"aaa1"
System.out.println("map1.remove(\"1\")="+map1.remove("1"));
System.out.println("map1.get(\"1\")="+map1.get("1"));
map1.putAll(map2);//将map2全部元素放入map1中
map2.clear();//清空map2
System.out.println("map1 IsEmpty?="+map1.isEmpty());
System.out.println("map2 IsEmpty?="+map2.isEmpty());
System.out.println("map1 中的鍵值對的個數size = "+map1.size());
System.out.println("KeySet="+map1.keySet());//set
System.out.println("values="+map1.values());//Collection
System.out.println("entrySet="+map1.entrySet());
System.out.println("map1 是否包含鍵：11 = "+map1.containsKey("11"));
System.out.println("map1 是否包含值：aaa1 = "+map1.containsValue("aaa1")); 運作結果：
map1.get("1")=aaa1
map1.remove("1")=aaa1
map1.get("1")=null
map1 IsEmpty?=false
map2 IsEmpty?=true
map1 中的鍵值對的個數size = 3
KeySet=[2, 10, 11]
values=[bbb2, aaaa10, bbbb11]
entrySet=[2=bbb2, 10=aaaa10, 11=bbbb11]
map1 是否包含鍵：11 = true
map1 是否包含值：aaa1 = false Map<Integer, String> map1 = new HashMap<Integer, String>();
Map<Integer, String> map2 = new LinkedHashMap<Integer, String>();
for(int i=0;i<10;i++){
int s=(int)(Math.random()*100);//産生一個随機數，并将其放入Map中
map1.put(new Integer(s),"第 "+i+" 個放入的元素："+s+"\n");
map2.put(new Integer(s),"第 "+i+" 個放入的元素："+s+"\n");
}
System.out.println("未排序前HashMap："+map1);
System.out.println("未排序前LinkedHashMap："+map2);
//使用TreeMap來對另外的Map進行重構和排序
Map<Integer, String> sortedMap = new TreeMap<Integer, String>(map1);
System.out.println("排序後："+sortedMap);
System.out.println("排序後："+new TreeMap<Integer, String>(map2)); 運作結果：
未排序前HashMap：{68=第 3 個放入的元素：68
, 32=第 5 個放入的元素：32
, 71=第 7 個放入的元素：71
, 53=第 9 個放入的元素：53
, 37=第 8 個放入的元素：37
, 42=第 4 個放入的元素：42
, 24=第 2 個放入的元素：24
, 63=第 6 個放入的元素：63
, 29=第 0 個放入的元素：29
, 88=第 1 個放入的元素：88
}
未排序前LinkedHashMap：{29=第 0 個放入的元素：29
, 88=第 1 個放入的元素：88
, 24=第 2 個放入的元素：24
, 68=第 3 個放入的元素：68
, 42=第 4 個放入的元素：42
, 32=第 5 個放入的元素：32
, 63=第 6 個放入的元素：63
, 71=第 7 個放入的元素：71
, 37=第 8 個放入的元素：37
, 53=第 9 個放入的元素：53
}
排序後：{24=第 2 個放入的元素：24
, 29=第 0 個放入的元素：29
, 32=第 5 個放入的元素：32
, 37=第 8 個放入的元素：37
, 42=第 4 個放入的元素：42
, 53=第 9 個放入的元素：53
, 63=第 6 個放入的元素：63
, 68=第 3 個放入的元素：68
, 71=第 7 個放入的元素：71
, 88=第 1 個放入的元素：88
}
排序後：{24=第 2 個放入的元素：24
, 29=第 0 個放入的元素：29
, 32=第 5 個放入的元素：32
, 37=第 8 個放入的元素：37
, 42=第 4 個放入的元素：42
, 53=第 9 個放入的元素：53
, 63=第 6 個放入的元素：63
, 68=第 3 個放入的元素：68
, 71=第 7 個放入的元素：71
, 88=第 1 個放入的元素：88
} 從運作結果，我們可以看出，HashMap的存入順序和輸出順序無關。而LinkedHashMap 則保留了鍵值對的存入順序。TreeMap則是對Map中的元素進行排序。在實際的使用中我們也經常這樣做：使用HashMap或者LinkedHashMap 來存放元素，當所有的元素都存放完成後，如果使用則是需要一個經過排序的Map的話，我們再使用TreeMap來重構原來的Map對象。這樣做的好處是：因為HashMap和LinkedHashMap 存儲資料的速度比直接使用TreeMap 要快，存取效率要高。當完成了所有的元素的存放後，我們再對整個的Map中的元素進行排序。這樣可以提高整個程式的運作的效率，縮短執行時間。
轉載請注明出處：http://www.cnblogs.com/yydcdut/p/3705054.html
作者：我愛物聯網
出處：http://yydcdut.cnblogs.com/
本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接配接，否則保留追究法律責任的權利。