转载

Collection和Collections之间的使用与区别（顺带讲解Comparable与Comparator区别）

前言 Collection与Collections的区别一句话概括就是后者是S曲线.....哎哎哎别打....别打...别打脸QnQ

咳咳...严肃点，在之前的文章中已经讲过Collection了，它是单列集合类的根接口，用于存储一系列符合某种规则的元素，它主要的子接口分别是List和Set。

Collections则是集合工具类，用来对集合进行操作。可以理解为服务Collection集合的工具类，主要提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作

@[toc]

1.1 Collections常用功能

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 CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //原来添加写法
        //list.add(233);
        //list.add(555);
        //list.add(666);
        //list.add(7777);
        
        //采用工具类 完成 往集合中添加元素  
        Collections.addAll(list, 1, 4, 3，2);
        System.out.println(list);
        //排序方法 
        Collections.sort(list);
        System.out.println(list);
    }
}
结果：
[ 1, 4, 3，2]
[1, 2, 3,4]
复制代码

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

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

1.2 Comparator比较器的使用

研究这个方法前还是先研究这个 public static <T> void sort(List<T> list) 方法先。

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

使用这个方法存储 字符串类型 代码如下【注意这里是字符串类型】： 

public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<String>  list = new ArrayList<String>();
        list.add("小卤蛋");
        list.add("小短腿");
        list.add("小鲁班");
        list.add("小憨包");
        //排序方法
        Collections.sort(list);
        System.out.println(list);
    }
}
运行结果：[小卤蛋, 小憨包, 小短腿, 小鲁班]
复制代码

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

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

1.3 分析String源码

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

public final class String implements java.io.Serializable,
Comparable<String>, CharSequence {
       ....
}
复制代码

String类实现了这个Comparable接口（Integer也实现这接口），并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，修改源码这件事这是不可能的了！除非你们怂恿博主跑去sun公司修改源码，接着我就删库跑路，最后绝壁是挨最毒的打....

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

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

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

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

操作如下:

public class CollectionsDemo {
    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]

复制代码

1.4Comparable接口和Comparator接口区别

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。只能在类中实现 compareTo() 一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过 Collections.sort （和 Arrays.sort ）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator强行对某个对象进行整体排序。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort ），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

总而言之，言而总之 comparable是需要比较的对象来实现接口。这样对象调用实现的方法来比较。对对象的耦合度高（需要改变对象的内部结构，破坏性大）。comparator相当于一通用的比较工具类接口。需要定制一个比较类去实现它，重写里面的compare方法，方法的参数即是需要比较的对象。对象不用做任何改变。解耦。

1.5 欢迎来到王者龙耀排序战场

创建一个学生类，存储到ArrayList集合中完成指定排序操作。

Student 初始类

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 +
               '}';
    }
}
复制代码

测试类：

public class Demo {

    public static void main(String[] args) {
        // 创建四学生刺客对象 存储到集合中
        ArrayList<Student> list = new ArrayList<Student>();

        list.add(new Student("r卤蛋七号",18));
        list.add(new Student("j安琪拉屎",16));
        list.add(new Student("a刘备胎",16));
        list.add(new Student("a东皇太二",17));
        list.add(new Student("m夏侯惇坑",16));


        /*
          让学生 按照年龄排序 升序
         */
//        Collections.sort(list);//要求 该list中元素类型  必须实现比较器Comparable接口


        for (Student student : list) {
            System.out.println(student);
        }


    }
}
复制代码

发现，当我们调用 Collections.sort() 方法的时候 程序报错了。

原因：如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。

于是我们就完成了Student类的一个实现，如下：

public class Student implements Comparable<Student>{
    ....
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;//升序
    }
}
复制代码

再次测试，代码就OK 了效果如下：

Student{name='j安琪拉屎', age=16}
Student{name='a刘备胎', age=16}
Student{name='m夏侯惇坑', age=16}
Student{name='a东皇太二', age=17}
Student{name='r卤蛋七号', age=18}
复制代码

1.6 排序加餐不加价

如果在使用的时候，想要独立的定义规则去使用 可以采用 Collections.sort(List list,Comparetor<T> c) 方式，自己定义规则： 

Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getAge()-o1.getAge();//以学生的年龄降序
    }
});
复制代码

效果：

Student{name='r卤蛋七号', age=18}
Student{name='a东皇太二', age=17}
Student{name='j安琪拉屎', age=16}
Student{name='a刘备胎', age=16}
Student{name='m夏侯惇坑', age=16}
复制代码

如果想要规则更多一些，可以参考下面代码：

Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 年龄降序
                int result = o2.getAge()-o1.getAge();//年龄降序

                if(result==0){//第一个规则判断完了 下一个规则 姓名的首字母 升序
                    result = o1.getName().charAt(0)-o2.getName().charAt(0);
                }

                return result;
            }
        });
复制代码

效果如下：

Student{name='r卤蛋七号', age=18}
Student{name='a东皇太二', age=17}
Student{name='a刘备胎', age=16}
Student{name='j安琪拉屎', age=16}
Student{name='m夏侯惇坑', age=16}
复制代码

水晶你就是个混子，说好不带掉血的呢？哦豁完了...

最后欢迎各位关注我的公众号，一起探讨技术，向往技术，追求技术，来了就是盆友喔...

Collection和Collections之间的使用与区别（顺带讲解Comparable与Comparator区别）
原文  https://juejin.im/post/5dc366be6fb9a04abd4cceb9
正文到此结束
所属分类： 编程技术 Java

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Java设计模式 Jenkins进阶系列 openfire参考指南 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 Ant教程 java实例教程 SpringCloud Elastic-Job-Lite XStream教程 深入浅出MyBatis Hazelcast教程 ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 springcloud-demo JPA教程 ActiveMQ中文指南 Java内存模型 java-demo dubbo教程 Linux入门视频教程
近期评论
  1. 1 Spring Cloud Circuit Breaker快速入门Demo
  2. 2 Spring Cloud Bus快速入门Demo
  3. 3 Spring Cloud Config快速入门Demo
  4. 4 Spring Cloud Function快速入门Demo
  5. 5 SSPanel-Uim搭建教程 2023年全新定制版主题-解决老版本命令失效问题
  6. 6 Spring Boot集成Milvus和deeplearning4j实现图搜图功能
  7. 7 Spring Boot集成Aviator实现参数校验
  8. 8 ACME自动申请免费的通配符https域名证书
  9. 9 wordpress 数据库和文件优化
  10. 10 CentOS安装Docker与Docker-Compose
网站信息
  • 文章总数：82,696 篇
  • 文件总数：284,257 个
  • 标签总数：2,380 个
  • 分类总数：84 个
  • 留言数量：2,560 条
  • 在线人数：630 人
  • 运行天数：4,392天
  • 最后更新：2024年11月05日22点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG