導航:首頁 > 編程語言 > javaset和list

javaset和list

發布時間:2023-03-29 02:24:23

java的集合類型有哪些

Java集合類型主要有3種:set(集)、list(列表)和map(映射)。

Collection、Set和List的區別如下:
Collection對象之間沒有指定的順序,允許有重復元素和多個null元素對象;它是Set和List介面的父類,是一種最通用型的集合介面;

Set各個元素對象之間沒有指定的順序,不允許有重復元素,最多允許有一個null元素對象;
List各個元素對象之間有指定的順序,允許重復元素和多個null元素對象;

Ⅱ Java中Set 和List兩個集合怎樣互相轉化

import java.util.HashSet;import java.util.Set;
public class tes {
public static void main(String[] args) {
//set集合,元素是不重復的。通過equal判斷是否相等
//如果是自定義的對象,需要重寫equal和hashcode方法
Set set = new HashSet();
set.add("sina");
set.add("");
set.add("");
System.out.println(set.toString());
set.remove("");
System.out.println(set.toString());

}
}

======
結果:
[, sina]
[sina]

Ⅲ java set 和 list的區別

java中setmaplist的區別:
都是集合介面
簡要說明
set--其中的值不允許重復,無序的數據結構
list--其中的值允許重復,因為其為有序的數據結構
map--成對的數據結構,健值必須具有唯一性(鍵不能同,否則值替換)
List按對象進入的順序保存對象,不做排序或編輯操作。Set對每個對象只接受一次,並使用自己內部的排序方法(通常,你只關心某個元素是否屬於Set,而不關心它的順序--否則應該使用List)。Map同樣對每個元素保存一份,但這是基於"鍵"的,Map也有內置的排序,因而不關心元素添加的順序。如果添加元素的順序對你很重要,應該使用LinkedHashSet或者LinkedHashMap.

List的功能方法
實際上有兩種List:一種是基本的ArrayList,其優點在於隨機訪問元素,另一種是更強大的LinkedList,它並不是為快速隨機訪問設計的,而是具有一套更通用的方法。
List:次序是List最重要的特點:它保證維護元素特定的順序。List為Collection添加了許多方法,使得能夠向List中間插入與移除元素(這只推薦LinkedList使用。)一個List可以生成ListIterator,使用它可以從兩個方向遍歷List,也可以從List中間插入和移除元素。
ArrayList:由數組實現的List。允許對元素進行快速隨機訪問,但是向List中間插入與移除元素的速度很慢。ListIterator只應該用來由後向前遍歷ArrayList,而不是用來插入和移除元素。因為那比LinkedList開銷要大很多。
LinkedList:對順序訪問進行了優化,向List中間插入與刪除的開銷並不大。隨機訪問則相對較慢。(使用ArrayList代替。)還具有下列方法:addFirst(),addLast(),getFirst(),getLast(),removeFirst()和removeLast(),這些方法(沒散舉有在任何介面或基類中定義過)使得LinkedList可以當作堆棧、隊列和雙向隊列使用。

Set的功能方法
Set具有與Collection完全一樣的介面,因此沒有任何額外的功能,不像前面有兩個不同的List。實際上Set就是Collection,只是行為不同。(這是繼承與多態思想的典型應用:表現不同的行為。)Set不保存重復的元素(至於如何判斷元素相同則較為負責)
Set:存入Set的每個元素都必須是唯一的,因為Set不保存重復元素。加入Set的元素必須定義equals()方法以確保對象的唯一性。Set與Collection有完全一樣的介面。Set介面不保證維護元素的次序。
HashSet:為快速查找設計的Set。存入HashSet的對象必須定義hashCode()。
TreeSet:保存次序的Set,底層為樹結構。使用它可以從Set中提取有序的序列。
LinkedHashSet:具有HashSet的查詢速度,且內部使用鏈表維護元素的順序(插入的次序)。於是在使悔悔用迭代器遍歷Set時,結果會按元素插入的次序顯示。

Map的功能方法
方法put(Objectkey,Objectvalue)添加一個「值」(想要得東西)和與「值」相關聯的「鍵」(key)(使用它來查找)。
方法get(Objectkey)返回與給定「鍵」相關聯的「值」。可以用containsKey()和containsValue()測試Map中是否包含某個碧掘正「鍵」或「值」。標準的Java類庫中包含了幾種不同的Map:HashMap,TreeMap,LinkedHashMap,WeakHashMap,IdentityHashMap。它們都有同樣的基本介面Map,但是行為、效率、排序策略、保存對象的生命周期和判定「鍵」等價的策略等各不相同。
執行效率是Map的一個大問題。看看get()要做哪些事,就會明白為什麼在ArrayList中搜索「鍵」是相當慢的。而這正是HashMap提高速度的地方。HashMap使用了特殊的值,稱為「散列碼」(hashcode),來取代對鍵的緩慢搜索。「散列碼」是「相對唯一」用以代表對象的int值,它是通過將該對象的某些信息進行轉換而生成的。所有Java對象都能產生散列碼,因為hashCode()是定義在基類Object中的方法。

HashMap就是使用對象的hashCode()進行快速查詢的。此方法能夠顯著提高性能。
Map:維護「鍵值對」的關聯性,使你可以通過「鍵」查找「值」
HashMap:Map基於散列表的實現。插入和查詢「鍵值對」的開銷是固定的。可以通過構造器設置容量capacity和負載因子loadfactor,以調整容器的性能。
LinkedHashMap:類似於HashMap,但是迭代遍歷它時,取得「鍵值對」的順序是其插入次序,或者是最近最少使用(LRU)的次序。只比HashMap慢一點。而在迭代訪問時發而更快,因為它使用鏈表維護內部次序。
TreeMap:基於紅黑樹數據結構的實現。查看「鍵」或「鍵值對」時,它們會被排序(次序由Comparabel或Comparator決定)。TreeMap的特點在於,你得到的結果是經過排序的。TreeMap是唯一的帶有subMap()方法的Map,它可以返回一個子樹。
WeakHashMao:弱鍵(weakkey)Map,Map中使用的對象也被允許釋放:這是為解決特殊問題設計的。如果沒有map之外的引用指向某個「鍵」,則此「鍵」可以被垃圾收集器回收。
IdentifyHashMap:使用==代替equals()對「鍵」作比較的hashmap。專為解決特殊問題而設計。
List介面對Collection進行了簡單的擴充,它的具體實現類常用的有ArrayList和LinkedList。你可以將任何東西放到一個List容器中,並在需要時從中取出。ArrayList從其命名中可以看出它是一種類似數組的形式進行存儲,因此它的隨機訪問速度極快,而LinkedList的內部實現是鏈表,它適合於在鏈表中間需要頻繁進行插入和刪除操作。在具體應用時可以根據需要自由選擇。前面說的Iterator只能對容器進行向前遍歷,而ListIterator則繼承了Iterator的思想,並提供了對List進行雙向遍歷的方法。

Set介面也是Collection的一種擴展,而與List不同的時,在Set中的對象元素不能重復,也就是說你不能把同樣的東西兩次放入同一個Set容器中。它的常用具體實現有HashSet和TreeSet類。HashSet能快速定位一個元素,但是你放到HashSet中的對象需要實現hashCode()方法,它使用了前面說過的哈希碼的演算法。而TreeSet則將放入其中的元素按序存放,這就要求你放入其中的對象是可排序的,這就用到了集合框架提供的另外兩個實用類Comparable和Comparator。一個類是可排序的,它就應該實現Comparable介面。有時多個類具有相同的排序演算法,那就不需要在每分別重復定義相同的排序演算法,只要實現Comparator介面即可。集合框架中還有兩個很實用的公用類:Collections和Arrays。Collections提供了對一個Collection容器進行諸如排序、復制、查找和填充等一些非常有用的方法,Arrays則是對一個數組進行類似的操作。

Map是一種把鍵對象和值對象進行關聯的容器,而一個值對象又可以是一個Map,依次類推,這樣就可形成一個多級映射。對於鍵對象來說,像Set一樣,一個Map容器中的鍵對象不允許重復,這是為了保持查找結果的一致性;如果有兩個鍵對象一樣,那你想得到那個鍵對象所對應的值對象時就有問題了,可能你得到的並不是你想的那個值對象,結果會造成混亂,所以鍵的唯一性很重要,也是符合集合的性質的。當然在使用過程中,某個鍵所對應的值對象可能會發生變化,這時會按照最後一次修改的值對象與鍵對應。對於值對象則沒有唯一性的要求。你可以將任意多個鍵都映射到一個值對象上,這不會發生任何問題(不過對你的使用卻可能會造成不便,你不知道你得到的到底是那一個鍵所對應的值對象)。Map有兩種比較常用的實現:HashMap和TreeMap。HashMap也用到了哈希碼的演算法,以便快速查找一個鍵,TreeMap則是對鍵按序存放,因此它便有一些擴展的方法,比如firstKey(),lastKey()等,你還可以從TreeMap中指定一個范圍以取得其子Map。鍵和值的關聯很簡單,用pub(Objectkey,Objectvalue)方法即可將一個鍵與一個值對象相關聯。用get(Objectkey)可得到與此key對象所對應的值對象。

Ⅳ 在java中,set集合和list集合有什麼相同點和不同點

在網上看到一點,可能對你有所幫助
Set(集合):
Set是最簡單的一種集合。集合中的對象不按特定的方式排序,並且沒有重復對象。
Set介面主要實現了兩個實現類:
HashSet:HashSet類按照哈希演演算法來存取集合中的對象,存取速度比較快
TreeSet:TreeSet類實現了SortedSet介面,能夠對集合中的對象進行排序。
Set的用法:
存放的是對象的引用,沒有重復對象
Setset=newHashSet();
Strings1=newString("hello");
Strings2=s1;
Strings3=newString("world");
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size());//列印集合中對象的數目為2。
Set的add()方法是如何判斷對象是否判陵已經存放在集合中?
booleanisExists=false;
掘鉛戚Iteratoriterator=set.iterator();
while(it.hasNext()){
StringoldStr=it.next();
if(newStr.equals(oldStr)){
isExists=true;
}
}
List(列表):
List的特徵是其元素以線性方式存儲,集合中可以存放重復對象。
List介面主要實現類包括:
ArrayList():代表長度可以改變得數組。可以對元素進行隨機的訪問,向ArrayList()中插入激坦與
與刪除元素的速度慢。
LinkedList():在實現中採用鏈表數據結構。插入和刪除速度快,訪問速度慢。
對於List的隨機訪問來說,就是只隨機來檢索位於特定位置的元素。
List的get(intindex)方法放回集合中由參數index指定的索引位置的對象,下標從「0」開始。
最基本的兩種檢索集合中的所有對象的方法:1:用for循環和get()方法:
for(inti=0;i<LIST.SIZE();I++){<P>
System.out.println(list.get(i));
}
2:使用迭代器(Iterator):
Iteratorit=list.iterator();
while(it.hashNext){
System.out.println(it.next);
}

Ⅳ Java中的Set,List,Map的區別

對JAVA的集合的理解是想對於數組

數組是大小固定的 並且同一個數組只能存放類型一樣的數據(基本類型/引用類型)

JAVA集合可以存儲和操作數目不固定的一組數據

所有的JAVA集合都位於 java util包中!

JAVA集合只能存放引用類型的的數據 不能存放基本數據類型

JAVA集合主要分為三種類型

Set(集)

List(列表)

Map(映射)

Collection 介面

Collection是最基本的集合介面 聲明了適用於JAVA集合(只包括Set和List)的通用方法

Set 和List 都繼承了Conllection Map沒有

Collection介面的方法

boolean add(Object o) :向集合中加入一個對象的引用

void clear() :刪除集合中所有的對象 即不再持有這些對象的引用

boolean isEmpty() :判斷集合是否為空

boolean contains(Object o): 判斷集合中是否持有特定對象的引用

Iterartor iterator() : 返回一個Iterator對象 可以用來遍歷集合中的元素

boolean remove(Object o):從集合中刪除一個對象的引用

int size() :返回集合中元素的數目

Object[] toArray() :返回一個數組 該數組中包括集合中的所有元素

關於 Iterator() 和toArray() 方法都用於集合的所有的元素 前者返回一個Iterator對象 後者返回一個

包含集合中所有元素的數組

Iterator介面聲明了如下方法

hasNext(): 判斷集合中元素是否遍歷完畢 如果沒有 就返回true

next() :返回下一個元素

remove():從集合中刪除上一個有next()方法返回的元素

Set(集合)

Set是最簡單的一種集合 集合中的對象不按特定的方式排序 並且沒有重復對象

Set介面主要實現了兩個實現類

HashSet : HashSet類按照哈希演算法來存取集合中的對象 存取速度比較快

TreeSet : TreeSet類實現了SortedSet介面 能夠對集合中的對象進行排序

Set 的用法

存放的是對象的引用 沒有重復對象

Set set=new HashSet();

String s =new String( hello );

String s =s ;

String s =new String( world );

set add(s );

set add(s );

set add(s );

System out println(set size());//列印集合中對象的數目 為

Set 的 add()方法是如何判斷對象是否已經存放在集合中?

boolean isExists=false;

Iterator iterator=erator();

while(it hasNext()) {

String oldStr=it next();

if(newStr equals(oldStr)){

isExists=true;

}

}

List(列表)

List的特徵是其元素以線性方式存儲 集合中可以存放重復對象

List介面主要實現類包括

ArrayList() : 代表長度可以改變得數組 可以對元素進行隨機的訪問 向ArrayList()中插入與

與刪除元素的速度慢

LinkedList(): 在實現中採用鏈表數據結構 插入和刪除速度快 訪問速度慢

對於List的隨機訪問來說 就是只隨機來檢索位於特定位置的元素

List 的 get(int index) 方法放回集合中由參數index指定的索引位置的對象 下標從 開始

最基本的兩種檢索集合中的所有對象的方法

: 用for循環和get()方法

for(int i= ; i<list size();i++){

System out println(list get(i));

}

: 使用 迭代器(Iterator):

Iterator it=erator();

while(it hashNext){

System out println(it next);

}

Map(映射):

Map 是一種把鍵對象和值對象映射的集合 它的每一個元素都包含一對鍵對象和值對象

Map沒有繼承於Collection介面

從Map集合中檢索元素時 只要給出鍵對象 就會返回對應的值對象

Map 的常用方法

添加 刪除操作

Object put(Object key Object value): 向集合中加入元素

Object remove(Object key): 刪除與KEY相關的元素

void putAll(Map t): 將來自特定映像的所有元素添加給該映像

void clear(): 從映像中刪除所有映射

查詢操作

Object get(Object key): 獲得與關鍵字key相關的值

Map集合中的鍵對象不允許重復 也就說 任意兩個鍵對象通過equals()方法比較的結果都是false

但是可以將任意多個鍵獨享映射到同一個值對象上

Conllections : 集合實用類

Conllections提供了供JAVA集合實用的靜態方法

總結

JAVA集合的基本用法 都歸納了 上面這些是平常最常用的JAVA集合 具體的其他的 還要參考JDK幫助文檔了 呵呵 關於 Map的應用 還有很多 具體就是這個 Conllections提供了很多 List /Map 實用的方法 對平常開發非常有用

對次會會不斷修改!

boolean containsKey(Object key): 判斷映像中是否存在關鍵字key

boolean containsValue(Object value): 判斷映像中是否存在值value

int size(): 返回當前映像中映射的數量

boolean isEmpty() 判斷映像中是否有任何映射

List按對象進入的順序保存對象 不做排序或編輯操作 Set對每個對象只接受一次 並使用自己內部的排序方法(通常 你只關心某個元素是否屬於Set 而不關心它的順序 否則應該使用List) Map同樣對每個元素保存一份 但這是基於 鍵 的 Map也有內置的排序 因而不關心元素添加的順序 如果添加元素的順序對你很重要 應該使用 LinkedHashSet或者LinkedHashMap

List的功能方法

實際上有兩種List: 一種是基本的ArrayList 其優點在於隨機訪問元素 另一種是更強大的LinkedList 它並不是為快速隨機訪問設計的 而是具有一套更通用的方法

List : 次序是List最重要的特點 它保證維護元素特定的順序 List為Collection添加了許多方法 使得能夠向List中間插入與移除元素(這只推薦LinkedList使用 )一個List可以生成ListIterator 使用它可以從兩個方向遍歷List 也可以從List中間插入和移除元素

ArrayList : 由數組實現的List 允許對元素進行快速隨機訪問 但是向List中間插入與移除元素的速度很慢 ListIterator只應該用來由後向前遍歷ArrayList 而不是用來插入和移除元素 因為那比LinkedList開銷要大很多

LinkedList : 對順序訪問進行了優化 向List中間插入與刪除的開銷並不大 隨機訪問則相對較慢 (使用ArrayList代替 )還具有下列方法 addFirst() addLast() getFirst() getLast() removeFirst() 和 removeLast() 這些方法 (沒有在任何介面或基類中定義過)使得LinkedList可以當作堆棧 隊列和雙向隊列使用

Set的功能方法

Set具有與Collection完全一樣的介面 因此沒有任何額外的功能 不像前面有兩個不同的List 實際上Set就是Collection 只是行為不同 (這是繼承與多態思想的典型應用 表現不同的行為 )Set不保存重復的元素(至於如何判斷元素相同則較為負責)

Set : 存入Set的每個元素都必須是唯一的 因為Set不保存重復元素 加入Set的元素必須定義equals()方法以確保對象的唯一性 Set與Collection有完全一樣的介面 Set介面不保證維護元素的次序

HashSet : 為快速查找設計的Set 存入HashSet的對象必須定義hashCode()

TreeSet : 保存次序的Set 底層為樹結構 使用它可以從Set中提取有序的序列

LinkedHashSet : 具有HashSet的查詢速度 且內部使用鏈表維護元素的順序(插入的次序) 於是在使用迭代器遍歷Set時 結果會按元素插入的次序顯示

Map的功能方法

方法put(Object key Object value)添加一個 值 (想要得東西)和與 值 相關聯的 鍵 (key)(使用它來查找) 方法get(Object key)返回與給定 鍵 相關聯的 值 可以用containsKey()和containsValue()測試Map中是否包含某個 鍵 或 值 標準的Java類庫中包含了幾種不同的Map HashMap TreeMap LinkedHashMap WeakHashMap IdentityHashMap 它們都有同樣的基本介面Map 但是行為 效率 排序策略 保存對象的生命周期和判定 鍵 等價的策略等各不相同

執行效率是Map的一個大問題 看看get()要做哪些事 就會明白為什麼在ArrayList中搜索 鍵 是相當慢的 而這正是HashMap提高速度的地方 HashMap使用了特殊的值 稱為 散列碼 (hash code) 來取代對鍵的緩慢搜索 散列碼 是 相對唯一 用以代表對象的int值 它是通過將該對象的某些信息進行轉換而生成的 所有Java對象都能產生散列碼 因為hashCode()是定義在基類Object中的方法

HashMap就是使用對象的hashCode()進行快速查詢的 此方法能夠顯著提高性能

Map : 維護 鍵值對 的關聯性 使你可以通過 鍵 查找 值

HashMap : Map基於散列表的實現 插入和查詢 鍵值對 的開銷是固定的 可以通過構造器設置容量capacity和負載因子load factor 以調整容器的性能

LinkedHashMap : 類似於HashMap 但是迭代遍歷它時 取得 鍵值對 的順序是其插入次序 或者是最近最少使用(LRU)的次序 只比HashMap慢一點 而在迭代訪問時發而更快 因為它使用鏈表維護內部次序

TreeMap : 基於紅黑樹數據結構的實現 查看 鍵 或 鍵值對 時 它們會被排序(次序由Comparabel或Comparator決定) TreeMap的特點在於 你得到的結果是經過排序的 TreeMap是唯一的帶有subMap()方法的Map 它可以返回一個子樹

WeakHashMao : 弱鍵(weak key)Map Map中使用的對象也被允許釋放: 這是為解決特殊問題設計的 如果沒有map之外的引用指向某個 鍵 則此 鍵 可以被垃圾收集器回收

lishixin/Article/program/Java/ky/201311/27866

Ⅵ java中 List 與Set 的區別

復制的,但是比較詳細,樓主看看吧:

ArrayList Vector LinkedList 區別與用法

ArrayList 和Vector是採用數組方式存儲數據,此數組元素數大於實際存儲的數據以便增加和插入元素,都允許直接序號索引元素,但是插入數據要設計到數組元素移動等內存操作,所以索引數據快插入數據慢,Vector由山山桐於使用了synchronized方法(線程安全)所以性能上比ArrayList要差,LinkedList使用雙向鏈表實現存儲,按序號索引數據需要進行向前或向後遍歷,但是插入數據時只需要記錄本項的前後項即可,所以插入數度較快!

線性表,鏈表,哈希表是常用的數據結構,在進行Java開發時,JDK已經為我們提供了一系列相應的類來實現基本的數據結構。這些類均在java.util包中。本文試圖通過簡單的描述,向讀者闡述各個類的作用以及如何正確使用這些類。

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection介面
Collection是最基本的集合介面,一個Collection代表一組Object,即Collection的元素(Elements)。一些Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類,Java SDK提供的類都是繼承自Collection的「子介面」如List和Set。
所有實現Collection介面的類都必須提供兩個標準的構造函數:無參數的構造函數用於創建一個空的Collection,有一個Collection參數的構造函數用於創建一個新的Collection,這個新的Collection與傳入的Collection有相同的元素。後一個構造函數允許用戶復制一個Collection。
如何遍歷Collection中的每一個元素?不論Collection的實際類型如何,它都支持一個iterator()的方法,該方法返回一個迭代子,使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下:
Iterator it = collection.iterator(); // 獲得一個迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一個元素
}
由Collection介面派生的兩個介面是List和Set。

List介面
List是有序的Collection,使用此介面能夠精確的控制每個元素插入的位置。用戶能夠使用索引(元素在List中的位置,類似於數組下標)來訪問List中的元素,這類似於Java的數組。
和下面要提到的Set不同,List允許有相同的元素。
除了具有Collection介面必備的iterator()方法外,List還提供一個listIterator()方法,返回一個ListIterator介面,和標準的Iterator介面相比,ListIterator多了一些add()之類的方法,允許添加,刪除,設定元素,還能向前或向後遍歷。
實現List介面的常用類有LinkedList,ArrayList,Vector和Stack。

LinkedList類
LinkedList實現了List介面,允許null元素。此外LinkedList提供逗坦額外的get,remove,insert方法在LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧(stack),隊列(queue)或雙向隊列(deque)。
注意LinkedList沒有同步方法。如果多個線程同時訪問一個List,則必須自唯基己實現訪問同步。一種解決方法是在創建List時構造一個同步的List:
List list = Collections.synchronizedList(new LinkedList(...));

ArrayList類
ArrayList實現了可變大小的數組。它允許所有元素,包括null。ArrayList沒有同步。
size,isEmpty,get,set方法運行時間為常數。但是add方法開銷為分攤的常數,添加n個元素需要O(n)的時間。其他的方法運行時間為線性。
每個ArrayList實例都有一個容量(Capacity),即用於存儲元素的數組的大小。這個容量可隨著不斷添加新元素而自動增加,但是增長演算法並沒有定義。當需要插入大量元素時,在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。
和LinkedList一樣,ArrayList也是非同步的(unsynchronized)。

Vector類
Vector非常類似ArrayList,但是Vector是同步的。由Vector創建的Iterator,雖然和ArrayList創建的Iterator是同一介面,但是,因為Vector是同步的,當一個Iterator被創建而且正在被使用,另一個線程改變了Vector的狀態(例如,添加或刪除了一些元素),這時調用Iterator的方法時將拋出,因此必須捕獲該異常。

Stack 類
Stack繼承自Vector,實現一個後進先出的堆棧。Stack提供5個額外的方法使得Vector得以被當作堆棧使用。基本的push和pop方法,還有peek方法得到棧頂的元素,empty方法測試堆棧是否為空,search方法檢測一個元素在堆棧中的位置。Stack剛創建後是空棧。

Set介面
Set是一種不包含重復的元素的Collection,即任意的兩個元素e1和e2都有e1.equals(e2)=false,Set最多有一個null元素。
很明顯,Set的構造函數有一個約束條件,傳入的Collection參數不能包含重復的元素。
請注意:必須小心操作可變對象(Mutable Object)。如果一個Set中的可變元素改變了自身狀態導致Object.equals(Object)=true將導致一些問題。

Map介面
請注意,Map沒有繼承Collection介面,Map提供key到value的映射。一個Map中不能包含相同的key,每個key只能映射一個value。Map介面提供3種集合的視圖,Map的內容可以被當作一組key集合,一組value集合,或者一組key-value映射。

Hashtable類
Hashtable繼承Map介面,實現一個key-value映射的哈希表。任何非空(non-null)的對象都可作為key或者value。
添加數據使用put(key, value),取出數據使用get(key),這兩個基本操作的時間開銷為常數。
Hashtable通過initial capacity和load factor兩個參數調整性能。通常預設的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但相應的查找時間將增大,這會影響像get和put這樣的操作。
使用Hashtable的簡單示例如下,將1,2,3放到Hashtable中,他們的key分別是」one」,」two」,」three」:
Hashtable numbers = new Hashtable();
numbers.put(「one」, new Integer(1));
numbers.put(「two」, new Integer(2));
numbers.put(「three」, new Integer(3));
要取出一個數,比如2,用相應的key:
Integer n = (Integer)numbers.get(「two」);
System.out.println(「two = 」 + n);
由於作為key的對象將通過計算其散列函數來確定與之對應的value的位置,因此任何作為key的對象都必須實現hashCode和equals方法。hashCode和equals方法繼承自根類Object,如果你用自定義的類當作key的話,要相當小心,按照散列函數的定義,如果兩個對象相同,即obj1.equals(obj2)=true,則它們的hashCode必須相同,但如果兩個對象不同,則它們的hashCode不一定不同,如果兩個不同對象的hashCode相同,這種現象稱為沖突,沖突會導致操作哈希表的時間開銷增大,所以盡量定義好的hashCode()方法,能加快哈希表的操作。
如果相同的對象有不同的hashCode,對哈希表的操作會出現意想不到的結果(期待的get方法返回null),要避免這種問題,只需要牢記一條:要同時復寫equals方法和hashCode方法,而不要只寫其中一個。
Hashtable是同步的。

HashMap類
HashMap和Hashtable類似,不同之處在於HashMap是非同步的,並且允許null,即null value和null key。,但是將HashMap視為Collection時(values()方法可返回Collection),其迭代子操作時間開銷和HashMap的容量成比例。因此,如果迭代操作的性能相當重要的話,不要將HashMap的初始化容量設得過高,或者load factor過低。

WeakHashMap類
WeakHashMap是一種改進的HashMap,它對key實行「弱引用」,如果一個key不再被外部所引用,那麼該key可以被GC回收。

總結
如果涉及到堆棧,隊列等操作,應該考慮用List,對於需要快速插入,刪除元素,應該使用LinkedList,如果需要快速隨機訪問元素,應該使用ArrayList。
如果程序在單線程環境中,或者訪問僅僅在一個線程中進行,考慮非同步的類,其效率較高,如果多個線程可能同時操作一個類,應該使用同步的類。
要特別注意對哈希表的操作,作為key的對象要正確復寫equals和hashCode方法。
盡量返回介面而非實際的類型,如返回List而非ArrayList,這樣如果以後需要將ArrayList換成LinkedList時,客戶端代碼不用改變。這就是針對抽象編程

同步性
Vector是同步的。這個類中的一些方法保證了Vector中的對象是線程安全的。而ArrayList則是非同步的,因此ArrayList中的對象並不是線程安全的。因為同步的要求會影響執行的效率,所以如果你不需要線程安全的集合那麼使用ArrayList是一個很好的選擇,這樣可以避免由於同步帶來的不必要的性能開銷。
數據增長
從內部實現機制來講ArrayList和Vector都是使用數組(Array)來控制集合中的對象。當你向這兩種類型中增加元素的時候,如果元素的數目超出了內部數組目前的長度它們都需要擴展內部數組的長度,Vector預設情況下自動增長原來一倍的數組長度,ArrayList是原來的50%,所以最後你獲得的這個集合所佔的空間總是比你實際需要的要大。所以如果你要在集合中保存大量的數據那麼使用Vector有一些優勢,因為你可以通過設置集合的初始化大小來避免不必要的資源開銷。
使用模式
在ArrayList和Vector中,從一個指定的位置(通過索引)查找數據或是在集合的末尾增加、移除一個元素所花費的時間是一樣的,這個時間我們用O(1)表示。但是,如果在集合的其他位置增加或移除元素那麼花費的時間會呈線形增長:O(n-i),其中n代表集合中元素的個數,i代表元素增加或移除元素的索引位置。為什麼會這樣呢?以為在進行上述操作的時候集合中第i和第i個元素之後的所有元素都要執行位移的操作。這一切意味著什麼呢?
這意味著,你只是查找特定位置的元素或只在集合的末端增加、移除元素,那麼使用Vector或ArrayList都可以。如果是其他操作,你最好選擇其他的集合操作類。比如,LinkList集合類在增加或移除集合中任何位置的元素所花費的時間都是一樣的?O(1),但它在索引一個元素的使用缺比較慢-O(i),其中i是索引的位置.使用ArrayList也很容易,因為你可以簡單的使用索引來代替創建iterator對象的操作。LinkList也會為每個插入的元素創建對象,所有你要明白它也會帶來額外的開銷。
最後,在《Practical Java》一書中Peter Haggar建議使用一個簡單的數組(Array)來代替Vector或ArrayList。尤其是對於執行效率要求高的程序更應如此。因為使用數組(Array)避免了同步、額外的方法調用和不必要的重新分配空間的操作。

Ⅶ java中 List 與Set 有什麼區別

Java的集合類都位於java.util包中,Java集合中存放的是對象的引用,而非對象本身。

Java集合主要分為三種類型:
a.Set(集):集合中的對象不按特定方式排序,並且沒有重復對象。它的有些實現類能對集合中的對象按特定方式排序。
b.List(列表):集合中的對象按索引位置排序,可以有重復對象,允許按照對象在集合中的索引位置檢索對象。
c.Map(映射):集合中的每一個元素包含一對鍵對象和值對象,集合中沒有重復的鍵對象,值對象可以重復。它的有些實現類能對集合中的鍵對象進行排序。

Set、List和Map統稱為Java集合。

1.Set(集)
Set集合中的對象不按特定方式排序,並且沒有重復對象。Set介面主要有兩個實現類HashSet和TreeSet。HashSet類按照哈希演算法來存取集合中的對象,存取速度比較快。HashSet類還有一個子類LinkedHashSet類,它不僅實現了哈希演算法,而且實現了鏈表數據結構。TreeSet類實現了SortedSet介面,具有排序功能。

Set的add()方法判斷對象是否已經存在於集合中的判斷流程:
boolean isExists = false;
Iterator it = set.iterator();
while(it.hasNext()){
Object object = it.next();
if(newObject.equals(oldObject)){
isExists = true;
break;
}
}

2.HashSet類
當HashSet向集合中加入一個對象時,會調用對象的hashCode()方法獲得哈希碼,然後根據這個哈希碼進一步計算出對象在集合中的存放位置。

當Object1變數和object2變數實際上引用了同一個對象,那麼object1和object2的哈希碼肯定相同。

為了保證HashSet能正常工作,要求當兩個對象用equals()方法比較的結果為相等時,它們的哈希碼也相等。即:
customer1.hashCode() == customer2.hashCode();

如:對應於Customer類的以下重寫後的equals()方法:

public boolean equals(Object o){
if(this==o) return true;
if(!o instanceof Customer) return false;
final Customer other = (Customer)o;
if(this.name.equals(other.getName())&&this.age==other.getAge())
return true;
else
return false;
}

為了保證HashSet正常工作,如果Customer類覆蓋了equals()方法,也應該覆蓋hashCode()方法,並且保證兩個相等的Customer對象的哈希碼也一樣。

public int hashCode(){
int result;
result = (name==null?0:name.hashCode());
result = 29*result+(age==null?0:age.hashCode());
return result;
}

3.TreeSet類

TreeSet類實現了SortedSet介面,能夠對集合中的對象進行排序。TreeSet支持兩種排序方式:自然排序和客戶化排序,在默認情況下TreeSet採用自然排序方式。

a.自然排序
在JDK中,有一部分類實現了Comparable介面,如Integer、Double和String等。Comparable介面有一個compareTo(Object o)方法,它返回整數類型。對於表達式x.compareTo(y),如果返回值為0,表示x和y相等,如果返回值大於0,表示x大於y,如果返回值小於0,表示x小於y。

TreeSet調用對象的compareTo()方法比較集合中對象的大小,然後進行升序排列,這種排序方式稱為自然排序。

以下列出了JDK中實現了Comparable介面的一些類的排序方式
類 排序
BigDecimal\BigInteger\Byte\Double\Float\Integer\Long\Short 按數字大小排序
Character 按字元的Unicode值的數字大小排序
String 按字元串中字元的Unicode值排序

使用自然排序時,只能向TreeSet集合中加入同類型的對象,並且這些對象的類必須實現了Comparable介面,否則會在第二次調用TreeSet的add()方法時,會拋出ClassCastException異常。

例如:
以下是Customer類的compareTo()方法的一種實現方式:
public int compareTo(Object o){
Customer other = (Customer)o;

//先按照name屬性排序
if(this.name.compareTo(other.getName())>0) return 1;
if(this.name.compareTo(other.getName())<0) return -1;

//再按照age屬性排序
if(this.age>other.getAge()) return 1;
if(this.age<other.getAge()) return -1;

return 0;
}

為了保證TreeSet能正確地排序,要求Customer類的compareTo()方法與equals()方法按相同的規則比較兩個Customer對象是否相等。
因此在Customer類的equals()方法中應該採用相同的比較規則:

public boolean equals(Object o){
if(this==o) return true;
if(!(o instanceof Customer)) return false;
final Customer other = (Customer)o;

if(this.name.equals(other.getName())&&this.age==other.getAge()){
return true;
}else{
return false;
}
}

值得注意的是,對於TreeSet中已經存在的Customer對象,如果修改了它們的屬性,TreeSet不會對集合進行重新排序。在實際域模型中,實體類的屬性可以被更新,因此不適合通過TreeSet來排序。最適合於排序的是不可變類。

b.客戶化排序

除了自然排序,TreeSet還支持客戶化排序。java.util.Comparator介面用於指定具體的排序方式,它有個compare(Object object1,Object object2)方法,用於比較兩個對象的大小。當表達式compare(x,y)的值大於0,表示x大於y;當compare(x,y)的值小於0,表示x小於y;當compare(x,y)的值等於0,表示x等於y。
例如:如果希望TreeSet僅按照Customer對象的name屬性進行降序排列,可以創建一個實現Comparator介面的類CustomerComparator:

public class CustomerComparator implements Comparator{
public int compare(Object o1,Object o2){
Customer c1= (Customer)o1;
Customer c2 = (Customer)o2;

if(c1.getName().compareTo(c2.getName())>0) return -1;
if(c2.getName().compareTo(c2.getName())<0) return 1;

return 0;
}
}

接下來在構造TreeSet的實例時,調用它的TreeSet(Comparator comparator)構造方法:
Set set = new TreeSet(new CustomerComparator());

4.向Set中加入持久化類的對象

例如兩個Session實例從資料庫載入相同的Order對象,然後往HashSet集合里存放,在默認情況下,Order類的equals()方法比較兩個Orer對象的內存地址是否相同,因此order1.equals(order2)==false,所以order1和order2游離對象都加入到HashSet集合中,但實際上order1和order2對應的是ORDERS表中的同一條記錄。對於這一問題,有兩種解決方案:

(1)在應用程序中,謹慎地把來自於不同Session緩存的游離對象加入到Set集合中,如:
Set orders = new HashSet();
orders.add(order1);
if(!order2.getOrderNumber().equals(order1.getOrderNumber()))
order.add(order2);

(2)在Order類中重新實現equals()和hashCode()方法,按照業務主鍵比較兩個Order對象是否相等。

提示:為了保證HashSet正常工作,要求當一個對象加入到HashSet集合中後,它的哈希碼不會發生變化。

5.List(列表)

List的主要特徵是其對象以線性方式存儲,集合中允許存放重復對象。List介面主要的實現類有LinkedList和ArrayList。LinkedList採用鏈表數據結構,而ArrayList代表大小可變的數組。List介面還有一個實現類Vector,它的功能和ArrayList比較相似,兩者的區別在於Vector類的實現採用了同步機制,而ArrayList沒有使用同步機制。

List只能對集合中的對象按索引位置排序,如果希望對List中的對象按其他特定方式排序,可以藉助Comparator和Collections類。Collections類是集合API中的輔助類,它提供了操縱集合的各種靜態方法,其中sort()方法用於對List中的對象進行排序:
a.sort(List list):對List中的對象進行自然排序。
b.sort(List list,Comparator comparator):對List中的對象進行客戶化排序,comparator參數指定排序方式。

如Collections.sort(list);

6.Map(映射)

Map(映射)是一種把鍵對象和值對象進行映射的集合,它的每一個元素都包含一對鍵對象和值對象,而值對象仍可以是Map類型,依次類推,這樣就形成了多級映射。

Map有兩種比較常用的實現:HashMap和TreeMap。HashMap按照哈希演算法來存取鍵對象,有很好的存取性能,為了保證HashMap能正常工作,和HashSet一樣,要求當兩個鍵對象通過equals()方法比較為true時,這兩個對象的hashCode()方法返回的哈希碼也一樣。

TreeMap實現了SortedMap介面,能對鍵對象進行排序。和TreeSet一樣,TreeMap也支持自然排序和客戶化排序兩種方式。

例:創建一個緩存類EntityCache,它能粗略地模仿Session的緩存功能,保證緩存中不會出現兩個OID相同的Customer對象或兩個OID相同的Order對象,這種惟一性是由鍵對象的惟一性來保證的。

Key.java:

package mypack;

public class Key{
private Class classType;
private Long id;

public Key(Class classType,Long id){
this.classType = classType;
this.id = id;
}

public Class getClassType(){
return this.classType;
}

public Long getId(){
return this.id;
}

public boolean equals(Object o){
if(this==o) return true;
if(!(o instanceof Key)) return false;
final Key other = (Key)o;
if(classType.equals(other.getClassType())&&id.equals(other.getId()))
return true;
return false;
}

public int hashCode(){
int result;
result = classType.hashCode();
result = 29 * result + id.hashCode();
return result;
}
}

EntityCache.java:

package mypack;
import java.util.*;
public class EntityCache {
private Map entitiesByKey;
public EntityCache() {
entitiesByKey=new HashMap();
}

public void put(BusinessObject entity){
Key key=new Key(entity.getClass(),entity.getId());
entitiesByKey.put(key,entity);
}

public Object get(Class classType,Long id){
Key key=new Key(classType,id);
return entitiesByKey.get(key);
}

public Collection getAllEntities(){
return entitiesByKey.values();
}
public boolean contains(Class classType,Long id){
Key key=new Key(classType,id);
return entitiesByKey.containsKey(key);
}
}

閱讀全文

與javaset和list相關的資料

熱點內容
java怎麼退出 瀏覽:900
掛接pdf 瀏覽:163
浪潮伺服器遠程修改bmc地址 瀏覽:119
單立文電影 瀏覽:871
linuxtar命令 瀏覽:874
優酷app如何屏蔽短視頻 瀏覽:480
看著就解壓的軟體 瀏覽:785
android撥號界面源碼 瀏覽:54
在線高清 瀏覽:375
程序員陸漓發型劉海 瀏覽:484
台灣電影《三十兒立》 瀏覽:315
南京學程序員培訓班 瀏覽:267
怎麼把華為手機app密碼刪掉 瀏覽:623
android事件冒泡 瀏覽:685
大片在線高清電影 瀏覽:791
程序員限制年齡怎麼辦 瀏覽:428
ug80數控編程視頻教程下載 瀏覽:771
四川信息化少兒編程定製 瀏覽:9
跟血戀一樣打真搶的電影 瀏覽:931
雲伺服器為什麼快 瀏覽:877