CompareTo 和caompare的初步理解，以及一些错误案例的展示

最新推荐文章于 2021-08-19 09:41:10 发布
最新推荐文章于 2021-08-19 09:41:10 发布
阅读量614 收藏
点赞数
分类专栏： 零基础自学JAVA--感悟和笔记 文章标签： compareTo和compare理解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37226649/article/details/87907933
版权

继承Comparable的实体类

package com.hantao.sortTest;

public class User implements Comparable<Object>{
    int id;
    String name;
    int  mainId;

    public int getMainId() {
        return mainId;
    }

    public void setMainId(int mainId) {
        this.mainId = mainId;
    }

    public User(int id, String name, int mainId) {
        this.id = id;
        this.name = name;
        this.mainId = mainId;
    }

    /*
     * Getters and Setters
     */
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", mainId=" + mainId +
                '}';
    }

    /**
     *负数代表左值小于右值，排在上面
     *正数代表左值大于右值，排在下面
     *0代表左值等于右值，排在上面
     * @param o
     * @return
     */
    @Override
    public int compareTo(Object o) {
        //可以这样理解：排序就是比较谁大谁小，将小的放在前面，大的放在后面。
        // 例如当返回负数的时候，表明第一个数应该排在第二个数的上面。

        //可以按照你想要的规则进行排序,不论是按照集合中的正序(返回值1),
        // 还是集合中的倒序(返回值-1)还是按照字典排序(如上)都是可以的。


        //1、如果字符串相等返回值0
        //2、如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值（ascii码值）（负值代表：前字符串的值小于后字符串，正值代表：前字符串大于后字符串）
        //3、如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方全比较完,这时就比较字符的长度. 
        //负值代表：前字符串的值小于后字符串，正值代表：前字符串大于后字符串
        //字符串越小的放在越前面。

        //同一个对象
        System.out.println("左侧为"+this.toString()+":右侧为"+o.toString());
        if(this ==o){
            User u = (User) o;
            System.out.println("左边==右侧,将"+mainId+"放在"+u.mainId+"前面");
            //负数代表左值小于右值，排在上面
            //正数代表左值大于右值，排在下面
            //0代表左值等于右值，排在上面
            return 0;
        }
        else if (o instanceof User) {
            User u = (User) o;
            if(id<=u.id){
                //(this.id-u.id)为负数    从小到大排序
                //想要从小到大排序,修改为(u.id-this.id)为负数
                System.out.println( "左边<右侧,将"+mainId+"放在"+u.mainId+"前面");
                return -1;
            }else{
                System.out.println("左边>右侧，将"+u.mainId+"放在"+mainId+"前面");
                return 1;
            }
        }else{
            System.out.println("报错");
            return -1;
        }
    }
}

test类

然后写一个Test类进行运行

package com.hantao.sortTest;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class UserTest2 {
  //编写Comparator,根据User的id对User进行排序
        private static final Comparator<User> COMPARATOR = new Comparator<User>() {
        public int compare(User o1, User o2) {
            return o1.compareTo(o2);//运用User类的compareTo方法比较两个对象
        }
    };
        public static void main(String[] args) {
            ArrayList<User> student = new ArrayList<User>();
            User user1 = new User(1,"zhongjingzou",1);
            User user5 = new User(2,"zhongjingzou4",4);
            User user4 = new User(2,"zhongjingzou3",3);
            User user2 = new User(2,"zhongjingzou2",2);
            User user6 =user5;
            User user7 =user5;

            student.add(user1);
            student.add(user5);
            student.add(user2);
            student.add(user4);
            student.add(user7);
            student.add(user6);




            Collections.sort(student, COMPARATOR);
            for(int i=0;i<student.size();i++){
                System.out.println(student.get(i).toString());
            }

            Collections.sort(student,new Comparator<User>() {
                @Override
                public int compare(User u1, User u2) {
                    //先倒序排序（从大到小）左边的参数和右边的参数相对传入的顺序倒置
                    int fileType = u2.getId() - u1.getId();
                    //想要正序排列(从小到大) 左边的参数和右边的参数按照传入的顺序
                    //int fileType = u1.getId() - u2.getId();
                    if (fileType == 0) {
                        //1、如果字符串相等返回值0
                        //2、如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值（ascii码值）（负值代表：前字符串的值小于后字符串，正值代表：前字符串大于后字符串）
                        //3、如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方全比较完,这时就比较字符的长度. 
                        //负值代表：前字符串的值小于后字符串，正值代表：前字符串大于后字符串
                        //字符串越小的放在越前面。
                        return u1.getName().compareToIgnoreCase(u2.getName());
                    }
                    return fileType;
                }
            });
            for(int i=0;i<student.size();i++){
                System.err.println(student.get(i).toString());
            }
        }
}

个人理解：

返回值的正，负，0

*负数代表左值小于右值，左值插入到当前右值的上面（前面）
*正数代表左值大于右值，右值插入到当前左值的上面（前面）
*0代表左值等于右值，左值插入到当前右值的上面（前面）

测试1:

首先我们来查看一下 

//编写Comparator,根据User的id对User进行排序
        private static final Comparator<User> COMPARATOR = new Comparator<User>() {
        public int compare(User o1, User o2) {
            return o1.compareTo(o2);//运用User类的compareTo方法比较两个对象
        }
    };

的效果。

左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=1, name='zhongjingzou', mainId=1}
左边>右侧，将1放在4前面
Disconnected from the target VM, address: '127.0.0.1:56748', transport: 'socket'
左侧为User{id=2, name='zhongjingzou2', mainId=2}:右侧为User{id=2, name='zhongjingzou4', mainId=4}
左边<右侧,将2放在4前面
左侧为User{id=2, name='zhongjingzou2', mainId=2}:右侧为User{id=2, name='zhongjingzou4', mainId=4}
左边<右侧,将2放在4前面
左侧为User{id=2, name='zhongjingzou2', mainId=2}:右侧为User{id=1, name='zhongjingzou', mainId=1}
左边>右侧，将1放在2前面
左侧为User{id=2, name='zhongjingzou3', mainId=3}:右侧为User{id=2, name='zhongjingzou2', mainId=2}
左边<右侧,将3放在2前面
左侧为User{id=2, name='zhongjingzou3', mainId=3}:右侧为User{id=1, name='zhongjingzou', mainId=1}
左边>右侧，将1放在3前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou2', mainId=2}
左边<右侧,将4放在2前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou3', mainId=3}
左边<右侧,将4放在3前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=1, name='zhongjingzou', mainId=1}
左边>右侧，将1放在4前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou3', mainId=3}
左边<右侧,将4放在3前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou4', mainId=4}
左边==右侧,将4放在4前面
User{id=1, name='zhongjingzou', mainId=1}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou3', mainId=3}
User{id=2, name='zhongjingzou2', mainId=2}
User{id=2, name='zhongjingzou4', mainId=4} 

可以根据描述的语句自己动手一下，看一下写的顺序是否一致。

然后修改一下list中add的顺序，可以发现相等的

  student.add(user1);
            student.add(user2);
            student.add(user4);
            student.add(user5);
            student.add(user6);
            student.add(user7);

左侧为User{id=2, name='zhongjingzou2', mainId=2}:右侧为User{id=1, name='zhongjingzou', mainId=1}
左边>右侧，将1放在2前面
左侧为User{id=2, name='zhongjingzou3', mainId=3}:右侧为User{id=2, name='zhongjingzou2', mainId=2}
左边<右侧,将3放在2前面
左侧为User{id=2, name='zhongjingzou3', mainId=3}:右侧为User{id=2, name='zhongjingzou2', mainId=2}
左边<右侧,将3放在2前面
左侧为User{id=2, name='zhongjingzou3', mainId=3}:右侧为User{id=1, name='zhongjingzou', mainId=1}
左边>右侧，将1放在3前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou3', mainId=3}
左边<右侧,将4放在3前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=1, name='zhongjingzou', mainId=1}
左边>右侧，将1放在4前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou3', mainId=3}
左边<右侧,将4放在3前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou4', mainId=4}
左边==右侧,将4放在4前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou4', mainId=4}
左边==右侧,将4放在4前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou2', mainId=2}
左边<右侧,将4放在2前面
左侧为User{id=2, name='zhongjingzou4', mainId=4}:右侧为User{id=2, name='zhongjingzou3', mainId=3}
左边<右侧,将4放在3前面
User{id=1, name='zhongjingzou', mainId=1}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou3', mainId=3}
User{id=2, name='zhongjingzou2', mainId=2}

修改add的顺序可以发现输出的结构有差异。

相同的对象(地址值一样)在list中的位置不一致也将导致排序的问题出现。

测试2:

然后来看一下

 Collections.sort(student,new Comparator<User>() {
                @Override
                public int compare(User u1, User u2) {
                    //先倒序排序（从大到小）左边的参数和右边的参数相对传入的顺序倒置
                    int fileType = u2.getId() - u1.getId();
                    //想要正序排列(从小到大) 左边的参数和右边的参数按照传入的顺序
                    //int fileType = u1.getId() - u2.getId();
                    if (fileType == 0) {
                        //1、如果字符串相等返回值0
                        //2、如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值（ascii码值）（负值代表：前字符串的值小于后字符串，正值代表：前字符串大于后字符串）
                        //3、如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方全比较完,这时就比较字符的长度. 
                        //负值代表：前字符串的值小于后字符串，正值代表：前字符串大于后字符串
                        //字符串越小的放在越前面。
                        return u1.getName().compareToIgnoreCase(u2.getName());
                    }
                    return fileType;
                }
            });

对应的结果

 

student.add(user1);
student.add(user2);
student.add(user4);
student.add(user5);
student.add(user6);
student.add(user7);

结果如下:

User{id=2, name='zhongjingzou2', mainId=2}
User{id=2, name='zhongjingzou3', mainId=3}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=1, name='zhongjingzou', mainId=1}

student.add(user1);
student.add(user5);
student.add(user2);
student.add(user4);
student.add(user7);
student.add(user6);

结果如下:

User{id=2, name='zhongjingzou2', mainId=2}
User{id=2, name='zhongjingzou3', mainId=3}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=2, name='zhongjingzou4', mainId=4}
User{id=1, name='zhongjingzou', mainId=1}

两次结果一致，可以思考一下为何这次add的顺序并没有导致之前相同地址值的排序sort出异常的情况。

 

附上相关int类型测试sort方法的测试Demo

import java.util.*;


public class SortTest {
    public void arraySort(){
        int[] arr = {1,4,6,333,8,2};
        Arrays.sort(arr);//使用java.util.Arrays对象的sort方法
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    public void listSort1(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(55);
        list.add(9);
        list.add(0);
        list.add(2);
        Collections.sort(list);//使用Collections的sort方法
        for(int a :list){
            System.out.println(a);
        }
    }
    //对list降序排序
    public void listSort2(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(55);
        list.add(9);
        list.add(0);
        list.add(2);
        //升序排列
        Collections.sort(list, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });//使用Collections的sort方法，并且重写compare方法
        for(int a :list){
            System.out.println(a);
        }
        //降序排列
        System.out.println("从大到小");
        Collections.sort(list, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });//使用Collections的sort方法，并且重写compare方法
        for(int a :list){
            System.out.println(a);
        }
    }

}

错误示例: 永远无法返回正值，永远只返回负值，无法正常排序。

照这么比，o1永远比o2要小那当然不能排序。

package com.lin;
 
import java.util.Comparator;
 
public class ComparatorTest implements Comparator<Student> {
 
    @Override
    public int compare(Student o1, Student o2) {
        if(o1.getAge() < o2.getAge()){
            int num = o1.getAge() - o2.getAge();
//            System.out.println(num);
            return num;
        }else{
            int num = o2.getAge() - o1.getAge();
//            System.out.println(num);
            return num;
        }
    }
}

 

相关:

【转】Java中Collections.sort()和Arrays.sort()所采用的排序算法

https://www.cnblogs.com/merru/articles/4666493.html

 

 

 

 

  

 

 

 

周仲景
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
25454
hanguabiao0595的博客
09-26 1万+
http://www.niadp.top http://www.oadxh.top http://www.lbcos.top http://www.ldpfy.top http://www.vctkh.top http://www.appga.top http://www.qvgep.top http://www.vpdch.top http://www.koapa.top ht
compare(o1，o2)方法中返回正数，负数。
hpccph15的博客
04-06 2860
compare(Object o1, Object o2) { return -1; //返回负数时参数的顺序就是排的顺序即:o1,o2 } compare(Object o1, Object o2) { return 1; //返回正数时参数的反序就是排的顺序即:o2,o1 } /** *假设有个person类，有年龄属性age */ compare(Person p1, Person p2) { return p1.age - p2.age; //如果p1.age > p2.a
compareTo 返回为整数 调用者比参数大;返回负数 调用者比参数小
weixin_30614587的博客
11-28 271
compareTo 返回为整数 调用者比参数大;返回负数 调用者比参数小 转载于:https://www.cnblogs.com/classmethond/p/10035763.html
complare函数（C++algorithm库）
weixin_44285715的博客
03-04 875
1. sort函数 int a[10]={9,6,3,8,5,2,7,4,1,0}; sort(a,a+10) 以上默认是从小到大排序的。参数分别是数组的首地址、首地址+数组长度。 如果想按自己的意愿排序，可以重写complare函数，如下 #include&amp;lt;iostream&amp;gt; #include&amp;lt;algorithm&amp;gt; using namespace std; bool c...
用OpenSSL做自签名的证书(by quqi99)
技术并艺术着
08-19 3208
作者：张华 发表于：2014-04-18 版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本版权声明 (http://blog.csdn.net/quqi99 ) 注：csdn居然丢文章，这篇2014年的就丢了，这是从互联网上找到的其他网站的转载备份。 加密技术回顾 非对称加密算法如RSA的特点如下: 1, 公钥加密私钥解密, 大家都可以用我的公钥给我发加密的数据了, 因为只有我有私钥才能解密. 2, 私钥加密公钥解密叫数字签名(例如所谓的UEFI secure boot就是在
详解java中保持compareTo和equals同步
08-31
Java 中保持 compareTo 和 equals 同步 在 Java 中，compareTo 和 equals 是两个不同的概念，但它们之间存在着紧密的联系。compareTo 是 Comparable 接口中的方法，用于比较两个对象的大小关系，而 equals 是 ...
java CompareTo使用案例
01-17
本文将深入探讨`compareTo()`方法的使用，包括其基本原理、语法、用例以及如何在实际项目中应用。 `compareTo()`方法的基本概念： ----------------------- `compareTo()`方法主要用于比较两个对象的大小，并返回...
Lambda表达式的一些简单用法以及自我理解
08-26
例如，以下代码展示了如何使用Lambda表达式对一个整数列表进行升序排序： ```java List<Integer> numbers = Arrays.asList(5, 2, 9, 1, 5); Collections.sort(numbers, (a, b) -> a - b); ``` 这里的`(a, b) ->...
关于重写equals，hashcode以及compareTo方法！
04-19
关于重写equals、hashcode以及compareTo方法！ equals()方法是Object类中的一个方法，它用于比较两个对象是否相等。然而，它的默认实现是比较对象的引用（地址），而不是比较对象的实际内容。因此，在某些情况下，...
浅谈java中BigDecimal的equals与compareTo的区别
09-01
在Java编程语言中，BigDecimal类用于表示任意精度的十进制浮点数，它提供了...对于财务计算，通常会采用`compareTo`来避免因小数点后零的差异导致的错误。理解这两个方法的差异，可以帮助我们编写更健壮和精确的代码。
linux ftps服务端和客户端
04-06
linux ftps服务端和客户端
MSP430 RFID以及射频
11-15
基于MSP430开发的资料 RFID msp430 射频卡 电路 MSP430 RFID以及射频
gdc服务器pem文件,第三十八章 PEM_密钥对生成与读取方法
weixin_35051558的博客
08-06 811
一、PEM概述PEM是OpenSSL和许多其他SSL工具的标准格式，OpenSSL 使用PEM 文件格式存储证书和密钥。这种格式被设计用来安全的包含在ascii甚至富文本文档中，如电子邮件。这意味着您可以简单的复制和粘贴pem文件的内容到另一个文档中。二、PEM文件介绍PEM文件是Base64编码的证书。PEM证书通常用于web服务器，因为他们可以通过一个简单的文本编辑器，很容易地转换成可读的数据...
RSA私钥文件（PEM）解析
热门推荐
mxiaomi的专栏
06-15 3万+
已知RSA私钥各数据域，生成PEM文件。
关于list.sort()中对象的属性无法调用compareTo()方法解决方案
qq_21396793的博客
03-15 2381
首先我们先了解下排序与list.sort()使用，引用http://blog.csdn.net/u011611902/article/details/49450629尝试下第二种方法是会发现你选择自定义类对象的排序属性无法调用compareTo()方法即出现如下图情况（PS: 将属性public，调用属性同样不行）解决思路是（加壳）在myComp中实现一个针对int型的compare方法，再调用实...
java多条件优先级排序 --------- Comparator
深圳大力
02-11 496
Comparator用法代码   package com;     import java.util.ArrayList;   import java.util.Collections;   import java.util.Comparator;   import java.util.List;     public class ComparatorDemo {       pub
Comparator类中的compare(T o1,T o2)和compareTo()的使用与疑惑解答
qq_36005199的博客
08-07 1万+
这几天做项目刚好遇到需要排序的需求，大概就是你查询一个list,然后list中保存的是map数据，你需要根据map中的若干个数据排序，比如说 List&lt;Map&lt;String, Object&gt;&gt; list = new ArrayList&lt;&gt;(); Map&lt;String, Object&gt; yuan = new HashMap&lt;&gt;();...
Java Comparator接口和compareto方法总结
GOV_D的博客
03-28 1705
compare(Object o1,Object o2)方法是java.util.Comparator接口的方法，它实际上用的是待比较对象的compareTo(Object o)方法。 之前一直搞不清楚自定义的compare的返回值到底怎么处理，一番查询和总结后得到如下结果： compare(Object o1,Object o2)方法中，默认采用的是o1-o2，若o1<o2，返回值为-1；若o1==o2，返回值为0；若o1>o2,返回值为1；而其排序结果是按-1来排序的，即默认为从小到大排序。
5种转换Date的方式
Sean Zou
02-26 4423
最常见的在实体类上配置 1 JsonFormat来源于jackson，Jackson是一个简单基于Java应用库，Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象。Jackson所依赖的jar包较少，简单易用并且性能也要相对高些，并且Jackson社区相对比较活跃，更新速度也比较快。 注意:默认Spring @Reque...
compareto和comparable
最新发布
08-03
compareTo和Comparable都是Java中用于比较对象的接口和方法。 Comparable是一个接口，它定义了一个compareTo()方法，用于比较对象的大小。实现Comparable接口的类可以使用Collections.sort()方法进行排序。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值