java集合總結

篇一：Java集合類總結2

Java中集合類用法總結

Collection

├List

│├LinkedList

│├ArrayList │└Vector

│ └Stack

└Set

├HashSet

└TreeSet

Map

├Hashtable

├HashMap

├WeakHashMap

└TreeMap

Map接口：

|

+ -- WeakHashMap: 以弱鍵 實現的基于哈希表的 Map。在 WeakHashMap 中，當某個鍵不再正常使用時，將自動移除其條目。更精確地說，對于一個給定的鍵，其映射的存在并不阻止垃圾回收器對該鍵的丟棄，這就使該鍵成為可終止的，被終止，然后被回收。丟棄某個鍵時，其條目從映射中有效地移除，因此，該類的行為與其他的 Map 實現有所不同。此實現不是同步的。

|

+ -- TreeMap:該映射根據其鍵的自然順序進行排序，或者根據創建映射時提供的 Comparator 進行排序，具體取決于使用的構造方法。此實現不是同步的。 |

+ -- HashMap:基于哈希表的 Map 接口的實現。此實現提供所有可選的映射操作，并允許使用 null 值和 null 鍵。此類不保證映射的順序，特別是它不保證該順序恒久不變。此實現不是同步的。

|

+-- Sorted Map: 進一步提供關于鍵的總體排序 的 Map。該映射是根據其

鍵的自然順序進行排序的，或者根據通常在創建有序映射時提供的 Comparator 進行排序。對有序映射的 collection 視圖進行迭代時，此順序就會反映出來。要采用此排序方式，還需要提供一些其他操作。

Collection接口：

|

+ -- Set接口:一個不包含重復元素的 collection。更正式地說，set 不包含滿足 e1.equals(e2) 的元素對 e1 和 e2，并且最多包含一個 null 元素。正如其名稱所暗示的，此接口模仿了數學上的 set 抽象。

||

|+ -- HashSet:此類實現 Set 接口，由哈希表支持。它不保證 set 的迭代順序；特別是它不保證該順序恒久不變。此類允許使用 null 元素。此類為基本操作提供了穩定性能，此實現不是同步的。

||

|+ -- LinkedHashSet:具有可預知迭代順序的 Set 接口的哈希表和鏈接列表實現。此實現與 HashSet 的不同之外在于，后者維護著一個運行于所有條目的雙重鏈接列表。此鏈接列表定義了迭代順序，即按照將元素插入到 set中 的順序進行迭代。注意，插入順序不 受在 set 中重新插入的 元素的影響。此實現不是同步的。

||

|+ -- TreeSet:基于 TreeMap 的 NavigableSet 實現。使用元素的自然順序對元素進行排序，或者根據創建 set 時提供的 Comparator 進行排序，具體取決于使用的構造方法。此實現為基本操作提供受保證的 log(n) 時間開銷。此實現不是同步的。

|

+ -- List接口:有序的 collection。此接口的用戶可以對列表中每個元素的插入位置進行精確地控制。用戶可以根據元素的整數索引訪問元素，并搜索列表中的元素。

|

+ -- ArrayList:List 接口的大小可變數組的實現。實現了所有可選列表操作，并允許包括 null 在內的所有元素。除了實現 List 接口外，此類還提供一些方法來操作內部用來存儲列表的數組的大小。每個 ArrayList 實例都有一個容量。該容量是指用來存儲列表元素的數組的大小。它總是至少等于列表的大小。隨著向

ArrayList 中不斷添加元素，其容量也自動增長。并未指定增長策略的細節，因為這不只是添加元素會帶來分攤固定時間開銷那樣簡單。此實現不是同步的。|

+ -- LinkedList:List 接口的鏈接列表實現。實現所有可選的列表操作，并且允許所有元素。除了實現 List 接口外，LinkedList 類還為在列表的開頭及結尾 get、remove 和 insert 元素提供了統一的命名方法。這些操作允許將鏈接列表用作堆棧、隊列或雙端隊列。提供先進先出隊列操作(FIFO)。此實現不是同步的。

|

+ -- Vector:Vector 類可以實現可增長的對象數組。與數組一樣，它包含可以使用整數索引進行訪問的組件。但是 ，Vector 的大小可以根據需要增大或縮小，以適應創建 Vector 后進行添加或移除項的操作。此實現是同步的.

1. Collection的功能

下面這張表給出了Collection的所有功能，也就是你能用Set和List做什么事。Map不是繼承Collection的，所以我們會區別對待。

boolean add(Object)：確保容器能持有你傳給它的那個參數。如果沒有把它加進去，就返回false。 boolean addAll(Collection)：加入參數Collection所含的所有元素。只要加了元素，就返回true。

void clear()：清除容器所保存的所有元素。

boolean contains(Object)：如果容器持有參數Object，就返回true。 boolean containsAll(Collection)：如果容器持有參數Collection所含的全部元素，就返回true。

boolean isEmpty()：如果容器里面沒有保存任何元素，就返回true。

Iterator iterator()：返回一個可以在容器的各元素之間移動的Iterator。 boolean removeAll(Collection)：刪除容器里面所有參數Collection所包含的元素。只要刪過東西，就返回true。

boolean retainAll(Collection)：只保存參數Collection所包括的元素。如果發生過變化，則返回true。 int size()：返回容器所含元素的數量。

Object toArray()：返回一個包含容器中所有元素的數組。

Object toArray(Object a)：返回一個包含容器中所有元素的數組，且

這個數組不是普通的Object數組，它的類型應該同參數數組a的類型相同。

注意，這里沒有能進行隨機訪問的get()方法。這是因為Collection還包括Set。而Set有它自己的內部順序。所以如果你要檢查Collection的元素，你就必須使用迭代器。

2．List的功能

List的基本用法事相當將但的。雖然絕大多數時候，你只是用add()加對象，用get()取對象，用iterator()獲取這個序列的Iterator，但List還有一些別的很有用的方法。

實際上有兩種List：擅長對元素進行隨機訪問的，較常用的ArrayList，和更強大的LinkedList。LinkedList不是為快速的隨機訪問而的，但是它卻有一組更加通用的方法。

Lisk：List的最重要的特征就是有序；它會確保以一定的順序保存元素。List在Collection的基礎上添加了大量方法，使之能在序列中間插入和刪除元素。List可以制造ListIterator對象，你除了能用它在List的中間插入和刪除元素之外，還能用它沿兩個方法遍歷List。

ArrayList*：一個用數組實現的List。能進行快速的隨機訪問，但是往列表中間插入和刪除元素的時候比較慢。ListIterator只能用在反向遍歷ArrayList的場合，不要用它來插入和刪除元素，因為相比LinkedList，在ArrayList里面用ListIterator的系統開銷比較高。

LinkedList：對順序訪問進行了優化。在List中間插入和刪除元素的代價也不高。隨機訪問的速度相對較慢。此外它還有addFirst()，addLast()，getFirst()，getLast()，removeFirst()和removeLast()等方法，你能把它當成棧，隊列或雙向隊列來用。

記住，容器只是一個存儲對象的盒子。如果這個笑盒子能幫你解決所有的問題，那你就用不著取管它事怎么實現的。如果開發環境里面還有一些別的，會造成固定的性能開銷的因素存在，那么ArrayList和LinkedList之間的性能差別就會變得不那么重要了。你只需要它們中的一個，你甚至可以想象有這樣一種“完美”的抽象容器；它能根據用途，自動地切換其底層的實現。

用LinkedList做一個棧

“?！庇袝r也被稱為“后進先出”的容器。就是說，最后一個被“壓”進棧中的東西，會第一個“彈”出來。同其他Java容器一樣，壓進去和彈出來的東西都是Object，所以除非你只用Object的功能，否則就必須對彈起來的東西進行類型轉換。

LinkedList的方法能直接實現棧的功能，所以你完全可以不寫Stack而直接使用LinkedList。

如果你只想要棧的功能，那么繼承就不太合適了，因為繼承出來的是一個擁有LinkedList的所有方法的類。

用LinkedList做一個隊列

隊列是一個“先進先出”容器。也就是，你把一端把東西放進去，從另一端把東西取出來。所以你放東西的順序也就是取東西的順序。LinkedList有支持隊列的功能的方法，所以它也能被當作Queue來用。

還能很輕易地用LinkedList做一個deque。它很像隊列，只是你可以從任意一端添加和刪除元素。

Vector類

Vector非常類似ArrayList，但是Vector是同步的。由Vector創建的

Iterator，雖然和ArrayList創建的Iterator是同一接口，但是，因為Vector是同步的，當一個Iterator被創建而且正在被使用，另一個線程改變了Vector的狀態，這時調用Iterator的方法時將拋出ConcurrentModificationException，因此必須捕獲該異常。

Stack 類

Stack繼承自Vector，實現一個后進先出的堆棧。Stack提供5個額外的方法使得Vector得以被當作堆棧使用?；镜膒ush和pop方法，還有peek方法得到棧頂的元素，empty方法測試堆棧是否為空，search方法檢測一個元素在堆棧中的位置。Stack剛創建后是空棧。

3．Set的功能

Set的接口就是Collection的，所以不像那兩個List，它沒有額外的功能。實際上Set確確實實就是一個Collection－－只不過行為方式不同罷了。Set會拒絕持有多個具有相同值的對象的實例。

Set：加入Set的每個元素必須是唯一的；否則，Set是不會把它加進

篇二：【java】集合框架

【java總結】集合框架

Collection是集合框架層次結構中的根接口。Collection 表示一組對象，這些對象也稱為 collection 的元素。一些 collection 允許有重復的元素，而另一些則不允許。一些 collection 是有序的，而另一些則是無序的。Collection接口下有最常用的接口為List跟Set。需要注意的是，Map并沒有實現Collection接口。

List接口實現類ArrayList

優點：類似數組的形式進行存儲，因此它的隨機訪問速度極快。

缺點：不適合于在線性表中間需要頻繁進行插入和刪除操作。因為每次插入和刪除都需要移動數組中的元素，它是用數組存儲元素的，這個數組可以動態創建，如果元素個數超過了數組的容量，那么就創建一個更大的新數組，并將當前數組中的所有元素都復制到新數組中。

view plain copy

span style=font-size:14px;public class ArrayListTest {

public static void main(String args){

ListString arrayList=new ArrayListString();

arrayList.add(Welcome);

arrayList.add(to);

arrayList.add(java);

//把ArrayList變為數組相關的內容進行遍歷

String strArray=new String;

arrayList.toArray(strArray);

for(int i=0;istrArray.length;i++)System.out.println(strArray);

//使用迭代器進行ArrayList遍歷

IteratorString iter=arrayList.iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

}

}/span

List接口實現類LinkedList

優點：適合于在鏈表中間需要頻繁進行插入和刪除操作。

缺點： 隨機訪問速度較慢。查找一個元素需要從頭開始一個一個的找。此類實現 Deque 接口，為 add、poll 提供先進先出隊列操作，以及其他堆棧和雙端隊列操作LinkedList是在一個鏈表中存儲元素。

view plain copy

span style=font-size:14px;public class LinkedListTest {

public static void main(String args){

ListString linkedList=new LinkedListString();

//使用ForEach遍歷linkedList

String strArray2=new String;

linkedList.toArray(strArray2);

for(int i=0;istrArray2.length;i++)System.out.println(strArray2);

//foreach遍歷LinkedList

for(String str:linkedList){

System.out.println(str);

}

//使用迭代器進行ArrayList遍歷

IteratorString iter=linkedList.iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

}

}/span

List接口實現類Vector：

Vector使用了關鍵字synchronized將訪問和修改向量的方法都變成同步的了，所以對于不需要同步的應用程序來說，類ArrayList比類Vector更高效。

相同點：

①都繼承于AbstractList，并且實現List接口

②都實現了RandomAccess和Cloneable接口

③都是通過數組實現的，本質上都是動態數組，默認數組容量是10

④都支持Iterator和listIterator遍歷

不同點：

①ArrayList是非線程安全，而Vector是線程安全的

②容量增加方式不同，Vector默認增長為原來一倍，而ArrayList卻是原來的一半+1 ③Vector支持通過Enumeration去遍歷，而List不支持

view plain copy

span style=font-size:14px;public class VectorTest {

public static void main(String args){

VectorInteger vector = new VectorInteger();

for(int i = 0; i 10; i++){

vector.add(i);

}

//直接打印

System.out.println(vector.toString());

//size()

System.out.println(vector.size());

//contains

System.out.println(vector.contains(2));

//總結：對比Vector的遍歷方式，使用索引的隨機訪問方式最快，使用迭代器最慢 //iterator遍歷

IteratorInteger iterator = vector.iterator();

while(iterator.hasNext()){

System.out.print(iterator.next() + );

}

//Enumeration遍歷

Enumeration enu = vector.elements();

while (enu.hasMoreElements()) {

System.out.println((Integer)enu.nextElement());

}

//toArray

Object objArr = vector.toArray();

System.out.println(\nobjArr: + Arrays.asList(objArr));

Integer intArr = vector.toArray(new Integer);

System.out.println(intArr: + Arrays.asList(intArr));

//add

vector.add(5);

//remove

vector.remove(5);

System.out.println(vector);

//containsAll

System.out.println(vector.containsAll(Arrays.asList(5,6)));

//addAll

vector.addAll(Arrays.asList(555,666));

System.out.println(vector);

//removeAll

vector.removeAll(Arrays.asList(555,666));

System.out.println(vector);

//addAll方法

vector.addAll(5, Arrays.asList(666,666, 6));

System.out.println(vector);

//get方法

System.out.println(vector.get(5));

//set方法

vector.set(5, 55);

System.out.println(vector.get(5));

//add方法

vector.add(0, 555);

System.out.println(vector);

//remove方法

vector.remove(0);

System.out.println(vector);

//indexof方法

System.out.println(vector.indexOf(6));

//lastIndexOf方法

System.out.println(vector.lastIndexOf(6));

//listIterator方法

ListIteratorInteger listIterator = vector.listIterator();

System.out.println(listIterator.hasPrevious());

//listIterator(index)方法

ListIteratorInteger iListIterator = vector.listIterator(5);

System.out.println(iListIterator.previous());

//subList方法

System.out.println(vector.subList(5, 7));

//clear

vector.clear();

System.out.println(vector);

}

}/span

List接口實現類Stack

棧類，是Java2之前引入的，繼承自類Vector。同樣是線程同步的

view plain copy

span style=font-size:14px;public class StackTest {

public static void main(String args){

StackInteger stack = new StackInteger();

for(int i = 0; i 10; i++){

stack.add(i);

}

System.out.println(stack);

System.out.println(stack.peek());

stack.push(555);

System.out.println(stack);

System.out.println(stack.pop());

System.out.println(stack);

System.out.println(stack.empty());

System.out.println(stack.search(6));

System.out.println(stack遍歷：);

while(!stack.empty()){

System.out.print(stack.pop() + );

}

}

}/span

List接口總結：實際使用中我們需要根據特定的需求選用合適的類，如果 除了在末尾外不能在其他位置插入或者刪除元素，那么ArrayList效率更高，如果需要經常插入或者刪除元素，就選擇LinkedList。

Set接口實現類HashSet：

HashSet是Set接口最常見的實現類，其底層是基于hash算法進行存儲相關元素的。HashSet中存儲元素的位置是固定的，并且是無序的。Set集合中的去重和hashCode與equals方法相關。

view plain copy

span style=font-size:14px;public class Num implements Comparable{

private int num;

public Num(int num){

this.num=num;

}

@Override

public int compareTo(Object o) {

// TODO Auto-generated method stub

Num x=(Num)o;

if(numx.num)return 1;

else if(num==x.num) return 0;

else return -1;

}

public String toString(){

return num=+num;

}

}/span

篇三：JAVA集合之Map映射深刻總結案例附上解釋跟總結

一．HashMap實例

案例1：HashMapDemo1

package Map映射;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

/** Java集合系列之Map映射學習總結

* 順序結構

* 基于哈希表的 Map 接口的實現 。

* 鍵和值都允許是null,值可以重復。

* 無序的

* 線程不安全的。

* 遍歷無序輸出.

* 和Set集一樣，沒有for循環遍歷的方法。

* 遍歷Map方法有兩種：

* ①調用keySet方法：

*Set keys = map.keySet();

* Iterator it = keys.iterator();

* ②調用entrySet方法：

*Set keys = map.entrySet();

*Iterator it = keys.iterator();

* 本例子遍歷的是基本類型

*

*/

public class HashMapDemo1 {

public static void main(String args) {

HashMap map = new HashMap();

map.put(1, 111);

map.put(1, 上海);

map.put(5, 廣州);

map.put(3, 西安);

map.put(null,武漢); //鍵允許是null

map.put(2, null);//值允許是null

map.put(null,null);//鍵和值都允許是null,會替換前面的null:武漢.

System.out.println(**********迭代器遍歷調用keySet方法*********);Set keys = map.keySet();//獲取所有的鍵，放入一個集合中

Iterator it = keys.iterator();//取得迭代器才可以遍歷

//遍歷出來的結果是無序的。

}

} while(it.hasNext()) { Object obj = it.next();//切記這個至少遍歷鍵，不是值。 System.out.println(obj+------+map.get(obj));//取得鍵對應的值 } System.out.println(**********迭代器遍歷調用entrySet方法*********); Set set1=map.entrySet(); Iterator iterator1=set1.iterator(); while (iterator1.hasNext()) { Map.Entry object = (Map.Entry) iterator1.next(); System.out.println(object.getKey()+------+object.getValue()); }

案例2：HashMapDemo2

package Map映射;

import java.util.*;

public class HashMapDemo2 {

@SuppressWarnings(rawtypes) public static void main(String args){ HashMapComparable, Comparable map=new HashMapComparable, HashMapInteger,Person2 map1=new HashMapInteger,Person2(); Person2 p1=new Person2(李川,111,80); Person2 p2=new Person2(李您,111,80); Comparable();//一個鍵對應一個值，而且鍵不能重復，會被覆蓋 Person2 p3=new Person2(林是,111,80); map1.put(1, p1); map1.put(2, p2); map1.put(3, p3);map.put(1, 110); map.put(2, 220); map.put(城市,福建); map.put(null, null); System.out.println(***********用keySet方法遍歷*********); Set keys=map.keySet();//取得鍵值，取得map所有的鍵值，存入set集合中 Iterator iterator=keys.iterator();//利用鍵值取得value值while(iterator.hasNext()){ Object object=iterator.next(); System.out.println(object+-------+map.get(object));//輸出是無序的 }

System.out.println(***********用entrySet方法遍歷*********); SetMap.EntryInteger,Person2 keys1=map1.entrySet();//查找文檔，發現map1調用entrySet方法返回的的是SetMap.EntryK,V，所以要用相應的接收。Map.EntryInteger,Person2可寫或不寫

IteratorMap.EntryInteger,Person2 iterator1=keys1.iterator(); //while(iterator1.hasNext()){ Map.EntryInteger,Person2 entry = (Map.EntryInteger,Person2) // entry.getValue();表示取得該鍵對應的值，這個值要是基本類型的話，那就 System.out.println((entry.getKey()+-------+姓名：得到一個Set的迭代器，在后面的遍歷中使用。SetMap.EntryK,V可寫可不寫。 iterator1.next(); 直接輸出，要是引用類型的話，還需要調用方法取得相應的值

+(entry.getValue()).getname()+學號：+(entry.getValue()).getno()+分數：+(entry.getValue()).getscore()));//輸出是無序的

}

class Person2{

String name; int no; int score; public Person2(String name,int no,int score){ this.name=name; this.no=no; this.score=score;} } } public void setname(String name){ this.name=name; } public void setno(int no){ this.no=no; } public void setscore(int score){ this.score=score; } public String getname(){ return name; } public int getno(){ return no; } public int getscore(){

} }

案例3：HashMapDemo3

package Map映射;

/**

*總結：HashMap用entrySet()方法遍歷用法：

*①SetMap.EntryInteger, Object keys = map3.entrySet();也是先取得集合中的(鍵-值)映射關系，放入keys集合中

*②IteratorMap.EntryInteger, Object iterator = keys.iterator();取得迭代器，用來遍歷(鍵-值)映射關系的集合.

*③iterator.hasNext();判斷是否有鍵

*④Map.EntryInteger,Object entry = iterator.next();遍歷第一個(鍵-值)映射關系，請注意，Map.entrySet 方法返回映射的 collection 視圖，用Map.Entry接收。

*這樣就可以通過調用entry.getKey()和entry.getValue()這兩個方法取得(鍵-值)映射關系中對應的值了。

*注意了，對于entry.getValue()，若是基本數據怎么不需要改變，若是引用類型： *Person3 p=(Person3) entry.getValue();

*System.out.println(entry.getKey()+----+pp.getname());

*/

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

public class HashMapDemo3 {

public static void main(String args){

HashMapInteger, Object map3=new HashMapInteger,Object();

Person3 p1=new Person3(李川,111,80); Person3 p2=new Person3(李川,111,80); Person3 p3=new Person3(李川,111,80); map3.put(1,11); map3.put(2, 110); map3.put(3, 220); map3.put(6, p1); map3.put(4,福建); map3.put(5, a); map3.put(null, null); map3.put(7, p2); map3.put(8, p3); map3.remove(6); SetMap.EntryInteger, Object keys = map3.entrySet();

IteratorMap.EntryInteger, Object iterator = keys.iterator();

while (iterator.hasNext()) {

Map.EntryInteger,Object entry = iterator.next();

if(entry.getValue() instanceof Person3){//entry.getValue()這是表示值，但是對應的是引用類型對象

Person3 pp=(Person3) entry.getValue();

System.out.println(entry.getKey()+----+pp.getname());

}

else {

System.out.println(entry.getKey()+----+entry.getValue());

}

}

}

}

class Person3{

String name;

int no;

int score;

public Person3(String name,int no,int score){

this.name=name;

this.no=no;

this.score=score;

}

public void setname(String name){

this.name=name;

}

public void setno(int no){

this.no=no;

}

public void setscore(int score){

this.score=score;

}

public String getname(){

return name;

}

public int getno(){

return no;

}

public int getscore(){

return score;

}