【集合系列】- 深入淺出的分析 Set集合
一、摘要
關於 Set 介面,在實際開發中,其實很少用到,但是如果你出去面試,它可能依然是一個繞不開的話題。
言歸正傳,廢話咱們也不多說了,相信使用過 Set 集合類的朋友都知道,Set集合的特點主要有:元素不重複、儲存無序的特點。
啥意思呢?你可以理解為,向一個瓶子裡面扔東西,這些東西沒有記號是第幾個放進去的,但是有一點就是這個瓶子裡面不會有重樣的東西。
細細思考,你會發現, Set 集合的這些特性正處於 List 集合和 Map 集合之間,為什麼這麼說呢?之前的集合文章中,咱們瞭解到,List 集合的特點就是存取有序,本質是一個有序陣列,每個元素依次按照順序儲存;Map 集合主要用於存放鍵值對,雖然底層也是用陣列存放,但是元素在陣列中的下標是通過雜湊演算法計算出來的,陣列下標無序。
而 Set 集合,在元素儲存方面,注重獨立無二的特性,如果某個元素在集合中已經存在,不會儲存重複的元素,同時,集合儲存的是元素,不像 Map 集合那樣儲存的是鍵值對。
具體的分析,咱們慢慢道來,開啟 Set 集合,主要實現類有 HashSet、LinkedHashSet 、TreeSet 、EnumSet( RegularEnumSet、JumboEnumSet )等等,總結 Set 介面實現類,圖如下:
由圖中的繼承關係,可以知道,Set 介面主要實現類有 AbstractSet、HashSet、LinkedHashSet 、TreeSet 、EnumSet( RegularEnumSet、JumboEnumSet ),其中 AbstractSet、EnumSet 屬於抽象類,EnumSet 是在 jdk1.5 中新增的,不同的是 EnumSet 集合元素必須是列舉型別。
- HashSet 是一個輸入輸出無序的集合,集合中的元素基於 HashMap 的 key 實現,元素不可重複;
- LinkedHashSet 是一個輸入輸出有序的集合,集合中的元素基於 LinkedHashMap 的 key 實現,元素也不可重複;
- TreeSet 是一個排序的集合,集合中的元素基於 TreeMap 的 key 實現,同樣元素不可重複;
- EnumSet 是一個與列舉型別一起使用的專用 Set 集合,其中 RegularEnumSet 和 JumboEnumSet 不能單獨例項化,只能由 EnumSet 來生成,同樣元素不可重複;
下面咱們來對各個主要實現類進行一一分析!
二、HashSet
HashSet 是一個輸入輸出無序的集合,底層基於 HashMap 來實現,HashSet 利用 HashMap 中的key
元素來存放元素,這一點我們可以從原始碼上看出來,閱讀原始碼如下:
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable{
// HashMap 變數
private transient HashMap<E,Object> map;
/**HashSet 初始化*/
public HashSet() {
//預設例項化一個 HashMap
map = new HashMap<>();
}
}
2.1、add方法
開啟HashSet
的add()
方法,原始碼如下:
public boolean add(E e) {
//向 HashMap 中新增元素
return map.put(e, PRESENT)==null;
}
其中變數PRESENT
,是一個非空物件,原始碼部分如下:
private static final Object PRESENT = new Object();
可以分析出,當進行add()
的時候,等價於
HashMap map = new HashMap<>();
map.put(e, new Object());//e 表示要新增的元素
在之前的集合文章中,咱們瞭解到 HashMap 在新增元素的時候 ,通過equals()
和hashCode()
方法來判斷傳入的key
是否相同,如果相同,那麼 HashMap 認為新增的是同一個元素,反之,則不是。
從原始碼分析上可以看出,HashSet 正是使用了 HashMap 的這一特性,實現儲存元素下標無序、元素不會重複的特點。
2.2、remove方法
HashSet 的刪除方法,同樣如此,也是基於 HashMap 的底層實現,原始碼如下:
public boolean remove(Object o) {
//呼叫HashMap 的remove方法,移除元素
return map.remove(o)==PRESENT;
}
2.3、查詢方法
HashSet 沒有像 List、Map 那樣提供 get 方法,而是使用迭代器或者 for 迴圈來遍歷元素,方法如下:
public static void main(String[] args) {
Set<String> hashSet = new HashSet<String>();
System.out.println("HashSet初始容量大小:"+hashSet.size());
hashSet.add("1");
hashSet.add("2");
hashSet.add("3");
hashSet.add("3");
hashSet.add("2");
hashSet.add(null);
//相同元素會自動覆蓋
System.out.println("HashSet容量大小:"+hashSet.size());
//迭代器遍歷
Iterator<String> iterator = hashSet.iterator();
while (iterator.hasNext()){
String str = iterator.next();
System.out.print(str + ",");
}
System.out.println("\n===========");
//增強for迴圈
for (String str : hashSet) {
System.out.print(str + ",");
}
}
輸出結果:
HashSet初始容量大小:0
HashSet容量大小:4
null,1,2,3,
===========
null,1,2,3,
需要注意的是,HashSet 允許新增為null
的元素。
三、LinkedHashSet
LinkedHashSet 是一個輸入輸出有序的集合,繼承自 HashSet,但是底層基於 LinkedHashMap 來實現。
如果你之前瞭解過 LinkedHashMap,那麼你一定知道,它也繼承自 HashMap,唯一有區別的是,LinkedHashMap 底層資料結構基於迴圈連結串列實現,並且陣列指定了頭部和尾部,雖然陣列的下標儲存無序,但是卻可以通過陣列的頭部和尾部,加上迴圈連結串列,依次可以查詢到元素儲存的過程,從而做到輸入輸出有序的特點。
如果還不瞭解 LinkedHashMap 的實現過程,可以參閱集合系列中關於 LinkedHashMap 的實現過程文章。
閱讀 LinkedHashSet 的原始碼,類定義如下:
public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, java.io.Serializable {
public LinkedHashSet() {
//呼叫 HashSet 的方法
super(16, .75f, true);
}
}
查詢原始碼,super
呼叫的方法,原始碼如下:
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
//初始化一個 LinkedHashMap
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
3.1、add方法
LinkedHashSet
沒有重寫add
方法,而是直接呼叫HashSet
的add()
方法,因為map
的實現類是LinkedHashMap
,所以此處是向LinkedHashMap
中新增元素,當進行add()
的時候,等價於
HashMap map = new LinkedHashMap<>();
map.put(e, new Object());//e 表示要新增的元素
3.2、remove方法
LinkedHashSet
也沒有重寫remove
方法,而是直接呼叫HashSet
的刪除方法,因為LinkedHashMap
沒有重寫remove
方法,所以呼叫的也是HashMap
的remove
方法,原始碼如下:
public boolean remove(Object o) {
//呼叫HashMap 的remove方法,移除元素
return map.remove(o)==PRESENT;
}
3.3、查詢方法
同樣的,LinkedHashSet 沒有提供 get 方法,使用迭代器或者 for 迴圈來遍歷元素,方法如下:
public static void main(String[] args) {
Set<String> linkedHashSet = new LinkedHashSet<String>();
System.out.println("linkedHashSet初始容量大小:"+linkedHashSet.size());
linkedHashSet.add("1");
linkedHashSet.add("2");
linkedHashSet.add("3");
linkedHashSet.add("3");
linkedHashSet.add("2");
linkedHashSet.add(null);
linkedHashSet.add(null);
System.out.println("linkedHashSet容量大小:"+linkedHashSet.size());
//迭代器遍歷
Iterator<String> iterator = linkedHashSet.iterator();
while (iterator.hasNext()){
String str = iterator.next();
System.out.print(str + ",");
}
System.out.println("\n===========");
//增強for迴圈
for (String str : linkedHashSet) {
System.out.print(str + ",");
}
}
輸出結果:
linkedHashSet初始容量大小:0
linkedHashSet容量大小:4
1,2,3,null,
===========
1,2,3,null,
可見,LinkedHashSet 與 HashSet 相比,LinkedHashSet 輸入輸出有序。
四、TreeSet
TreeSet 是一個排序的集合,實現了NavigableSet
、SortedSet
、Set
介面,底層基於 TreeMap 來實現。TreeSet 利用 TreeMap 中的key
元素來存放元素,這一點我們也可以從原始碼上看出來,閱讀原始碼,類定義如下:
public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable {
//TreeSet 使用NavigableMap介面作為變數
private transient NavigableMap<E,Object> m;
/**物件初始化*/
public TreeSet() {
//預設例項化一個 TreeMap 物件
this(new TreeMap<E,Object>());
}
//物件初始化呼叫的方法
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
}
new TreeSet<>()
物件例項化的時候,表達的意思,可以簡化為如下:
NavigableMap<E,Object> m = new TreeMap<E,Object>();
因為TreeMap
實現了NavigableMap
介面,所以沒啥問題。
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable{
......
}
4.1、add方法
開啟TreeSet
的add()
方法,原始碼如下:
public boolean add(E e) {
//向 TreeMap 中新增元素
return m.put(e, PRESENT)==null;
}
其中變數PRESENT
,也是是一個非空物件,原始碼部分如下:
private static final Object PRESENT = new Object();
可以分析出,當進行add()
的時候,等價於
TreeMap map = new TreeMap<>();
map.put(e, new Object());//e 表示要新增的元素
TreeMap 類主要功能在於,給新增的集合元素,按照一個的規則進行了排序,預設以自然順序進行排序,當然也可以自定義排序,比如測試方法如下:
public static void main(String[] args) {
Map initMap = new TreeMap();
initMap.put("4", "d");
initMap.put("3", "c");
initMap.put("1", "a");
initMap.put("2", "b");
//預設自然排序,key為升序
System.out.println("預設 排序結果:" + initMap.toString());
//自定義排序,在TreeMap初始化階段傳入Comparator 內部物件
Map comparatorMap = new TreeMap<String, String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2){
//根據key比較大小,採用倒敘,以大到小排序
return o2.compareTo(o1);
}
});
comparatorMap.put("4", "d");
comparatorMap.put("3", "c");
comparatorMap.put("1", "a");
comparatorMap.put("2", "b");
System.out.println("自定義 排序結果:" + comparatorMap.toString());
}
輸出結果:
預設 排序結果:{1=a, 2=b, 3=c, 4=d}
自定義 排序結果:{4=d, 3=c, 2=b, 1=a}
相信使用過TreeMap
的朋友,一定知道TreeMap
會自動將key
按照一定規則進行排序,TreeSet
正是使用了TreeMap
這種特性,來實現新增的元素集合,在輸出的時候,其結果是已經排序好的。
如果您沒看過原始碼TreeMap
的實現過程,可以參閱集合系列文章中TreeMap
的實現過程介紹,或者閱讀 jdk 原始碼。
4.2、remove方法
TreeSet 的刪除方法,同樣如此,也是基於 TreeMap 的底層實現,原始碼如下:
public boolean remove(Object o) {
//呼叫TreeMap 的remove方法,移除元素
return m.remove(o)==PRESENT;
}
4.3、查詢方法
TreeSet 沒有重寫 get 方法,而是使用迭代器或者 for 迴圈來遍歷元素,方法如下:
public static void main(String[] args) {
Set<String> treeSet = new TreeSet<>();
System.out.println("treeSet初始容量大小:"+treeSet.size());
treeSet.add("1");
treeSet.add("4");
treeSet.add("3");
treeSet.add("8");
treeSet.add("5");
System.out.println("treeSet容量大小:"+treeSet.size());
//迭代器遍歷
Iterator<String> iterator = treeSet.iterator();
while (iterator.hasNext()){
String str = iterator.next();
System.out.print(str + ",");
}
System.out.println("\n===========");
//增強for迴圈
for (String str : treeSet) {
System.out.print(str + ",");
}
}
輸出結果:
treeSet初始容量大小:0
treeSet容量大小:5
1,3,4,5,8,
===========
1,3,4,5,8,
4.4、自定義排序
使用自定義排序,有 2 種方法,第一種在需要新增的元素類,實現Comparable
介面,重寫compareTo
方法來實現對元素進行比較,實現自定義排序。
方法一
/**
* 建立實體類Person實現Comparable介面
*/
public class Person implements Comparable<Person>{
private int age;
private String name;
public Person(String name, int age){
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o){
//重寫 compareTo 方法,自定義排序演算法
return this.age-o.age;
}
@Override
public String toString(){
return name+":"+age;
}
}
建立一個Person
實體類,實現Comparable
介面,重寫compareTo
方法,通過變數age
實現自定義排序
測試方法如下:
public static void main(String[] args) {
Set<Person> treeSet = new TreeSet<>();
System.out.println("treeSet初始容量大小:"+treeSet.size());
treeSet.add(new Person("李一",18));
treeSet.add(new Person("李二",17));
treeSet.add(new Person("李三",19));
treeSet.add(new Person("李四",21));
treeSet.add(new Person("李五",20));
System.out.println("treeSet容量大小:"+treeSet.size());
System.out.println("按照年齡從小到大,自定義排序結果:");
//迭代器遍歷
Iterator<Person> iterator = treeSet.iterator();
while (iterator.hasNext()){
Person person = iterator.next();
System.out.print(person.toString() + ",");
}
}
輸出結果:
treeSet初始容量大小:0
treeSet容量大小:5
按照年齡從小到大,自定義排序結果:
李二:17,李一:18,李三:19,李五:20,李四:21,
方法二
第二種方法是在TreeSet
初始化階段,Person
不用實現Comparable
介面,將Comparator
介面以內部類的形式作為引數,初始化進去,方法如下:
public static void main(String[] args) {
//自定義排序
Set<Person> treeSet = new TreeSet<>(new Comparator<Person>(){
@Override
public int compare(Person o1, Person o2) {
if(o1 == null || o2 == null){
//不用比較
return 0;
}
//從小到大進行排序
return o1.getAge() - o2.getAge();
}
});
System.out.println("treeSet初始容量大小:"+treeSet.size());
treeSet.add(new Person("李一",18));
treeSet.add(new Person("李二",17));
treeSet.add(new Person("李三",19));
treeSet.add(new Person("李四",21));
treeSet.add(new Person("李五",20));
System.out.println("treeSet容量大小:"+treeSet.size());
System.out.println("按照年齡從小到大,自定義排序結果:");
//迭代器遍歷
Iterator<Person> iterator = treeSet.iterator();
while (iterator.hasNext()){
Person person = iterator.next();
System.out.print(person.toString() + ",");
}
}
輸出結果:
treeSet初始容量大小:0
treeSet容量大小:5
按照年齡從小到大,自定義排序結果:
李二:17,李一:18,李三:19,李五:20,李四:21,
需要注意的是,TreeSet
不能新增為空的元素,否則會報空指標錯誤!
五、EnumSet
EnumSet 是一個與列舉型別一起使用的專用 Set 集合,繼承自AbstractSet
抽象類。與 HashSet、LinkedHashSet 、TreeSet 不同的是,EnumSet 元素必須是Enum
的型別,並且所有元素都必須來自同一個列舉型別,EnumSet 定義原始碼如下:
public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
implements Cloneable, java.io.Serializable {
......
}
EnumSet
是一個虛類,不能直接通過例項化來獲取物件,只能通過它提供的靜態方法來返回EnumSet
實現類的例項。
EnumSet
的實現類有兩個,分別是RegularEnumSet
、JumboEnumSet
兩個類,兩個實現類都繼承自EnumSet
。
EnumSet
會根據列舉型別中元素的個數,來決定是返回哪一個實現類,當 EnumSet
元素中的元素個數小於或者等於64
,就會返回RegularEnumSet
例項;當EnumSet
元素個數大於64
,就會返回JumboEnumSet
例項。
這一點,我們可以從原始碼中看出,原始碼如下:
public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
Enum<?>[] universe = getUniverse(elementType);
if (universe == null)
throw new ClassCastException(elementType + " not an enum");
//當元素個數小於或者等於 64 的時候,返回 RegularEnumSet
if (universe.length <= 64)
return new RegularEnumSet<>(elementType, universe);
else
//大於64,返回 JumboEnumSet
return new JumboEnumSet<>(elementType, universe);
}
noneOf
是EnumSet
中一個靜態方法,用於判斷是返回哪一個實現類。
我們來看看當元素個數小於等於64的時候,使用RegularEnumSet
的類,原始碼如下:
class RegularEnumSet<E extends Enum<E>> extends EnumSet<E> {
/**元素為long型*/
private long elements = 0L;
/**新增元素*/
public boolean add(E e) {
typeCheck(e);
long oldElements = elements;
//二進位制運算,獲取元素
elements |= (1L << ((Enum<?>)e).ordinal());
return elements != oldElements;
}
}
RegularEnumSet 通過二進位制運算得到結果,直接使用long
來存放元素。
我們再來看看當元素個數大於64的時候,使用JumboEnumSet
的類,原始碼如下:
class JumboEnumSet<E extends Enum<E>> extends EnumSet<E> {
/**元素為long型*/
private long elements = 0L;
/**新增元素*/
public boolean add(E e) {
typeCheck(e);
int eOrdinal = e.ordinal();
int eWordNum = eOrdinal >>> 6;
long oldElements = elements[eWordNum];
//二進位制運算
elements[eWordNum] |= (1L << eOrdinal);
//使用陣列來操作元素
boolean result = (elements[eWordNum] != oldElements);
if (result)
size++;
return result;
}
}
JumboEnumSet 也是通過二進位制運算得到結果,使用long
來存放元素,但是它是使用陣列來存放元素。
二者相比,RegularEnumSet 效率比 JumboEnumSet 高些,因為操作步驟少,大多數情況下返回的是 RegularEnumSet,只有當列舉元素個數超過 64 的時候,會使用 JumboEnumSet。
5.1、新增元素
新建一個EnumEntity
的列舉型別,定義2個引數。
public enum EnumEntity {
WOMAN,MAN;
}
建立一個空的 EnumSet!
//建立一個 EnumSet,內容為空
EnumSet<EnumEntity> noneSet = EnumSet.noneOf(EnumEntity.class);
System.out.println(noneSet);
輸出結果:
[]
建立一個 EnumSet,並將列舉型別的元素全部新增進去!
//建立一個 EnumSet,將EnumEntity 元素內容新增到EnumSet中
EnumSet<EnumEntity> allSet = EnumSet.allOf(EnumEntity.class);
System.out.println(allSet);
輸出結果:
[WOMAN, MAN]
建立一個 EnumSet,新增指定的列舉元素!
//建立一個 EnumSet,新增 WOMAN 到 EnumSet 中
EnumSet<EnumEntity> customSet = EnumSet.of(EnumEntity.WOMAN);
System.out.println(customSet);
5.2、查詢元素
EnumSet
與HashSet
、LinkedHashSet
、TreeSet
一樣,通過迭代器或者 for 迴圈來遍歷元素,方法如下:
EnumSet<EnumEntity> allSet = EnumSet.allOf(EnumEntity.class);
for (EnumEntity enumEntity : allSet) {
System.out.print(enumEntity + ",");
}
輸出結果:
WOMAN,MAN,
六、總結
HashSet 是一個輸入輸出無序的 Set 集合,元素不重複,底層基於 HashMap 的 key 來實現,元素可以為空,如果新增的元素為物件,物件需要重寫 equals() 和 hashCode() 方法來約束是否為相同的元素。
LinkedHashSet 是一個輸入輸出有序的 Set 集合,繼承自 HashSet,元素不重複,底層基於 LinkedHashMap 的 key來實現,元素也可以為空,LinkedHashMap 使用迴圈連結串列結構來保證輸入輸出有序。
TreeSet 是一個排序的 Set 集合,元素不可重複,底層基於 TreeMap 的 key來實現,元素不可以為空,預設按照自然排序來存放元素,也可以使用 Comparable 和 Comparator 介面來比較大小,實現自定義排序。
EnumSet 是一個與列舉型別搭配使用的專用 Set 集合,在 jdk1.5 中加入。EnumSet 是一個虛類,有2個實現類 RegularEnumSet、JumboEnumSet,不能顯式的例項化改類,EnumSet 會動態決定使用哪一個實現類,當元素個數小於等於64的時候,使用 RegularEnumSet;大於 64的時候,使用JumboEnumSet類,EnumSet 其內部使用位向量實現,擁有極高的時間和空間效能,如果元素是列舉型別,推薦使用 EnumSet。
七、參考
1、JDK1.7&JDK1.8 原始碼
2、程式園 - java集合-EnumMap與EnumSet
作者:炸雞可樂
原文出處:www.pzblog.cn