十 Java集合框架 2 ：Set接口

Set接口和常用方法

基本介绍

无序，没有索引不允许重复元素，所以最多包含一个nullJDKAPI中Set接口的实现类有

set接口常用方法

和List接口一样，set接口也是Collection的子接口，常用方法和Collection接口一样。

`boolean`	`add(E e)`如果指定的元素不存在，则将其指定的元素添加（可选操作）。
`boolean`	`addAll(Collection<? extends E> c)`将指定集合中的所有元素添加到此集合（如果尚未存在）（可选操作）。
`void`	`clear()`从此集合中删除所有元素（可选操作）。
`boolean`	`contains(Object o)`如果此集合包含指定的元素，则返回 `true` 。
`boolean`	`containsAll(Collection<?> c)`返回 `true`如果此集合包含所有指定集合的元素。
`boolean`	`equals(Object o)`将指定的对象与此集合进行比较以实现相等。
`int`	`hashCode()`返回此集合的哈希码值。
`boolean`	`isEmpty()`如果此集合不包含元素，则返回 `true` 。
`Iterator<E>`	`iterator()`返回此集合中元素的迭代器。
`boolean`	`remove(Object o)`如果存在，则从该集合中删除指定的元素（可选操作）。
`boolean`	`removeAll(Collection<?> c)`从此集合中删除指定集合中包含的所有元素（可选操作）。
`boolean`	`retainAll(Collection<?> c)`仅保留该集合中包含在指定集合中的元素（可选操作）。
`int`	`size()`返回此集合中的元素数（其基数）。
`default Spliterator<E>`	`spliterator()`在此集合中的元素上创建一个 `Spliterator` 。
`Object[]`	`toArray()`返回一个包含此集合中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

set接口的遍历方式

同Collection的遍历方法一样，因为set接口是Collection接口的子接口。

可以使用迭代器增强for不能使用索引的方式遍历

// 以set接口的实现子类 HashSet举例 set接口方法
/*
    1. set接口的实现类（Set接口对象），不能存放重复的元素，可以添加一个null
    2. set接口对象存放的数据是无序的（即添加的顺序和取出的顺序不一致）
    3. 注意：取出的顺序虽然不是添加的顺序，但是它是固定的。
 */
Set set = new HashSet();
set.add('1');
set.add('2');
set.add('3');
set.add('3');//重复
set.add('4');
set.add('100');
set.add(null);
set.add(null);//重复添加null
System.out.println(set);//[null, 1, 100, 2, 3, 4]
//遍历(两种方式)
//1. 迭代器
System.out.println('====迭代器遍历');
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
    Object next =  iterator.next();
    System.out.println(next);
}
//2. 增强for遍历, 本质就是迭代器
System.out.println('====增强for遍历');
for (Object o : set) {
    System.out.println(o);
}
//set接口对象，不能通过索引来获取，无法使用普通for循环遍历

Set实现类–HashSet

基本介绍

HashSet实现了Set接口HashSet实际上是HashMappublicHashSet(){map=newHashMap<>();}可以存放null值，但是只能有一个nullHashSet不保证元素是有序的，取决于hash值，再确定索引的结果不能有重复元素/对象

//1. HashSet 实际上是HashMap
HashSet hashSet = new HashSet();
/* 默认构造器源码
    public HashSet() {
        map = new HashMap<>();
    }
 */

//2. 可以存放null值，但是只能有一个null
hashSet.add(null);
hashSet.add(null);
System.out.println(hashSet);

HashSet set = new HashSet();


//1.在执行add方法后，会返回一个boolean值
//2.如果添加成功，返回true，否则返回false
//3.可以通过remove指定删除哪个对象
System.out.println(set.add('Tom')); // true
System.out.println(set.add('Mike'));  // true
System.out.println(set.add('john'));  // true
System.out.println(set.add('Tom'));  // false
System.out.println(set.add('Jerry')); //true
set.remove('Tom');
System.out.println(set);//[Mike, john, Jerry]


set = new HashSet();
//hashSet 不能添加相同的元素/数据
set.add('lucy');  // true
set.add('lucy');  // false
set.add(new Cat('tom'));  //true
set.add(new Cat('tom'));  //true
System.out.println(set);//[Cat{name='tom'}, Cat{name='tom'}, lucy]

//经典面试题
System.out.println(set.add(new String('kobe')));//true
System.out.println(set.add(new String('kobe')));//false
System.out.println(set);//[kobe, Cat{name='tom'}, Cat{name='tom'}, lucy]

HashSet底层机制

HashSet底层是HashMap，HashMap底层是

相较数组存储效率高

代码实现

//模拟一个HashSetMap的底层(HashMap的底层结构)

//1.创建一个数组，数组的类型是Node[]
//2.有些人，直接把Node[]数组称为表
Node[] table = new Node[16];

//3.创建结点
Node john = new Node('john',null);
table[2] = john;
Node jack = new Node('jack', null);
john.next = jack;//将jack节点挂载到 john后
Node rose = new Node('Rose',null);
jack.next = rose;//将roes结点挂载到jack后
Node lucy = new Node('lucy', null);
table[3] = lucy;
System.out.println(table);

存储结构

源码分析

HashSet的add方法

HashSet底层是HashMap添加一个元素时，先得到hash值会转成->索引值，找到存储数据表table，看这个索引位置是否已经存放的有元素如果没有，直接加入如果有，调用equals()比较，如果相同，就放弃添加，如果不相同，则添加到最后在java8中，如果一条链表的元素个数大于等于TREEIFY_THRESHOLD，并且table的大小>=MIN_TREEIFY_CAPCAITY，就会进行树化

HashSet hashSet = new HashSet();

hashSet.add('java');
hashSet.add('php');
hashSet.add('java');

System.out.println('haseSet='+hashSet);
/*
1. 执行Hashset()
public HashSet() {
    map = new HashMap<>();
}
2. 执行hashSet.add()
public boolean add(E e) { //e='java'
    return map.put(e, PRESENT)==null;//private static final Object PRESENT = new Object();
}
3. 执行put方法
public V put(K key, V value) {//key = 'java' , value = PRESENT (静态)
    return putVal(hash(key), key, value, false, true);
}
4. hash(key)方法，得到key对应的一个”hash值“，但不是hashcode！
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//>>>无符号右移16位
}
5. 执行putVal 核心!
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
           boolean evict) {
    Node[] tab; Node p; int n, i;   //定义了辅助变量
    //table 就是HashMap 的一个数组，类型是Node[]
    //if语句标识如果当前table是null或者大小为0
    //第一次扩容，空间大小为16
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;//resize():扩容，第一次生成Node[16],数组扩展的阈值为0.75*16=12
    //(1)根据key，得到hash去计算该key应该存放到table表的哪个索引位置
    //并把这个位置的对象，赋给p
    //(2)判断这个p是否为空
    //(2.1)如果p为null
    //如果p为null，标识还没有存放元素，就创建一个Node(key=”java“，value=PRESENT)
    //就放在该位置tab[i] = newNode(hash, key, value, null);
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        //开发技巧：在需要辅助变量或者局部变量的时候再创建
        //2.2如果p不为null
        Node e; K k;
        //2.2.1 假如数组位置的元素与key（相同）
        //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
        //并且满足 （准备加入的key和p指向的Node结点的key相同） 或（key动态绑定的equals()方法为真）
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //2.2.2 判断p是不是红黑树结点
        // 调用putTreeVal方法添加
        else if (p instanceof TreeNode)
            e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
        else {
        //2.2.3 假如是链表
        // 顺次比较链表的每一个元素是否相同(和2.2.1比较方法相同)，都不相同加在最后一个位置，相同就break
        // 注意在把元素添加到链表后，立即判断，该链表是否到达8个结点，就调用treeifyBin对链表进行树化（转成红黑树）
        // 注意，在转成红黑树时，要进行判断，判断条件：tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY（默认64）
        //上述条件成立，先table扩容，否则不成立才转成红黑树
            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;
            }
        }
        //3 判断是否存在
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //size 就是我们每加入一个结点Node(k,v,h,next),size++,不论是加在数组还是链表
    if (++size > threshold)
        resize();//扩容
    afterNodeInsertion(evict);//空方法，给HashMap子类去实现
    return null;
}
 */

HashSet扩容机制

HashSet底层是HashMap，第一次添加时，table数组扩容到1临界值是16*加载因子是0.75=12如果table数组使用到了临界值1就会扩容到16*2=3新的临界值就是32*0.75=2依次类推在Java8中，如果一条链表的元素个数到TREEIFY_THRESHOLD，并且table的大小>=MIN_TREEIFY_CAPACITY，就会进行树化，否则仍然采用数组扩容机制

注意：

每添加一个元素即添加一个节点，会执行一次++size，当size>threshold时就会执行扩容。table表扩容并不是表的16个大小被添加完才执行，当所有元素的个数大于临界值时就会执行扩容。

代码实践

题目描述：

定义一个Eeployee类，该类包括：private成员属性name,age

创建3个Employee对象放入HashSet中当name和age的值相认为是相同员工，不能添加到HashSet集合中

关键：重写hashCode()与equals()方法

快捷键：Alt+Insert=>equals()andhashCode()=>选择相应的参数

public class Demo17_HashSetExercise {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add(new Employee('jack', 18));
        hashSet.add(new Employee('mike', 28));
        hashSet.add(new Employee('jack', 18));
        System.out.println(hashSet);//[Employee{name='mike', age=28}, Employee{name='jack', age=18}]
    }
}
class Employee
{
    String name;
    int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age && Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, 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 Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return 'Employee{' +
                'name='' + name + ''' +
                ', age=' + age +
                '}';
    }
}

Set实现类–LinkedHashSet

基本介绍

LinkedHashSet是HashSet的子类LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组+双向链表LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存得。LinkedHashSet不允许添加重复元素

说明：

在LinkedHashSet中维护了一个hash表和双向链表每一个节点有before和after属性，这样可以形成双向链表在添加一个元素时，先求hash值，在求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表这样遍历LinkedHashSet也能确保插入顺序和遍历顺序一致

源码分析

public class Demo19_LinkedHashSet_Source {
    public static void main(String[] args) {
        LinkedHashSet set = new LinkedHashSet();
        set.add(new String('AA'));
        set.add(456);
        set.add(456);
        set.add(new Customer('刘',1001));
        set.add(123);
        set.add('kobe');
        for (int i = 0; i < 100; i++) {
            set.add(new Customer('kobe',24));
        }//也会树化 parent、left、right
        System.out.println(set);
        //1. LinkedHashSet 加入顺序和遍历顺序一致
        //2. LinkedHashSet 底层是一个LinkedHashMap(是hashMap的子类)
        //3. LinkedHashSet 底层结构(数组table+双向列表)
        //4. 添加第一次时，直接将数组table扩容到16，存放的结点类型 LinkedHashMap$Entry
        //5. 数组是HashMap$Node[] , 存放的元素/数据是 LinkedHashMap$Entry 类型
        /*
            //继承关系是在内部类完成 ， 都是静态内部类
            static class Entry extends HashMap.Node {
                Entry before, after;
                Entry(int hash, K key, V value, Node next) {
                    super(hash, key, value, next);
                }
            }
         */
    }
}
class Customer{
    private String name;
    private int no;

    public Customer(String name, int no) {
        this.name = name;
        this.no = no;
    }

    @Override
    public String toString() {
        return 'Customer{' +
                'name='' + name + ''' +
                ', no=' + no +
                '}';
    }

    @Override
    public int hashCode() {
        return 1;
    }
}

树化后的结点结构