进阶07 Set接口、HashSet、LinkedHashSet

最新推荐文章于 2024-08-26 12:03:45 发布

菜鸟要成长zz

最新推荐文章于 2024-08-26 12:03:45 发布

阅读量176

点赞数

分类专栏： Java进阶文章标签： java 接口 set

本文链接：https://blog.csdn.net/weixin_44688581/article/details/111165581

版权

Java进阶专栏收录该内容

17 篇文章 1 订阅

订阅专栏

在这里插入图片描述

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

java.util.Set接口 extends Collection接口
Set接口的特点:
1.不允许存储重复的元素
2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历

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

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

HashSet集合介绍

java.util.HashSet集合 implements Set接口
HashSet特点:
1.不允许存储重复的元素
2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
4.底层是一个哈希表结构(查询的速度非常的快)

public static void main(String[] args) {
    Set<Integer> set = new HashSet<>();//多态
    //使用add方法往集合中添加元素
    set.add(1);
    set.add(3);
    set.add(2);
    set.add(1);//重复，不允许存储
    //使用迭代器遍历set集合
    Iterator<Integer> it = set.iterator();
    while (it.hasNext()){
        Integer n = it.next();
        System.out.println(n);//1,2,3
    }
    //使用增强for遍历set集合
    System.out.println("-----------------");
    for (Integer i : set) {
        System.out.println(i);
    }
}

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

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

先了解哈希值：

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

在Object类有一个方法,可以获取对象的哈希值
int hashCode() 返回该对象的哈希码值。
hashCode方法的源码:
public native int hashCode();
native:代表该方法调用的是本地操作系统的方法

public class Person extends  Object{
    //先让Person类为空，默认继承Object，便于使用hashcode方法，然后重写
    
      //重写hashCode方法

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

public static void main(String[] args) {
    //Person类继承了Object类,所以可以使用Object类的hashCode方法
    Person p1 = new Person();
    int h1 = p1.hashCode();
    System.out.println(h1);//重写hashcode之前 1967205423  | 重写后 1

    Person p2 = new Person();
    int h2 = p2.hashCode();
    System.out.println(h2);//42121758   |  1

    /*
        toString方法的源码:
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
     */
    System.out.println(p1);//com.itheima.demo03.hashCode.Person@75412c2f
    System.out.println(p2);//com.itheima.demo03.hashCode.Person@282ba1e
    System.out.println(p1==p2);//false   如果重写了hashcode都是返回1，上面对象的返回值一样
                                    // 但此处显示false 也就是说实际的物理地址不相等

    //特殊：string类重写了hashcode方法
    /*
        String类的哈希值
            String类重写Obejct类的hashCode方法
     */
    String s1 = new String("abc");
    String s2 = new String("abc");
    System.out.println(s1.hashCode());//96354
    System.out.println(s2.hashCode());//96354
        //特殊下面两个虽然字符串不一样，但是哈希值一样
    System.out.println("重地".hashCode());//1179395
    System.out.println("通话".hashCode());//1179395
}

HashSet集合存储数据的结构图
在这里插入图片描述

注意hashset的构成，初始容量是16
首先计算数据的哈希值，把相同哈希值的数据放到同一位置上，其哈希值也就是对应的查询地址，
链表长度超过8位就把链表转换为红黑树（根和叶子都是黑色，中间是红色），为了提高查询的速度。

Set集合不允许存储重复元素的原理：

public static void main(String[] args) {
    //创建HashSet集合对象
    HashSet<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);//注意：集合重写了toString方法，直接打印里面的内容
            //[重地, 通话, abc]
}

创建了hashset集合
哈希表的数据结构组成：数组+链表或者数组+红黑树，横着是数组结构，竖着是链表结构（结合上面的hashset集合存储图）
在这里插入图片描述

原理：set在用add方法的时候会调用元素的hashcode方法和equals方法
先计算哈希值，放到数组中，如果遇到相同哈希值就进行比较，如果内容相同就不会添加到一起，
如果哈希值相同，内容不同（如上述重树和通话）就添加到一起，放到数组下面的链表当中。

HashSet存储自定义类型元素

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

首先定义Person类，有参数无参数的构造方法，成员变量的get，set。
再重写toString方法

public class Person {
    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 +
                '}';
    }

    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);//42121758
    Person p2 = new Person("张小敬",18);//20671747
    Person p3 = new Person("李必", 19);
    System.out.println(p1.hashCode());
    System.out.println(p2.hashCode());
    //上述p1,p2哈希值不同，说明没有重写hashcode方法和equals方法的对象不是同一个对象，
    // 虽然内容相同，不能保证唯一

    System.out.println(p1 == p2);//false  == 比较的是地址值
    System.out.println(p1.equals(p2));//false  没有重写比较的是两个的地址值。

    //重写后的结果：
    /*748923221
    748923221
    false
    true*/

    //重写了hashcode和equals方法后添加到结合中,就实现了唯一性
    set.add(p1);
    set.add(p2);
    set.add(p3);
    System.out.println(set);
    //[Person{name='李必', age=19}, Person{name='张小敬', age=18}]
}

LinkedHashSet

HashSet可以保证元素唯一，但是存进去的元素是没有顺序的，要保证有序就要用到子类
LinkedHashSet ，由链表和哈希表组合的一个数据存储结构。
java.util.LinkedHashSet集合 extends HashSet集合

LinkedHashSet集合特点:

   底层是一个哈希表(数组+链表/红黑树)+链表:

多了一条链表(记录元素的存储顺序),保证元素有序

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

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

可变参数

可变参数:是JDK1.5之后出现的新特性
使用前提:
当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数.
使用格式:定义方法时使用

修饰符返回值类型方法名(数据类型…变量名){}

可变参数的原理:
可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数
传递的参数个数,可以是0个(不传递),1,2…多个

 public static void main(String[] args) {
     //int i = add();
     //int i = add(10);
     int i = add(10,20);
     //int i = add(10,20,30,40,50,60,70,80,90,100);
     System.out.println(i);

     method("abc",5.5,10,1,2,3,4);
 }

 /*
     可变参数的注意事项
         1.一个方法的参数列表,只能有一个可变参数
         2.如果方法的参数有多个,那么可变参数必须写在参数列表的末尾
  */
 /*public static void method(int...a,String...b){

 }*/

 /*public static void method(String b,double c,int d,int...a){
 }*/

 //可变参数的特殊(终极)写法
 public static void method(Object...obj){

 }

 /*
     定义计算(0-n)整数和的方法
     已知:计算整数的和,数据类型已经确定int
     但是参数的个数不确定,不知道要计算几个整数的和,就可以使用可变参数
     add(); 就会创建一个长度为0的数组, new int[0]
     add(10); 就会创建一个长度为1的数组,存储传递来过的参数 new int[]{10};
     add(10,20); 就会创建一个长度为2的数组,存储传递来过的参数 new int[]{10,20};
     add(10,20,30,40,50,60,70,80,90,100); 就会创建一个长度为2的数组,
     存储传递来过的参数 new int[]{10,20,30,40,50,60,70,80,90,100};
  */
 public static int add(int...arr){
     //System.out.println(arr);//[I@2ac1fdc4 底层是一个数组
     //System.out.println(arr.length);//0,1,2,10
     //定义一个初始化的变量,记录累加求和
     int sum = 0;
     //遍历数组,获取数组中的每一个元素
     for (int i : arr) {//增强for 定义一个变量，用来取list中的值，它的类型就是数组的或者集合中存放的类型。
         //累加求和
        sum += i;
     }
     //把求和结果返回
     return sum;
 }

 //定义一个方法,计算三个int类型整数的和
public static int add3(int a ,int b, int c){
     return a+b+c;
}

 //定义一个方法,计算两个int类型整数的和
 public  static  int add2(int a ,int b){
     return a+b;
 }
 小结：1、注意可变参数的注意事项，
          1.一个方法的参数列表,只能有一个可变参数
          2.如果方法的参数有多个,那么可变参数必须写在参数列表的末尾
       2、可变参数的底层就是一个可变的数组，随着加入元素增加长度