Java Collection系列之：HashSet、LinkedHashSet、TreeSet的使用及源碼解析 Set接口 HashSet LinkedHashSet TreeSet 總結 參考

Set接口

整體Collection&Map的實現關係：

public interface Set<E> extends Collection<E> {
  
  int size();

  boolean isEmpty();

  boolean contains(Object o);

  Iterator<E> iterator();

  Object[] toArray();

  <T> T[] toArray(T[] a);

  boolean add(E e);

  boolean remove(Object o);

  boolean containsAll(Collection<?> c);

  boolean addAll(Collection<? extends E> c);

  boolean retainAll(Collection<?> c);

  boolean removeAll(Collection<?> c);

  void clear();

  boolean equals(Object o);

  int hashCode();

  @Override
  default Spliterator<E> spliterator() {
      return Spliterators.spliterator(this, Spliterator.DISTINCT);
   }

}

HashSet

HashSet基於key-value形式保存元素，底層是基於HashMap實現的(默認容量是16 負載因子是0.75)，HashSet的相關操作基本都是調用HashMap來完成的，Hashset存儲元素具有無序、不可重複的特點。

• 無序: 因爲底層數據結構是HashMap並且利用HashMap去存儲元素，所以HashSet存儲的元素也是無序的。
• 不可重複：HashSet#add添加元素時，底層利用HashMap將添加的元素當成HashMap中的key,並新建一個默認值PRESENT(Object類型,final修飾不可修改)當做HashMap中的value，利用HashMap中key值相等會覆蓋的特點，從而實現HashSet不能存儲重複元素(當添加元素不重複時，HashSet#add方法添加成功並返回true；如果添加的元素重複，則添加失敗，並返回false)。

HashSet的使用&遍歷

Set<String> hashSet = new HashSet<>();
hashSet.add("A");
hashSet.add("C");
hashSet.add("B");
hashSet.add("D");
hashSet.add("A");

System.out.println("使用for循環遍歷：");
for (String str : hashSet) {
    System.out.println("元素：" + str);
}

System.out.println("-------------");

System.out.println("使用Iterator循環遍歷：");
Iterator<String> iterator = hashSet.iterator();
while (iterator.hasNext()) {
    System.out.println("元素：" + iterator.next());
}

執行結果：

元素：A
元素：B
元素：C
元素：D

-------------

使用Iterator循環遍歷：
元素：A
元素：B
元素：C
元素：D

我們往HashSet中添加了2次"A"元素，通過結果發現並沒有存儲2個"A"，並且元素存儲順序並不是按添加順序排序的。所以HashSet存儲的是無序、不可重複的元素。

源碼淺析

構造函數

//默認無參構造函數 內部初始化一個HashMap  默認容量是16 負載因子0.75
public HashSet() {
    map = new HashMap<>();
}

//構造一個包含指定collection的set
public HashSet(Collection<? extends E> c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}

//構造一個指定容量和負載因子的HashSet
public HashSet(int initialCapacity, float loadFactor) {
    map = new HashMap<>(initialCapacity, loadFactor);
}

//構造函數中指定容量
public HashSet(int initialCapacity) {
    map = new HashMap<>(initialCapacity);
}

//構造函數僅能在包內訪問 此構造函數是爲了支持LinkedHashSet的初始化
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

HashSet常用方法

//hashSet中元素個數
public int size() {
    return map.size();
}
//是否爲空 爲空返回true 不爲空返回false
public boolean isEmpty() {
    return map.isEmpty();
}
//hashSet中是否包含元素o，包含返回true；不包含返回false
public boolean contains(Object o) {
    return map.containsKey(o);
}
//添加元素到hashSet中 成功返回true 失敗返回false
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
//刪除hashSet中的元素 成功返回true 失敗返回false
public boolean remove(Object o) {
    return map.remove(o)==PRESENT;
}
//清空hashSet中的元素
public void clear() {
    map.clear();
}
//拷貝副本
@SuppressWarnings("unchecked")
public Object clone() {
    try {
        HashSet<E> newSet = (HashSet<E>) super.clone();
        newSet.map = (HashMap<E, Object>) map.clone();
        return newSet;
    } catch (CloneNotSupportedException e) {
        throw new InternalError(e);
    }
}

遍歷

public Iterator<E> iterator() {
    return map.keySet().iterator();
}

可以看到調用的是HashMap#keySet方法，所以也證明了上面的結論：Hashset中的元素時保存在HashMap中的key中，具有無序、不可重複的特點；value 則是使用的 PRESENT對象，該對象被static final修飾，不可更改。

LinkedHashSet

LinkedHashSet繼承於HashSet,所以存放的元素不可重複；又因爲底層是通過LinkedHashMap(內部維護一個雙向鏈表)實現的，所以LinkedHashSet可以按順序遍歷(按插入順序排序)。

LinkedHashSet的使用&遍歷

LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("A");
linkedHashSet.add("C");
linkedHashSet.add("B");
linkedHashSet.add("D");
linkedHashSet.add("A");

for (String s : linkedHashSet) {
    System.out.println("value is " + s);
}

System.out.println("-------------");

Iterator<String> iterator = linkedHashSet.iterator();
while (iterator.hasNext()) {
    System.out.println("value is " + iterator.next());
}

執行結果：

value is A
value is C
value is B
value is D
-------------
value is A
value is C
value is B
value is D

添加元素時，分別在第一次和最後一次嘗試添加元素"A"，通過結果看只有第一次添加成功。通過結果可以看到LinkedHashSet可以按插入順序遍歷元素，並且存儲的元素是不能重複的。

源碼淺析

LinkedHashSet的源碼很簡單：

public class LinkedHashSet<E> extends HashSet<E>
              implements Set<E>, Cloneable, java.io.Serializable {

    private static final long serialVersionUID = -2851667679971038690L;

    public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }

    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }

    public LinkedHashSet() {
        super(16, .75f, true);
    }

    public LinkedHashSet(Collection<? extends E> c) {
        super(Math.max(2*c.size(), 11), .75f, true);
        addAll(c);
    }

    @Override
    public Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.DISTINCT | Spliterator.ORDERED);
    }
}

只有幾個構造參數並通過super調用了父類的構造函數，還記得父類HashSet中的那個構造函數:

//HashSet構造函數
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

這個構造函數就是供LinkedHashSet構造函數調用super時被調用的，所以LinkedHashSet內部就是通過LinkedHashMap及父類HashSet實現的，LinkedHashSet存儲的是有序、不可重複的元素。

TreeSet

TreeSet內部是通過TreeMap(紅黑樹)實現的，因爲TreeMap可以按自然順序或自定義順序排序，所以TreeSet同樣可以對元素進行排序存儲。

TreeSet的使用&遍歷

• 按自然順序排序：

TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("A");
treeSet.add("C");
treeSet.add("B");
treeSet.add("D");
treeSet.add("A");

for (String s : treeSet) {
    System.out.println("value is " + s);
}

System.out.println("-------------");

Iterator<String> iterator = treeSet.iterator();
while (iterator.hasNext()) {
    System.out.println("value is " + iterator.next());
}

執行結果:

value is A
value is B
value is C
value is D
-------------
value is A
value is B
value is C
value is D

放入的元素是String類型，內部實現了Comparable接口，TreeSet對元素進行了排序並且放入的元素時不能重複。

• 自定義排序：

Person person1 = new Person("張三", 10);
Person person2 = new Person("李四", 30);
Person person3 = new Person("王五", 20);
Person person4 = new Person("趙六", 10);

TreeSet<Person> treeSet = new TreeSet<>();
treeSet.add(person1);
treeSet.add(person2);
treeSet.add(person3);
treeSet.add(person4);

for (Person person : treeSet) {
    System.out.println("value is " + person);
}

System.out.println("-------------");

Iterator<Person> iterator = treeSet.iterator();
while (iterator.hasNext()) {
    System.out.println("value is " + iterator.next());
}



static class Person implements Comparable<Person> {

    private String Name;
    private int age;

    Person(String name, int age) {
        this.Name = name;
        this.age = age;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Person o) {
        if (age >= o.getAge()) {
            //年齡大的或相等的元素放在後面
            return 1;
        }
        return -1;
    }

    @Override
    public String toString() {
        return "[person(name:" + getName() + ",age:" + getAge() + ")]";
    }
}

執行結果：

value is [person(name:張三,age:10)]
value is [person(name:趙六,age:10)]
value is [person(name:王五,age:20)]
value is [person(name:李四,age:30)]
-------------
value is [person(name:張三,age:10)]
value is [person(name:趙六,age:10)]
value is [person(name:王五,age:20)]
value is [person(name:李四,age:30)]

TreeSet<Person>放入的是Person類型，在Person類中實現了Comparable接口並重寫其中的compareTo方法，在compareTo方法中根據age進行排序，age大的放在後面，所以最後遍歷的結果可以看到age是從小到大輸出的。

總結

• HashSet內部幾乎都是通過HashMap實現的，LinkedHashSet內部是通過LinkedHashMap實現的，TreeSet內部是通過TreeMap實現的；
• HashSet存儲無序、不可重複元素；LinkedHashSet存儲有序(按插入順序排序)、不可重複元素；TreeSet內部是TreeMap(紅黑樹)，內部元素可以按自然順序或自定義順序排序。

參考

【1】https://wiki.jikexueyuan.com/project/java-enhancement/java-twentyfour.html
【2】TreeSet: https://wiki.jikexueyuan.com/project/java-enhancement/java-twentyeight.html
【3】TreeSet: https://www.cnblogs.com/skywang12345/p/3311268.html