【Java笔记】集合（二）Set接口及其实现类、Collections

最新推荐文章于 2022-08-01 08:54:17 发布

weiambt

最新推荐文章于 2022-08-01 08:54:17 发布

阅读量453

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/Supreme7/article/details/107118404

版权

Java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Set接口及其实现类、Collections

五.Set集合

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

六.Set集合的实现类

1.HashSet

1.1概述

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

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

public class HashSetDemo {
    public static void main(String[] args) {
        //创建 Set集合
        HashSet<String> set = new HashSet<String>();

        //添加元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac");
        set.add("cba");
        //遍历
        for (String name : set) {
            System.out.println(name);
        }
        /*
            cba
            abc
            bac
        */
    }
}

1.2哈希值

测试：

public class HashCodeDemo {
    public static void main(String[] args) {

        //同一个对象的哈希值是固定的
        System.out.println("zhangsan".hashCode());//-1432604556
        System.out.println("zhangsan".hashCode());//-1432604556
        System.out.println("lisi".hashCode());//3322003
        
        //默认情况下不同对象的哈希值是不同的
        //而重写hashcode方法可以让不同对象的哈希值相同
        //String重写了hashcode()方法
        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395
        
    }
}

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

什么是哈希表呢？

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

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

看到这张图就有人要问了，这个是怎么存储的呢？为了方便大家的理解我们结合一个存储流程图来说明一下：

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

1.4HashSet存储自定义类型元素

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

范例：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

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

public class HashSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象   该集合中存储 Student类型对象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存储
        Student stu = new Student("于谦", 43);
        stuSet.add(stu);
        stuSet.add(new Student("郭德纲", 44));
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(stu);

        //重写toString方法后
        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
}
/*
		输出：
        Student{name='郭德纲', age=44}
        Student{name='于谦', age=43}
        Student{name='郭麒麟', age=23}
*/

2.LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

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

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<String>();
        set.add("bbb");
        set.add("aaa");
        set.add("abc");
        set.add("bbc");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        /*
            bbb
            aaa
            abc
            bbc
        * */
    }
}

3.TreeSet

Treeset的底层实现是二叉树，可以进行默认排序，也可以自定义排序。自定义排序的时候有两种方式，1实现 Comparable 接口完成排序（重写compareTo()方法），2是实现 Comparator 接口完成排序(重写compare()方法)。

1.特点

2.默认排序

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Integer> ts=new TreeSet<>();

        ts.add(10);
        ts.add(50);
        ts.add(40);
        ts.add(30);
        ts.add(30);

        for (Integer a:ts)
            System.out.println(a);
        
        //10
        //30
        //40
        //50
    }
}

3.自定义排序

下面是使用TreeSet存储学生对象并按照要求排序的案例，分别通过自然排序和比较器排序的方法实现，二者功能相同。

（1）使用自然排序Comparable

案例：

public class Student implements Comparable<Student>{
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Student o) {
//        return 0;
//        return 1;
//        return -1;

        //按照年龄升序排序
        int num=this.age-o.age;
        //降序
//        int num=o.age-this.age;

        //年龄相同比较name，按字母顺序排序（String实现了compareTo()方法）
        int num2 = num==0 ? this.name.compareTo(o.name):num;
        return num2;
    }
}

public class ComparableTest {
    public static void main(String[] args) {
        TreeSet<Student> ts=new TreeSet<>();
        ts.add(new Student("zhangsan",30));
        ts.add(new Student("lisi",25));
        ts.add(new Student("wangwu",28));
        ts.add(new Student("zhaoliu",40));
        ts.add(new Student("haoli",40));

        for (Student s:ts)
            System.out.println(s.getName()+","+s.getAge());
//        不实现Comparable接口报错：Student cannot be cast to java.lang.Comparable

//        实现后
//        lisi,25
//        wangwu,28
//        zhangsan,30
//        haoli,40
//        zhaoliu,40
    }
}

总结：

（2）使用比较器Comparator

案例：

public class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class ComparatorTest {
    public static void main(String[] args) {
        TreeSet<Student> ts=new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //this.age - s.age
                //s1,s2
                int num = s1.getAge() -s2.getAge();
                int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        ts.add(new Student("zhangsan",30));
        ts.add(new Student("lisi",25));
        ts.add(new Student("wangwu",28));
        ts.add(new Student("zhaoliu",40));
        ts.add(new Student("haoli",40));

        for (Student s:ts)
            System.out.println(s.getName()+","+s.getAge());

    }
}

总结：

（3）TreeSet存储学生对象案例总结

自然排序和比较器排序实现的功能，比较规则定义相同
自然排序是在学生类中实现Comparable接口，并重写compareTo方法
比较器排序是在TreeSet构造方法中传递比较器接口，通过实现内部类的compare方法

七. Collections工具类

1. 常用方法

java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：

public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
public static void shuffle(List<?> list):打乱集合顺序。
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

public class test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

//        //原来写法
//        list.add(10);
//        list.add(30);
//        list.add(20);

        //采用工具类添加元素
        Collections.addAll(list,20,5,90,40);//[20, 5, 90, 40]
        Collections.sort(list);//[5, 20, 40, 90]
//        Collections.shuffle(list);//随机洗牌
        System.out.println(list);
    }
}

2. 指定规则的排序

代码演示之后，发现我们的集合按照顺序进行了排列，可是这样的顺序是采用默认的顺序，如果想要指定顺序那该怎么办呢？

我们发现还有个方法没有讲，public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。接下来讲解一下指定规则的排列。

我们还是先研究这个方法

public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。

public class CollectionsDemo2 {
    public static void main(String[] args) {
        ArrayList<String>  list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法
        Collections.sort(list);
        System.out.println(list);//[aba, cba, nba, sba]
    }
}

结果：[aba, cba, nba, sba]

我们使用的是默认的规则完成字符串的排序，那么默认规则是怎么定义出来的呢？

说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用java.lang.Comparable接口去实现，一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator接口完成。

那么我们采用的public static <T> void sort(List<T> list)这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能，在String类型上如下：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {

String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用

public static <T> void sort(List<T> list，Comparator<? super T> )方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：

public int compare(String o1, String o2)：比较其两个参数的顺序。

两个对象比较的结果有三种：大于，等于，小于。

如果要按照升序排序，
则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）

如果要按照降序排序
则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）

public class CollectionsDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一个单词的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.charAt(0) - o1.charAt(0);
            }
        });
        System.out.println(list);//[sba, nba, cba, aba]
    }
}

【Java笔记】系列

集合（一）Collection接口、List接口及其实现类
集合（二）Set接口及其实现类、Collections
集合（三）Map接口及其实现类

weiambt

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
2
评论
【Java笔记】集合（二）Set接口及其实现类、Collections

Set接口及其实现类、Collections五.Set集合六.Set集合的实现类1.HashSet1.1概述1.2哈希值1.3HashSet集合存储数据的结构（哈希表）1.4HashSet存储自定义类型元素2.LinkedHashSet3.TreeSet1.特点2.默认排序3.自定义排序（1）使用自然排序Comparable（2）使用比较器Comparator（3）TreeSet存储学生对象案例总结七. Collections工具类1. 常用方法2. 指定规则的排序五.Set集合java.util.Se
复制链接

扫一扫