当前位置:首页 > Java技术 > Java 集合的工具类Collections的常用方法

Java 集合的工具类Collections的常用方法

2022年11月09日 23:08:04Java技术8

Collections类:java.utils.Collections是集合工具类,用来对集合进行操作。

Collections类的常用方法

public static <T> boolean adda1l(Collection<T> c, T ... elements)// 往集合中添加一些元素。

public static void shuff1e(List<?> 1ist)// 打乱顺序:打乱集合顺序。

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

public static <T> void sort(List<T> list, Comparator<? super T>)// 将集合中元素按照指定规则排序。

addAll(Collection c, T ... elements)方法

  1. 参数说明:

    Collection c:是要被添加元素的集合

    T ... elements:可变参数,是要给集合添加的元素

  2. 方法功能:往集合中添加一些元素

  3. 例子:

    import java.util.Collections;
    import java.util.HashSet;
    
    public class DemoCollections {
        public static void main(String[] args) {
            // 创建一个HashSet集合
            HashSet<String> hashSet = new HashSet<>();
    
            // 调用Collections类的静态方法addAll,往集合hashSet中添加多个元素
            Collections.addAll(hashSet, "a", "b", "c", "d", "e", "f", "g");
    
            // 输出HashSet集合
            System.out.println(hashSet);
        }
    }
    
  4. 输出结果:

    [a, b, c, d, e, f, g]
    

shuffle(List<?> list)方法

  1. 参数说明:List<?> list:表示传入的集合,即该方法传入的参数是一个集合

  2. 方法功能:打乱集合的顺序。

  3. 例子:

    import java.util.ArrayList;
    import java.util.Collections;
    
    public class DemoCollectionsShuffle {
        public static void main(String[] args) {
            // 创建一个ArrayList集合
            ArrayList<String> arrayList = new ArrayList<>();
    
            // 往arrayList集合中添加元素
            Collections.addAll(arrayList, "A", "B", "C", "D", "E", "F", "G");
            System.out.println("没有打乱时的集合:" + arrayList);
    
            // 调用Collections类的静态方法shuffle,将集合arrayList里面的元素顺序打乱
            Collections.shuffle(arrayList);
            System.out.println("打乱以后的集合:" + arrayList);
        }
    }
    
  4. 输出结果:

    没有打乱时的集合:[A, B, C, D, E, F, G]
    打乱以后的集合:[D, B, C, E, A, G, F]
    

sort(List list)方法

  1. 参数说明:List<?> list:表示传入的集合,即该方法传入的参数是一个集合

  2. 方法功能:对集合进行排序(默认为升序排序)

  3. 例子:

    import java.util.ArrayList;
    import java.util.Collections;
    
    public class Demo01CollectionsSort {
        public static void main(String[] args) {
            // 创建一个ArrayList集合
            ArrayList<Integer> arrayList = new ArrayList<>();
    
            // 往arrayList集合中添加元素
            Collections.addAll(arrayList, 1, 2, 10, 9, 8);
            System.out.println("没有排序时的集合:" + arrayList);
    
            // 调用sort()方法,将集合arrayList里面的元素进行排序
            Collections.sort(arrayList);
            System.out.println("排序后的集合:" + arrayList);
        }
    }
    
  4. 输出结果:

    没有排序时的集合:[1, 2, 10, 9, 8]
    排序后的集合:[1, 2, 8, 9, 10]
    

sort(List list, Comparator<? super T>)方法

首先,说明一下,这个方法仅做了解即可,学习过程中通常都是默认使用sort(List list)方法的。

  1. 参数说明:

    List<?> list:表示传入的集合,即该方法传入的第一个参数是一个集合

    Comparator<? super T>:这是一个排序规则,自定义(覆盖重写该接口的排序方法)

  2. 方法功能:对集合进行排序(默认为升序排序)

  3. 例子:

    // 随便创建一个Person类
    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;
        }
    }
    
  4. 自己定义一个排序规则进行测试:

    // 举例
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    
    public class Demo02CollectionsSort {
    
        public static void main(String[] args) {
            // 创建一个ArrayList集合
            ArrayList<Person> arrayList = new ArrayList<>();
    
            // 往arrayList集合中添加元素,集合存储的数据的类型是自定义类型(Person)
            Collections.addAll(
                    arrayList,
                    new Person("LeeHua", 20),
                    new Person("WanTao", 18),
                    new Person("XiaMin", 22),
                    new Person("HonMao", 22)
            );
            System.out.println("没有排序时的集合:" + arrayList);
    
            // 自定义排序规则,对arrayList集合进行排序
            Collections.sort(arrayList, new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    // 年龄相等,按照名字排序
                    while (o1.getAge() - o2.getAge() == 0) {
                        if (o1.getName().length() > o2.getName().length()) {
                            for (int i = 0; i < o2.getName().length(); i++) {
                                if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
                                    return o1.getName().charAt(i) - o2.getName().charAt(i);
                                }
                            }
                            return 1;
                        }
                        else if (o1.getName().length() < o2.getName().length()) {
                            for (int i = 0; i < o1.getName().length(); i++) {
                                if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
                                    return o1.getName().charAt(i) - o2.getName().charAt(i);
                                }
                            }
                            return - 1;
                        }
                        else {
                            for (int i = 0; i < o2.getName().length(); i++) {
                                if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
                                    return o1.getName().charAt(i) - o2.getName().charAt(i);
                                }
                            }
                            return 0;
                        }
                    }
                    // 年龄不相等,按照年龄排序
                    return o1.getAge() - o2.getAge();
                }
            });
            System.out.println("排序以后的集合:" + arrayList);
        }
    }
    
  5. 输出结果:

    没有排序时的集合:[Person{name='LeeHua', age=20}, Person{name='WanTao', age=18}, Person{name='XiaMin', age=22}, Person{name='HonMao', age=22}]
    排序以后的集合:[Person{name='WanTao', age=18}, Person{name='LeeHua', age=20}, Person{name='HonMao', age=22}, Person{name='XiaMin', age=22}]
    
  6. 排序规则代码及注释

    new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    // 首先判断年龄是否相等
                    while (o1.getAge() - o2.getAge() == 0) {
                        // 如果this年龄 == object年龄,那么就按名字的字母(char code)比较
                        // 按照名字的每个字母来比较
                        if (o1.getName().length() > o2.getName().length()) {
                            // o1的名字长度 > o2的名字长度
                            for (int i = 0; i < o2.getName().length(); i++) {
                                if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
                                    return o1.getName().charAt(i) - o2.getName().charAt(i);
                                }
                            }
                            // 假如o2的名字的所有字母,按顺序都与o1的名字对应位数的字母相等,字母长度大的排后,即o1排后
                            return 1;
                        }
                        // o1的名字长度 < o2的名字长度
                        else if (o1.getName().length() < o2.getName().length()) {
                            for (int i = 0; i < o1.getName().length(); i++) {
                                if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
                                    return o1.getName().charAt(i) - o2.getName().charAt(i);
                                }
                            }
                            // 假如o1的名字的所有字母,按顺序都与o2的名字对应位数的字母相等,字母长度大的排后,即o2排后
                            return - 1;
                        }
                        // o1的名字长度 = o2的名字长度
                        else {
                            for (int i = 0; i < o2.getName().length(); i++) {
                                if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
                                    return o1.getName().charAt(i) - o2.getName().charAt(i);
                                }
                            }
                            // 假如o1的名字的所有字母,按顺序都与o2的名字对应位数的字母相等,那么按照arrayList集合的添加顺序排序
                            return 0;
                        }
                    }
                    // 年龄不相等,按照年龄排序
                    return o1.getAge() - o2.getAge();
                }
            }
    

作者:LeeHua
来源链接:https://www.cnblogs.com/liyihua/p/12198483.html

版权声明:
1、JavaClub(https://www.javaclub.cn)以学习交流为目的,由作者投稿、网友推荐和小编整理收藏优秀的IT技术及相关内容,包括但不限于文字、图片、音频、视频、软件、程序等,其均来自互联网,本站不享有版权,版权归原作者所有。

2、本站提供的内容仅用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯相关权利人及本网站的合法权利。
3、本网站内容原作者如不愿意在本网站刊登内容,请及时通知本站(javaclubcn@163.com),我们将第一时间核实后及时予以删除。


本文链接:https://www.javaclub.cn/java/68968.html

分享给朋友:

“Java 集合的工具类Collections的常用方法” 的相关文章

全面了解 Java 原子变量类

📦 本文以及示例源码已归档在 javacore 一、原子变量类简介 为何需要原子变量类 保证线程安全是 Java 并发编程必须要解决的重要问题。Java 从原子性、可见性、有序性这三大特性入手,确保多线程的数据一致性。 确保线程安全最...

Java 并发核心机制

Java 并发核心机制

📦 本文以及示例源码已归档在 javacore 一、J.U.C 简介 Java 的 java.util.concurrent 包(简称 J.U.C)中提供了大量并发工具类,是 Java 并发能力的主要体现(注意,不是全部,有部分并发能力的支持在其他包中)。...

Java 内存模型

Java 内存模型

📦 本文以及示例源码已归档在 javacore Java 内存模型(Java Memory Model),简称 JMM。 JVM 中试图定义一种 JMM 来屏蔽各种硬件和操作系统的内存访问差异,以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。...

JAVA的JDK环境变量的配置JAVA

JAVA的JDK环境变量的配置JAVA

首先要在官网下载java 官网:http://www.oracle.com/technetwork/java/javase/downloads/ 到这个界面 选择我接受 记住该地址 最好的办法新建记事本,然后按ctrl+s保存 java环境变量的...

在JAVA 中将堆与栈分开的原因

栈是运行时的单位,而堆是存储的单位。 栈解决程序的运行问题,即程序如何执行,或者说如何处理数据;堆解决的是数据存储的问题,即数据怎么 放、放在哪儿。 注意:在Java中一个线程就会相应有一个线程栈与之对应 栈因为是运行单位,因此里面存储的信息都是跟...

图解 Java IO : 二、FilenameFilter源码

图解 Java IO : 二、FilenameFilter源码

Writer      :BYSocket(泥沙砖瓦浆木匠) 微         博:BYSocket 豆  &...

java泛型通配符详解

java泛型通配符详解

前言 泛型带来的好处 泛型中通配符 常用的 T,E,K,V,? ?无界通配符 上界通配符 < ? extends E> 下界通配符 < ? super E>...

java高级

java高级

  Java动态代理机制的出现,使得 Java 开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行,在分派执行的过程中,开发人员还可以按需调整委托类对象及其功能,这是一套非常灵活有弹性的代理框架。下...

java中equals,hashcode和==的区别

1、== java中的数据类型,可分为两类: 1.基本数据类型,也称原始数据类型 byte,short,char,int,long,float,double,boolean   他们之间的比较,应用双等号(==),比较的是他们的值。  2.引...

Java 基础【06】 Super 用法

     路漫漫其修远兮,吾将上下而求索。——屈原《离骚》      昨天写this用法总结的时候,突然产生了一个问题,请教别人之后,有了自己的一点认识。还是把它写下来,为大家更好的认识提供一点思路。 1)有人写了...

发表评论

访客

◎欢迎参与讨论,请在这里发表您的看法和观点。