浅谈HashSet和TreeSet区别及用法(附源码)

继承关系图



1.HashSet和TreeSet异同

首先，HashSet和都继承自AbstractSet类(该类是一个抽象类)

其次，两个类都不允许有重复值存在，如果有则自动剔除。

最后，看看下面这个例子来感受一下两者的区别

public static void main(String[] args) {

Set<String> seth = new HashSet<String>();
Set<String> sett = new TreeSet<String>();
seth.add("3");//HashSet
seth.add("1");
seth.add("1");
seth.add("4");
seth.add("2");
System.out.println(seth);
sett.add("3");//TreeSet
sett.add("1");
sett.add("1");
sett.add("4");
sett.add("2");
System.out.println(sett);

}

输出结果:

[3, 2, 1, 4] //hashSet内部存储无序，散列法的机制来存储信息的



[1, 2, 3, 4] //TreeSet内部自动排序，使用树结构存储Set接口的实现，并以升序顺序排序

补充一下，linkedHashSet集合类

该类里面的值以类似链表的结构插入值，输出的顺序与插入的顺序一致。

2.HashSet类

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable<span style="font-family:SimSun;">//HashSet类的继承关系</span>

package java.util;
/**
<span style="font-family:SimSun;"> *HashSet源码
*2016-05-14
*</span>/
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
static final long serialVersionUID = -5024744406713321676L;

private transient HashMap<E,Object> map;  //说明HashSet是通过HashMap实现的

private static final Object PRESENT = new Object();

public HashSet() {
map = new HashMap<>();
}

public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}

public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}

public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

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

public int size() {
return map.size();
}

public boolean isEmpty() {
return map.isEmpty();
}

public boolean contains(Object o) {
return map.containsKey(o);
}

public boolean add(E e) {
return map.put(e, PRESENT)==null;
}

public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}

public void clear() {
map.clear();
}

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();
}
}

private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();

s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());

s.writeInt(map.size());

for (E e : map.keySet())
s.writeObject(e);
}

private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();

int capacity = s.readInt();
float loadFactor = s.readFloat();
map = (((HashSet)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));

int size = s.readInt();

for (int i=0; i<size; i++) {
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
}

3.TreeSet类

public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable<span style="font-family:SimSun;">//TreeSet类的继承关系
</span>

package java.util;

public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable
{
private transient NavigableMap<E,Object> m;

private static final Object PRESENT = new Object();

TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
public TreeSet() {
this(new TreeMap<E,Object>());
}
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}

public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
public Iterator<E> iterator() {
return m.navigableKeySet().iterator();
}

public Iterator<E> descendingIterator() {
return m.descendingKeySet().iterator();
}

public NavigableSet<E> descendingSet() {
return new TreeSet<>(m.descendingMap());
}
public int size() {
return m.size();
}

public boolean isEmpty() {
return m.isEmpty();
}

public boolean contains(Object o) {
return m.containsKey(o);
}

public boolean add(E e) {
return m.put(e, PRESENT)==null;
}

public boolean remove(Object o) {
return m.remove(o)==PRESENT;
}

public void clear() {
m.clear();
}

public  boolean addAll(Collection<? extends E> c) {
// Use linear-time version if applicable
if (m.size()==0 && c.size() > 0 &&
c instanceof SortedSet &&
m instanceof TreeMap) {
SortedSet<? extends E> set = (SortedSet<? extends E>) c;
TreeMap<E,Object> map = (TreeMap<E, Object>) m;
Comparator<? super E> cc = (Comparator<? super E>) set.comparator();
Comparator<? super E> mc = map.comparator();
if (cc==mc || (cc != null && cc.equals(mc))) {
map.addAllForTreeSet(set, PRESENT);
return true;
}
}
return super.addAll(c);
}

public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
E toElement,   boolean toInclusive) {
return new TreeSet<>(m.subMap(fromElement, fromInclusive,
toElement,   toInclusive));
}

public NavigableSet<E> headSet(E toElement, boolean inclusive) {
return new TreeSet<>(m.headMap(toElement, inclusive));
}

public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
return new TreeSet<>(m.tailMap(fromElement, inclusive));
}

public SortedSet<E> subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}

public SortedSet<E> headSet(E toElement) {
return headSet(toElement, false);
}

public SortedSet<E> tailSet(E fromElement) {
return tailSet(fromElement, true);
}

public Comparator<? super E> comparator() {
return m.comparator();
}

public E first() {
return m.firstKey();
}

public E last() {
return m.lastKey();
}
public E lower(E e) {
return m.lowerKey(e);
}

public E floor(E e) {
return m.floorKey(e);
}

public E ceiling(E e) {
return m.ceilingKey(e);
}

public E higher(E e) {
return m.higherKey(e);
}

public E pollFirst() {
Map.Entry<E,?> e = m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}

public E pollLast() {
Map.Entry<E,?> e = m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
public Object clone() {
TreeSet<E> clone = null;
try {
clone = (TreeSet<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}

clone.m = new TreeMap<>(m);
return clone;
}

private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();
s.writeObject(m.comparator());
s.writeInt(m.size());

for (E e : m.keySet())
s.writeObject(e);
}

private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();

Comparator<? super E> c = (Comparator<? super E>) s.readObject();

TreeMap<E,Object> tm;
if (c==null)
tm = new TreeMap<>();
else
tm = new TreeMap<>(c);
m = tm;

int size = s.readInt();

tm.readTreeSet(size, s, PRESENT);
}

private static final long serialVersionUID = -2479143000061671589L;
}