java集合之二： Set接口

最新推荐文章于 2022-08-01 18:16:39 发布

步步静心

最新推荐文章于 2022-08-01 18:16:39 发布

阅读量170

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_43862596/article/details/108854006

版权

Java 专栏收录该内容

58 篇文章 1 订阅

订阅专栏

Set接口

存储无序，不可重复的数据

HashSet 作为Set接口的主要实现类；线程不安全；可以存储null值

LinkedHashSet HashSet的子类；遍历内部数据时按照添加顺序遍历

TreeSet 底层使用的是二叉树或者说红黑树存储的；可以按照添加对象的指定属性进行排序

解释无序

 @Test
public void test3(){
        Set set = new HashSet();
        set.add(123);
        set.add(456);
        set.add("AA");
        set.add("BB");
    	set.add(123);
        set.add(789);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

执行结果：

AA
BB
789
456
123

无序不等于随机，执行后的结果一直是上面显示的。HashSet 底层数组长度为16,第一次添加的元素可能不在第一个位置，这里就是第4个元素，第二个元素添加的位置也不定，第三，第四依次不定位置。

存储的数据在底层数组中并非按照数组索引顺序添加，而是依据哈希值决定

解释不重复

public class User {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.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;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
     @Override
    public boolean equals(Object o) {
        System.out.println("User equals");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name);
    }

    /*@Override
    public int hashCode() {
        return Objects.hash(name, age);
    }*/

Set set = new HashSet();

        set.add(123);
        set.add(456);
        set.add("AA");
        set.add("BB");
        set.add(789);

        set.add(new User("Tom",16));
        set.add(new User("Tom",16));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

执行结果：

BB
User{name='Tom', age=16}
789
456
User{name='Tom', age=16}
123

表面看，在User类中没有equals方法时或有equals方法但是没有hashCode方法时，执行结果都是上例中的那样。实际上Set接口的不重复是有equals方法参与的，不过上例中equals方法与hashCode方法并用时，确实会发现实际上还是使用到了equals方法，如下的结果：

User equals
AA
BB
789
456
User{name='Tom', age=16}
123

添加数据的过程

HashSet

向HashSet中添加元素a，首先调用元素a所在类的hashCode方法计算元素的哈希值，有了这个哈希值，通过某种算法比如说取余这种算出在HashSet底层数组中的索引位置，判断数组此位置处是否已经有元素，

如果没其他元素，则元素a直接添加成功；

或此位置处有其他元素b,或以链表形式存在的多个元素，则比较元素a与元素b的hash值。如果hash值不相同，则元素a添加成功；如果hash值相同，需要调用元素a所在类的equals方法，若equals方法返回true，则元素添加失败，若equals方法返回false，则元素添加成功。在这一整个情况下，元素a与已经存在指定索引位置上的数据以链表形式存储

jdk8 数组某一位置处有原先的元素。成功添加元素a，以链表形式由原来元素执行元素a,再添加了b，则由a指向b
在这里插入图片描述

jdk7，数组某一位置处有原先的元素,要添加第二个元素，比较与第一个不相同，可以成功添加，需要把新添加的元素放在数组中，原先元素放在数组外，由新添加元素指向原来元素，要添加第三个元素，那么3在数组中，链表形式，3->2->1,其他添加元素类似
在这里插入图片描述

HashSet底层结构：数组 + 链表
在这里插入图片描述

在没有重写hashCode方法时，相当于调用的是Object类中的hashCode方法，它相当于随机计算生成一个数，相当于代码中的set.add(new User(“Tom”,16));set.add(new User(“Tom”,16));new 的对象new User(“Tom”,16)是不一样的值；哈希值不同，两个元素在数组中的位置不同，所以就不需要equals方法参与就添加成功了

而重写了hashCode后，一般方法中有31这个数字

向Set中添加数据，其所在的类一定要重写hashCode方法和equals方法，重写的这两个方法应尽可能保持一致性，即两个对象有相同属性，那么得到的哈希值也相等，一般代码自动生成的都满足了这样的需求

Set接口中没有定义额外的方法，使用的都是Collection中声明过的方法

LinkedHashSet

相当于在HashSet的基础上，在添加数据的同时，又额外的提供了一对双向链表，记录此数据前一个和后一个数据。所以在添加数据时，根据hash值存放，后又可以依次取出集合中元素。对于频繁的遍历操作，LinkedHashSet比HashSet有利
在这里插入图片描述

TreeSet

向TreeSet中添加的数据要求是相同类的对象，不能添加不同类的对象

 Set set = new TreeSet();

        set.add(123);
        set.add(456);
        set.add("AA");
        set.add("BB");
        set.add(789);

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

  @Test
    public void test(){
        Set set = new TreeSet();

        set.add(123);
        set.add(456);
        set.add(56);
        set.add(78);


        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }
    //按照从小到大的顺序排列
    56
78
123
456

自然排序中，比较两个对象那个是否相同的标准：compareTo()返回0，不再是equals()

比如说set中添加多个User对象，需要将User类实现Comparable接口，public class User implements Comparable，重写compareTo方法。

@Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
           // return this.name.compareTo(user.name);
            int compareTo = this.name.compareTo(user.name);
            if(compareTo != 0){
                return compareTo;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw  new  RuntimeException("输入类型不匹配");
        }

    }

二叉树，小的在左边，大的在右边，在树形结构中，容不得存放相同数据
在这里插入图片描述
定制排序

比较两个对象是否相同标准为compare()返回0，不是equals()

 @Test
    public void test2(){

        Comparator com = new Comparator() {
            //年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof  User){
                    User u1 = (User)o1;
                    User u2 = (User) o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else{
                    throw  new RuntimeException("输入类型不匹配");
                }

            }
        };
        Set set = new TreeSet(com);
        set.add(new User("Tom",12));
        set.add(new User("Jerry",18));
        set.add(new User("Jim",22));
        set.add(new User("Mike",36));
        set.add(new User("Jack",19));
        set.add(new User("Jack",59));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }