Collections工具类

最新推荐文章于 2021-10-09 19:57:27 发布
最新推荐文章于 2021-10-09 19:57:27 发布
阅读量178 收藏 2
点赞数
分类专栏： 学习篇 Java 常用API 文章标签： java 接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45144691/article/details/107393649
版权
学习篇 同时被 3 个专栏收录
24 篇文章 0 订阅
订阅专栏
Java
17 篇文章 0 订阅
订阅专栏
常用API
5 篇文章 0 订阅
订阅专栏

Collections工具类

  1. java.util.Collections(工具类)：它里面包含了一些对Collection集合操作的一些实用方法。

常用方法：

  1. public static void shuffle(List<?> list) :打乱集合顺序。
  2. public static < T extends Comparable> void sort(List list) :将集合中元素按照默认规则排序。
  3. public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排序。
代码演示（shuffle） ：
public class Demo03 {
    public static void main(String[] args) {
        //1.定义一个集合
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(50);
        list.add(15);
        list.add(25);
        list.add(77);
        list.add(63);
        list.add(48);
        list.add(32);

        System.out.println(list);//[10, 50, 15, 25, 77, 63, 48, 32]

        //打乱集合顺序
        Collections.shuffle(list);

        System.out.println(list);//[15, 25, 48, 63, 50, 32, 77, 10]

    }
}
代码演示（sort方法自排序）：

  1. 调用的是：public static void sort(List<? extends Comparable> list)：

  2. 自排序指：集合中的元素必须实现Comparable接口，并重写compareTo()方法。sort()方法会利用这个方法对元素进行比较，进而进行排序。

     compareTo()方法返回：
     负数：当前对象 < 参数对象，【会将当前对象排在参数对象前面】
       0： 当前对象 = 参数对象，【不排序】
     正数：当前对象 > 参数对象，【会将当前对象排在参数对象后面】

自定义Student类(如果要对Student对象进行排序，需要Student实现Comparable接口，并重写compareTo()方法)

	public class Student implements Comparable<Student>{
    private String name;
    private int age;
    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;
    }
    /*
        此类需要实现Comparable接口，并重写compareTo()方法
        此方法被Collections的sort()方法调用，
        用于：对象的比较，并利用比较的结果进行排序。

        比较的结果：是一个int值

        compareTo()方法返回：
        负数：当前对象 < 参数对象，【会将当前对象排在参数对象前面】
          0： 当前对象 = 参数对象，【不排序】
        正数：当前对象 > 参数对象，【会将当前对象排在参数对象后面】

     */
    @Override
    public int compareTo(Student o) {
        System.out.println("compareTo()....");
        System.out.println("当前对象：" + this.name + "," + this.age +
                            " 参数对象：" + o.name + "," + o.age);
        //第一种写法：
        //1.如果我们想按：年龄升序排序(this – 参数)
//        return this.age -  o.age;//25   18
        //2.如果我们想按：年龄降序排序(参数 – this)
//        return o.age - this.age;//18  25，会让本方法返回负数

        //第二种写法
        //1.如果我们想按：年龄升序排序
        /*if (this.age < o.age) {
            //返回负数
            return -1;
        } else if (this.age == o.age) {
            //返回0
            return 0;
        } else{
            //返回1
            return 1;
        }*/
        //2.如果我们想按：年龄降序排序
        if (this.age < o.age) {
            //返回正数
            return 1;
        } else if (this.age == o.age) {
            //返回0
            return 0;
        } else{
            //返回-1
            return -1;
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类：

public class Demo04 {
    public static void main(String[] args) {
        //1.定义一个集合
        ArrayList<Integer> list1 = new ArrayList<>();//Integer实现了Comparable接口
        list1.add(10);
        list1.add(50);
        list1.add(15);
        list1.add(25);
        list1.add(77);
        list1.add(63);
        list1.add(48);
        list1.add(32);

        System.out.println("原数据" + list1);//[10, 50, 15, 25, 77, 63, 48, 32]

        //排序
        Collections.sort(list1);

        System.out.println("排序后：" + list1);//[10, 15, 25, 32, 48, 50, 63, 77]


        //2.定义一个字符串集合
        ArrayList<String> list2 = new ArrayList<>();//String类也实现了Comparable接口
        list2.add("cba");
        list2.add("acb");
        list2.add("bac");
        list2.add("cab");
        list2.add("abc");
        list2.add("bca");

        System.out.println("原数据：" + list2);//原数据：[cba, acb, bac, cab, abc, bca]

        //排序
        Collections.sort(list2);

        System.out.println("排序后：" + list2);//排序后：[abc, acb, bac, bca, cab, cba]


        //3.定义一个存储Student的集合
        ArrayList<Student> stuList = new ArrayList<>();//要求Student类也要实现Comparable接口

        stuList.add(new Student("张三", 18));
        stuList.add(new Student("李四", 25));
        stuList.add(new Student("王五", 17));


        System.out.println("-------------------------------");
        System.out.println(stuList);
        //排序
        Collections.sort(stuList);
        System.out.println(stuList);
    }
}
代码演示（sort方法比较器排序）：
  1. 调用：public static void sort(List list，Comparator<? super T> com )：此方法也可以对参数list中的元素进行排序。
  2. list中的元素可以不实现Comparable接口，可以使用第二个参数Comparator比较器进行排序。
  3. 另外还有一个作用，如果list中元素实现的Comparable接口，也重写了compareTo()方法，但此时不想按原来的规则排序，此时也可使用这个方法，传入一个比较器，就会使用比较器进行排序。

定义Student类（不需要实现Comparable接口）

public class Student {
    private String name;
    private int age;
    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 +
                '}';
    }
}

测试类：

public class Demo05 {
    public static void main(String[] args) {
        ArrayList<Integer> intList = new ArrayList<>();
        intList.add(10);
        intList.add(16);
        intList.add(7);
        intList.add(22);
        intList.add(66);
        intList.add(33);
        intList.add(88);

        System.out.println("原集合：" + intList);//原集合：[10, 16, 7, 22, 66, 33, 88]

        /*Collections.sort(intList);//结果是：升序
        System.out.println("升序：" + intList);//升序：[7, 10, 16, 22, 33, 66, 88]
        */
        //我想降序排序
        Collections.sort(intList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;//降序
            }
        });
        System.out.println("比较器降序：" + intList);//比较器升序：[88, 66, 33, 22, 16, 10, 7]


        //Student类(它没有实现Comparable接口)
        ArrayList<Student> stuList = new ArrayList<>();

        stuList.add(new Student("张三", 18));
        stuList.add(new Student("李四", 25));
        stuList.add(new Student("王五", 17));

        Collections.sort(stuList, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getAge() - o1.getAge();
            }
        });

        System.out.println(stuList);

    }
}
Li大爷_初学者
关注
专栏目录
Collections工具类_动力节点Java学院整理
08-30
Collections工具类详解 Collections工具类是Java中一个功能强大的工具类，提供了大量针对Collection/Map的操作。下面我们将对该工具类进行详细的介绍。 排序操作 Collections工具类提供了多种排序操作，主要针对...
Java中集合的介绍与使用
qq_43609524的博客
04-13 890
Java中集合的介绍与使用泛型泛型接口泛型接口的定义泛型接口的使用泛型通配符定义使用受限泛型Java中集合的介绍Java中有哪些集合connection的共性方法遍历集合（使用迭代器）迭代器的实现原理增强for循环 泛型 泛型:是一种未知的数据类型,当我们不知道使用什么数据类型的时候可以使用泛型，泛型也可以看出是一个变量,用来接收数据类型 E e: Element元素 T t :Type类型 ArrayList集合在定义的时候不知道集合中都会存储什么类型的数据,所以类型使用泛型E:未知的数据类型 创建集合对
javaSE connections工具类
wangxulei123的博客
10-07 386
Class Collections java.lang.Object java.util.Collections 此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。 static boolean addAll(Collection<? super T> c, T… elements) 将所有指定的...
Java集合框架知识点
One_hundred_nice的博客
01-17 4897
一、集合框架体系图 二、Java集合框架的基本接口 Collection 为集合层次的根节点。一个集合代表了一组对象，这些对象即为它的元素。Java提供这个接口的任何直接实现类。 List：是一个有序集合；它可以包含重复元素。你可以通过它的索引来访问它的任何元素。List更像一个长度可变的数组 Set：是一个无序集、不可以包含重复元素。 Map 是一个key映射到value的对象。一个...
java程序的Connection工具类（我自己使用的）
雪落无痕的博客
07-24 1064
有些bug 以后慢慢改进。目前修改了两次了
【工具类】一、ConnectionUtil
代码有个家
06-18 2334
包含静态代码块及数据库对象关闭方法。 properties文件数据格式：Key=Value public class ConnectionUtils { private static String driver; private static String uri; private static String user; private static String password;
Java使用Collections工具类对List集合进行排序
08-25
Java使用Collections工具类对List集合进行排序 Java使用Collections工具类对List集合进行排序是Java编程中一个常见的操作。Collections工具类提供了一个sort方法，可以对List集合进行排序。下面我们将详细介绍如何...
day05-迭代器，数据结构,List,Set ,TreeSet集合,Collections工具类 - 副本.md
07-20
这是为了方便大家了解集合类的相关知识所找的一个MarkDown文档,读者可以通过阅读了解各种子类集合的实现原理,红黑树的实现也会有所介绍.
JAVA中Collections工具类sort()排序方法
09-01
在Java编程中，Collections工具类提供了许多方便的集合操作，其中`sort()`方法是一个非常重要的功能，用于对List类型的集合进行排序。本文将详细介绍`Collections.sort()`方法的两种使用方式及其示例。 ### 一、...
Collections工具类_动力节点Java学院整理.
10-16
Java工具中的Collections工具类_动力节点Java学院整理.
Java.util.Collections类包的学习
zaihch的专栏
01-18 588
Java.util.Collections类包的学习 1. 描述： 1.1 概述 java.util.Collections类包含很多有用的方法，可以使程序员的工作变得更加容易，但是这些方法通常都没有被充分地利用。Javadoc给出Collections类最完整的描述：“这一个类包含可以操作或返回集合的专用静态类。 ” 1.2 所含方法 Iterator, ArrayList, Ele...
java connections_Connection和Connections
weixin_34739646的博客
02-13 574
1、java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。CollectionList、LinkedList 、ArrayList 、Vector 、Stack 、Set2、java.util.Collection...
java入门（List、Set、数据结构、Collections）
Li_CSDN_Li的博客
07-05 291
List、Set、数据结构、Collections List 【List集合的特点】 元素有索引 元素有存取有序 元素可以重复 【List集合中常用的方法】 void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。 E get(int index):返回集合中指定位置的元素。 E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。 E set(int index, E element):用指定元素替换集合中指定位置的
【JDBC】一个Connection小工具类
jxyyyy的博客
10-09 188
这几天学习jdbc的时候跟着视频写出来的一个用于连接数据库和释放对象的小工具类。 用到的类：druid(数据库连接池)下载地址：https://repo1.maven.org/maven2/com/alibaba/druid/1.1.23/ mysql驱动： https://dev.mysql.com/downloads/ JdbcTemplate类 https://jar-download.com/artifacts/org.springframework/spring-jdbc 还需要两个配置文件分别是
Collection接口，List(ArrayList集合,LinkedList集合)，Set(HashSet集合,LinkedHashSet集合)
Li某人_初学者
07-14 2938
Collection 集合概述： 集合作为容器用来存储，管理大量的对象（引用），这些集合内部cc爱用了不同的数据结构来存储元素，这些数据结构的不同导致了每种集合的增删改查效率不同。 数据结构会另开一篇。 Java常用集合体系： Collection接口的常用方法 由于Collection是一个接口，所以该类中全部都是抽象方法，调用时会使用多态（父类型引用指向子类型对象）。主要了解这些方法的作用。 增： public boolean add(E e);//把给定的对象添加到集合中 删： public vo
HTML笔记
Li某人_初学者
06-01 1670
简介 1、系统结构： B/S架构：（以后主要走的方向是这个。） Browser / Server （浏览器/服务器的交互形式。） Browser支持哪些语言：HTML CSS JavaScript 写HTML CSS JavaScript代码的这波人职位叫做：WEB前端开发工程师。（Java程序员目前来看也需要会一些前端的东西。） 前端页面上的图片需要UI设计师完成。（PS对java程序员来说没有太高的要求。） S是服务器端Server，Server端的语言很多：C C++ Java
内部类及权限修饰符
Li某人_初学者
07-13 740
内部类 概述：将一个类A定义在另外一个类B中，类A则称为内部类，类B则称为外部类（以下统称为类A，类B） 成员内部类 理论： 概述：类A定义在类B的方法外。 格式： //外部类 class B{ //内部类 class A{ } public static void main(String[] args){ } //方法1 public void one(){ } //方法2 public void one(){ } } 用途：在描述事物时，若该事物内部还包含其它事物，就可以
反射
Li某人_初学者
08-12 720
反射 反射的概念及演示： 反射：又被称为“反向加载”。（之前创建某个类的对象时：Student stu = new Student()）;//正向加载—缺点：使当前类与Student类产生了依赖。 反射不直接使用“类名”，可以通过一个字符串描述的一个类名（可以将其记录在配置文件中），去加载这个类，并创建它的对象，进而去调用它的一些属性和方法。 反射的好处：解开类和类之间的“耦合” 代码图解： 运行时class文件的加载： 获取Class对象的三种方式： Object类的getClass()方法：
JavaScript笔记
Li某人_初学者
06-01 655
什么是JavaScript，有什么用？ JavaScript是运行在浏览器上的脚本语言。简称JS。 JavaScript程序不需要我们程序员手动编译，编写完源代码之后，浏览器直接打开解释执行。 JavaScript的“目标程序”以普通文本形式保存，这种语言都叫做“脚本语言”。 Java的目标程序已.class形式存在，不能使用文本编辑器打开，不是脚本语言。 JavaScript简介： JavaScript是网景公司（NetScape）的 布兰登艾奇（JavaScript之父）开发的，最初叫做LiveScr
collections工具类
最新发布
06-03
Collections 是 Java 提供的一个工具类，提供了一些常用的静态方法，用于操作集合对象。主要包括以下一些方法： - sort(List<T> list)：对 List 集合进行排序 - binarySearch(List<?> list, T key)：在 List 集合中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值