Collection：Set集合

Collection集合中，除了List集合之外，还有Set集合。Set也是一个接口，使用Set需要实现它，它的常见实现类有HashSet、TreeSet。以常用的HashSet举例。

HashSet：

HashSet实现Set接口，底层以HashMap实现，不保证Set的迭代顺序，即Set是无序不重复的。这儿有一个细节需要注意：HashSet无序可以理解，但是TreeSet是有序的，为什么说Set是无序的呢？这儿有必要对有序这个词进行理解一下。

我们一般说的有序，是指，进入集合的顺序，先加入集合的元素，将先取到。使用迭代器迭代时，是依次去取元素。而TreeSet的有序，是指按自然顺序或者某种规则去排序，用迭代器对它进行迭代时，它取出的数据并不是先加入的先取到，后加入的后取到，而是根据他排序后的顺序去取。所以，可以说Set它是无序的。

HashSet常用的方法和List差不多。主要看一下Set的底层实现原理。

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

这是HashSet的构造器，可以看到，它是用HashMap去实现的。为什么HashSet会是无序不重复的呢，先看看它的add()方法：

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

private static final Object PRESENT = new Object();

根据构造器可以看到map是一个HashMap，所以map.put(e, PRESENT)是在HashMap中添加一个元素，它是把对象e作为Map的key，把object作为Map的value，因为Map的键是不重复的，所以HashSet会保证添加的元素是不重复的。

上面说到HashSet是无序且不重复的，但是存储一个对象会不会可以重复呢？用个例子来看一下：

public class Student {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Student() {
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

public class HashSetDemo {
	public static void main(String[] args) {
		Set<Student> set = new HashSet<Student>();
		set.add(new Student("lizy", 23));
		set.add(new Student("liyn", 21));
		set.add(new Student("lizy", 23));
		for (Student student : set) {
			System.out.println(student);
		}
	}
}

运行结果：

Student [name=lizy, age=23]
Student [name=liyn, age=21]
Student [name=lizy, age=23]

上面可以看到，HashSet在添加对象的时候，添加了重复的对象，为什么会重复呢？上面看了它的源码，它底层是以Map来实现的，所以，它的具体操作，要去HashMap中去查看。下面是HashMap的源码：

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

上面HashMap源码，在后期Map中，再详细解释。上面代码大概可以看出，当传入一个对象时，它并不是将对象的值作为主键添加在Map中，而是使用了hashCode()这个方法。它是将对象取hash值，然后做主键的，而在set中添加对象时，每次都是new一个新的对象，所以它们的地址是不同的，因此它们的hash值也是不同的，那么怎么保证它相等呢？

要解决这个，先看影响它的是什么，由源码大概可以看出，要添加一个元素，前面有很多条件，其中hashCode和equals大概可以知道，这两个条件是影响的关键。而hashCode和equals都是Object方法，重写它，如果添加的对象的值完全相同，则返回同一个值：

<span style="white-space:pre">	</span>@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

在Student中添加这两个方法，即可解决值全部相同的对象，不被加入到Set集合中。

除了HashSet之外，还有一个TreeSet。TreeSet，它根据自然顺序或者某些指定的条件进行对元素进行排序。TreeSet有两个构造器，一个是无参构造器，另一个是带一个接口的比较器构造器。无参构造器主要以自然顺序去排序。带参构造器，是根基指定的条件去排序。先看看TreeSet的底层实现：

    public TreeSet() {
        this(new TreeMap<E,Object>());
    }

    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

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

根据上面的构造器可以看到，它的底层是以TreeMap来实现的。它的添加方法具体实现代码如下：

    public V put(K key, V value) {
        Entry<K,V> t = root;<span style="white-space:pre">						</span>//建立根节点
        if (t == null) {
            compare(key, key); // type (and possibly null) check<span style="white-space:pre">	</span>

            root = new Entry<>(key, value, null);<span style="white-space:pre">			</span>//第一次添加数据，将其放入根结点
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;<span style="white-space:pre">				</span>//如果存在参数
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);<span style="white-space:pre">				</span>//比较两个大小
                if (cmp < 0)
                    t = t.left;<span style="white-space:pre">						</span>//小于的，放入左孩子
                else if (cmp > 0)
                    t = t.right;<span style="white-space:pre">					</span>//大于的，放入右孩子
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {<span style="white-space:pre">								</span>//下面不存在参数的，原理和他一样
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

上面是TreeSet实现底层代码，根据这两个构造器，做一个简单实例：

无参构造器案例：

public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Integer> ts = new TreeSet<Integer>();
		ts.add(11);
		ts.add(23);
		ts.add(13);
		ts.add(14);
		ts.add(50);
		for (Integer integer : ts) {
			System.out.print(integer+" ");
		}
	}
}

输出结果：11 13 14 23 50 

带比较器参数构造器案例：

public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Integer> ts = new TreeSet<Integer>(new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				//倒序排序
				return -o1.compareTo(o2);
			}
		});
		ts.add(11);
		ts.add(23);
		ts.add(13);
		ts.add(14);
		ts.add(50);
		for (Integer integer : ts) {
			System.out.print(integer+" ");
		}
	}
}

输出结果：50 23 14 13 11 

上面是TreeSet的底层实现，Tree的实现，可能不是很好理解，下一篇我将把二叉树的构建和三种遍历方式用代码去实现，再回头看它底层实现源码就会熟悉很多。