Java Set系列集合（Collections集合工具类、可变参数）

最新推荐文章于 2024-04-27 09:13:51 发布

秋千水竹马道

最新推荐文章于 2024-04-27 09:13:51 发布

阅读量895

点赞数 1

分类专栏： java 文章标签： java 数据结构开发语言

本文链接：https://blog.csdn.net/weixin_47138646/article/details/129267767

版权

java 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

    public static void main(String[] args) {
        Set<String> sets = new HashSet<>(); //一行经典代码︰无序 不重复 无索引
        // set<String> sets = new LinkedHashSet<>();//有序 不重复 无索引
        sets.add("MySQL");
        sets.add ("MySQL");
        sets.add("Java" );
        sets.add ("Java" );
        sets.add("HTML");
        sets.add("HTML");
        sets.add ("springBoot");
        sets.add("springBoot");
        System.out.println(sets);//[Java, MySQL, HTML, springBoot]
    }

HashSet集合元素无序的底层原理：哈希表

HashSet集合底层采取哈希表存储的数据。
哈希表是一种对于增删改查数据性能都较好的结构

哈希值:是JDK根据对象的地址，按照某种规则算出来的int类型的数值。
Object类的API：public int hashCode()：返回对象的哈希值
对象的哈希值特点：

同一个对象多次调用hashCode()方法返回的哈希值是相同的
默认情况下，不同对象的哈希值是不同的。

哈希表

JDK8之前的，底层使用数组+链表组成
1. 创建一个默认长度16的数组，数组名table
2. 根据元素的哈希值跟数组的长度求余计算出应存入的位置（哈希算法）
3. 判断当前位置是否为null，如果是null直接存入
4. 如果位置不为null，表示有元素，则调用equals方法比较
5. 如果一样，则不存，如果不一样，则存入数组，
  - JDK 7新元素占老元素位置，指向老元素
  - JDK 8中新元素挂在老元素下面
JDK8开始后，底层采用数组+链表+红黑树组成。
- 当挂在元素下面的数据过多时，查询性能降低，从JDK8开始后，当链表长度超过8的时候，自动转换为红黑树

哈希表的详细流程

创建一个默认长度16，默认加载因为0.75的数组，数组名table
根据元素的哈希值跟数组的长度计算出应存入的位置
判断当前位置是否为null，如果是null直接存入，如果位置不为null，表示有元素，则调用equals方法比较属性值，如果一样，则不存，如果不一样，则存入数组。
当数组存满到16*0.75=12时，就自动扩容，每次扩容原先的两倍(32)

HashSet集合元素去重复的底层原理

结论：如果希望Set集合认为2个内容一样的对象是重复的，必须重写对象的hashCode()和equals()方法

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Movie movie = (Movie) o;
        return Double.compare(movie.score, score) == 0 && Objects.equals(name, movie.name) && Objects.equals(actor, movie.actor);
    }

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

LinkedHashSet有序实现原理

底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序。

TreeSet

可排序：按照元素的大小默认升序（从小到大）排序。
TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好。
注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。

TreeSet集合默认的规则

对于数值类型：Integer , Double，官方默认按照大小进行升序排序。
对于字符串类型：默认按照首字符的编号升序排序。
对于自定义类型如Student对象，TreeSet无法直接排序。
结论：想要使用TreeSet存储自定义类型，需要制定排序规则

自定义排序规则

让自定义的类（如学生类）实现Comparable接口重写里面的compareTo方法来定制比较规则。
TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。

方式一：

package test;

import java.util.Comparator;
import java.util.Objects;

public class Movie implements Comparable<Movie> {
    private String name;
    private double score;
    private String actor;
    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }
    public String getName() {
        return name;
    }

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


    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }



    @Override
    public String toString() {
        return "Movie{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", actor='" + actor + '\'' +
                '}';
    }

    @Override
    public int compareTo(Movie o) {
        return Double.compare(this.score,o.score);//按照分数升序
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //定义一个集合存储电影对象。
        Set<Movie> movies=new TreeSet<>();
        //创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
        movies.add(new Movie("《肖生克的救赎》", 9.7 ,  "罗宾斯"));
        movies.add(new Movie("《霸王别姬》", 9.6 ,  "张国荣、张丰毅"));
        movies.add(new Movie("《阿甘正传》", 9.5 ,  "汤姆.汉克斯"));

        System.out.println(movies);//[Movie{name='《阿甘正传》', score=9.5, actor='汤姆.汉克斯'}, Movie{name='《霸王别姬》', score=9.6, actor='张国荣、张丰毅'}, Movie{name='《肖生克的救赎》', score=9.7, actor='罗宾斯'}]


    }
}

方式二：

   public static void main(String[] args) {
        //定义一个集合存储电影对象。
        Set<Movie> movies=new TreeSet<>(new Comparator<Movie>() {
            @Override
            public int compare(Movie o1, Movie o2) {
                return o1.getId()-o2.getId();//去掉重复元素
             //   return o1.getId()-o2.getId()>=0?1:-1;//不去掉重复元素
            }
        });

        //lambda方式
        // Set<Movie> movies=new TreeSet<>((Movie o1, Movie o2) -> o1.getId()-o2.getId()>=0?1:-1);
        
        //创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
        movies.add(new Movie(1,"《肖生克的救赎》", 9.7 ,  "罗宾斯"));
        movies.add(new Movie(1,"《霸王别姬》", 9.6 ,  "张国荣、张丰毅"));
        movies.add(new Movie(2,"《阿甘正传》", 9.5 ,  "汤姆.汉克斯"));

        System.out.println(movies);//[Movie{id='1', name='《肖生克的救赎》', score=9.7, actor='罗宾斯'}, Movie{id='2', name='《阿甘正传》', score=9.5, actor='汤姆.汉克斯'}]

    }

两种方式中，关于返回值的规则：

如果认为第一个元素大于第二个元素返回正整数即可。
如果认为第一个元素小于第二个元素返回负整数即可。
如果认为第一个元素等于第二个元素返回0即可，此时Treeset集合只会保留一个元素，认为两者重复。

注意：如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较器排序

Collection集合总结

如果希望元素可以重复，又有索引，索引查询要快?
- 用ArrayList集合，基于数组的。(用的最多)
如果希望元素可以重复，又有索引，增删首尾操作快?
- 用LinkedList集合，基于链表的。
如果希望增删改查都快，但是元素不重复、无序、无索引。
- 用HashSet集合，基于哈希表的。
如果希望增删改查都快，但是元素不重复、有序、无索引。
- 用LinkedHashSet集合，基于哈希表和双链表。
如果要对对象进行排序。
- 用TreeSet集合，基于红黑树。后续也可以用List集合实现排序。

可变参数

可变参数用在形参中可以接收多个数据。
可变参数的定义格式：数据类型…参数名称

可变参数的作用

接收参数非常灵活，方便。可以不接收参数，可以接收1个或者多个参数，也可以接收一个数组

可变参数在方法内部本质上就是一个数组。

可变参数的注意事项：

一个形参列表中可变参数只能有一个
可变参数必须放在形参列表的最后面

Collections集合工具类

java.utils.Collections:是集合工具类
作用：Collections并不属于集合，是用来操作集合的工具类。

public static boolean addAll(Collection<? super T> c, T… elements):给集合对象批量添加元素
public static void shuffle(List<?> list) ：打乱List集合元素的顺序
public static void sort(List list)：将集合中元素按照默认规则排序，注意：本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口。（List中相同类型的值会保留）
public static void sort(List list，Comparator<? super T> c)：将集合中元素按照指定规则排序

 public static void main(String[] args) {
        //定义一个集合存储电影对象。
        List<Movie> movies=new ArrayList<>();
        //创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
        movies.add(new Movie(1,"《肖生克的救赎》", 9.7 ,  "罗宾斯"));
        movies.add(new Movie(1,"《霸王别姬》", 9.6 ,  "张国荣、张丰毅"));
        movies.add(new Movie(2,"《阿甘正传》", 9.5 ,  "汤姆.汉克斯"));

        //方式一：Movie方法中重写了比较规则
//        Collections.sort(movies);
//        System.out.println(movies);

        //方式二：sort方法自带比较器
        Collections.sort(movies, new Comparator<Movie>() {
            @Override
            public int compare(Movie o1, Movie o2) {
                return o1.getId()-o2.getId();
            }
        });
        System.out.println(movies);//会自动保留重复的
    }

秋千水竹马道

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java Set系列集合（Collections集合工具类、可变参数）

Set系列集合特点无序：存取顺序不一致不重复：可以去除重复无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。Set集合实现类特点HashSet : 无序、不重复、无索引。LinkedHashSet：有序、不重复、无索引。TreeSet：排序、不重复、无索引。Set集合的功能上基本上与Collection的API一致。//一行经典代码︰无序不重复无索引 // set sets = new LinkedHashSet();
复制链接

扫一扫