【集合】set集合，hashSet概述，LinkedHashSet，TreeSet，存储学生对象并遍历（无参构造，自然排序），比较器排序，

一.set集合

1.Set集合：元素是唯一的，并且元素的顺序是无序的集合

2.在Set集合中存储的元素为什么不会有重复的呢？

这里我们就要分析原码：Set集合不重复跟他的实现类HashSet的add（）方法有关：

public interface Set extends Collection{
   
    void add(E e);
}

class HashSet implements Set{
   
    private transient HashMap<E,Object> map;

    private static final Object PRESENT = new Object();

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

    public boolean add(E e) {
   
            //E -- String
            //e -- "hello"
            return map.put(e, PRESENT)==null;
    }
}

class HashMap{
   
    //key -- "hello"
    //value -- new Object()
    public V put(K key, V value) {
   
            //读到这里我们知道put方法一定是与元素类中的
            //hashCode()方法有关
            return putVal(hash(key), key, value, false, true);
    }

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


    // hash -- (h = key.hashCode()) ^ (h >>> 16)结合hashCode()计算出来的值
    // key -- "hello"
    // value -- new Object()
    // onlyIfAbsent -- false
    // evict -- true
    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;

 //根据元素的对象计算好的哈希值再进行一次计算，计算出的是该元素存
 //储在哈希表中的位置
 //如果该元素的位置是null,说明这个位置没有元素，可以进行存储,创
 //建新的节点，存储元素
 //分析到这一步，我们再次验证一个结论，元素存储的位置与元素类中
 //hashCode()有关
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
   
   //如果该元素的位置不是null,说明这个位置上已经有元素了，可以确
   //定的是哈希值是一样的
            //但是呢，我不能确定这两个元素就是同一个元素。
            Node<K,V> e;
            K k;

    //先将存入元素的哈希值与该位置上的元素的哈希值进行比较
    //如果哈希值都不一样，继续走判断instanceof
    //如果哈希值都一样，会调用元素的equals(k)方法进行比较
   //如果equals(k)方法比较的结果是false的话，继续向下执行最终
   //会将元素添加到集合中或者不添加
   //如果equals(k)方法比较的结果是true的话,表示哈希值和内容都
   //一样，表示元素重复了
  //就覆盖，从现象上来看，其实就是不赋值
 //说到这里，我们就已经知道HashSet中add()方法实际上与
 //hashCode()方法和equals()方法有关
 //集合中会不会去重取决于元素类有没有重写hashCode()方法和
 //equals()方法
   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;
    }
}

分析到最后我们得出：要想让元素不重复，就要重写hashCode（)和equals（）方法

public class SetDemo12 {
   
    public static void main(String[] args) {
   
        Set<String> set = new HashSet<>();
        set.add("java");
        set.add("hive");
        set.add("mysql");
        set.add("hadoop");
        set.add("web");
        set.add("java");
        set.add("hadoop");
        set.add("c语言");
        set.add("hive");
        for (String s:set){
   
            System.out.println(s);
            /*说明:set集合是不重复的且输出是无序的。
            hive
            java
            语言
             web
            mysql
            hadoop

             */

        }

    }
}

结果：

3. 用Set集合存储学生对象（当学生的姓名和年龄都一样的时候，判定是同一个学生