Set接口

Set接口

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。

tips:Set集合取出元素的方式可以采用：迭代器、增强for。

3.1 HashSet集合介绍

java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持

HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。

小结

Set接口的特点

java.util.set接口 extends Collection接口

​ 1.不允许存储重复的元素

​ 2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历

HashSet特点

java.util.HashSet集合 implement Set接口

​ 1.不允许储存重复的元素

​ 2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历

​ 3.是一个无序的集合，存储元素和取出元素的顺序可能不一致

​ 4.底层是一个哈希表结构（查询速度非常快）

代码如下：

public static void main(String[] args) {
    Set<Integer> set = new HashSet<>();
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(1);
    // 使用迭代器遍历
    Iterator<Integer> it = set.iterator();
    while(it.hasNext()){
        Integer i = it.next();
        System.out.println(i);
    }
    System.out.println("=============");
    // 使用增强for  快捷键：数组/结合.for
    for(Integer i:set){
        System.out.println(i);
    }
    
}

输出结果如下，说明集合不能存储重复元素

1
2
3

=============

1
2
3

tips:根据结果我们发现1只存储了一个，也就是说重复的元素set集合不存储。

小结

哈希值：是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑的值，是模拟出来得到地址，不是数据实际存储的物理地址）

在Object类中有一个方法，可以获取对象的哈希值。

int hashCode() 返回该对象的哈希码值。

hashCode方法源码：

​ public native int hashCode();

​ native：代表该方法调用的是本地操作系统的方法

代码如下：

public class Demo01HashCode {
    public static void main(String[] args) {
        Person p1 = new Person();
        int h1 = p1.hashCode();
        // 460141958
        System.out.println(h1);

        Person p2 = new Person();
        int h2 = p2.hashCode();
        // 1163157884
        System.out.println(h2);

        /*
        *toString方法的源码：
        *   return getClass().getName() + "@" + Integer.toHexString(hashCode())；
        * */
        // Person@1b6d3586
        System.out.println(p1);
        // Person@4554617c
        System.out.println(p2);
        // false
        System.out.println(p1==p2);

        //String类的哈希值
        //  string类重写了Object类的hashCode方法
        String s1 = new String("abc");
        String s2 = new String("abc");
        // 96354
        System.out.println(s1.hashCode());
        // 96354
        System.out.println(s2.hashCode());

        // 1179395
        System.out.println("重地".hashCode());
        // 1179395
        System.out.println("通话".hashCode());

    }
}

2.2 HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。

存储流程图

总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式.

储数据的结构

Hashset集合存储数据的结构（哈希表）

数组结构：把元素进行了分组（相同哈希值的元素一组）链表/红黑树把结构相同哈希值的元素链接到一起

初始容量16

jdk1.8版本之前：哈希表 = 数组+链表

jdk1.8版本之后：

​ 哈希表 = 数组+链表；

​ 哈希表 = 数组+红黑树（提高查询的速度）

产生红黑树的条件：链表的长度超过了8位，那么就会把链表转换为红黑树（提高查询的速度）

哈希表的特点：速度快

哈希冲突：两个元素不同，但是哈希值相同

不重复的原理

set集合存储元素不重复的原理：

​ 前提：存储的元素必须重写hashCode方equals方法

示例代码：

public class Deno02HashSet {
    public static void main(String[] args) {
        // 创建HastSet集合对象
        Set<String> set = new HashSet<>();
        String s1 = new String("abc");
        String s2 = new String("abc");
        set.add(s1);
        set.add(s2);
        set.add("重地");
        set.add("通话");
        set.add("abc");
        System.out.println(set);
        // [重地, 通话, abc]
    }
}

2.3 HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

HashSet存储自定义类型元素

set集合保证元素唯一：

​ 存储元素（String，Integer，...,Student，Person...）,必须重写hashCode方法和equals方法

// person类
package Demo05HashSet;

import java.util.Objects;

/**
 * @author Lucky_
 * @date 2020/3/25
 * 知识点：
 */
public class Person extends Object{
    private String name;
    private int age;

    public Person(){

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.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 static void main(String[] args) {
    // 创建HashSet集合存储Person
    HashSet<Person> set = new HashSet<>();
    Person p1 = new Person("貂蝉",18);
    Person p2 = new Person("西施",18);
    Person p3 = new Person("貂蝉",18);
    System.out.println(p1.hashCode());
    // 35641772
    System.out.println(p3.hashCode());
    // 35641772

    System.out.println(p1 == p3);
    // false
    System.out.println(p1.equals(p3));
    // true
    set.add(p1);
    set.add(p2);
    set.add(p3);
    System.out.println(set);
    // [Person{name='貂蝉', age=18}, Person{name='西施', age=18}]
    }
}

2.4 LinkedHashSet

java.util.HashSet是Set`接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)

在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

java.util.LinkedHashSet集合 extends HashSet集合

LinkedHashSet集合特点：

​ 底层是一个哈希表（数组+链表/红黑树）+链表：多了一条链表（记录元素的存储顺序），保证元素有序

public class Demo03LinkedHashSet {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("www");
        set.add("abc");
        set.add("abc");
        System.out.println(set);
        // [abc, www] 无序，不允许重复

        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("www");
        linked.add("abc");
        linked.add("abc");
        System.out.println(linked);
        // [www, abc] 有序 不允许重复
    }
}

2.5 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

JDK1.5以后。出现了简化操作。... 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

小结

使用前提

当方法的参数列表数据类型 已经确定，但是参数的个数不确定，就可以使用可变参数

使用格式

修饰符 返回值类型 方法名（数据类型... 变量名）{}

原理

可变参数底层是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数

传递的参数个数，可以是0个（不传递），1,2.。。多个

注意事项

1. 一个方法的参数列表，只能有一个可变参数

   // 这种写法就是错误的
   // public static void method(int ...a,String ...b){}
   

2. 如果方法的参数有多个，那么可变参数必须写在参数列表的末尾

   public static void method(int a,String b,int...c){}
   

3. 可变参数的（终极）写法

   public static void method(Object obj){}
   
   

代码演示：

public static void main(String[] args){
    int i  = add(3,6);
    System.out.println(i);
    // 9
}
 /*
     * 完成数组  所有元素的求和 原始写法
     
      public static int getSum(int[] arr){
        int sum = 0;
        for(int i : arr){
            sum += i;
        }
        
        return sum;
      }
    */
    //可变参数写法
public static int add(int...a){
    // 定义一个初始化的变量
    int num = 0;
    // 遍历数组，获取每一个元素
    for(int i :arr){
        sum +=i;
    }
    return sum;
}