精华内容
下载资源
问答
  • compareTo
    2021-10-17 14:28:00

    compareTo

    • 如果指定的数与参数相等返回0
    • 如果指定的数小于参数返回 -1,-1表示降序排序
    • 如果指定的数大于参数返回 1,1表示升序排序

    compareTo重写

    • 重写该函数的类implements Comparable接口
    • this<o 指定的数小于参数,返回-1,-1表示降序排序
    • this>o 指定的数大于参数,返回1,1表示升序排序
    @Override
    	public int compareTo(Node o) {
    		//从小到大排序
    		return this.value-o.value;//返回-1是降序
    		//this与o比较
    		//this>o  指定的数大于参数,返回1
    		//this<o  指定的数小于参数,返回-1
    		//this=o  指定的数等于参数,返回0
    	}
    
    

    更全面

    更多相关内容
  • 下面小编就为大家带来一篇浅谈java中BigDecimal的equals与compareTo的区别。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了String类下compareTo()与compare()方法比较的相关资料,需要的朋友可以参考下
  • 主要给大家介绍了关于java源码解析之String类的compareTo(String otherString)方法的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面随着小编来一起学习学习吧
  • 主要给大家介绍了关于Java中比较运算符compareTo()、equals()与==的区别及应用的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面随着小编来一起学习学习吧
  • ###Responsibilities### Aequum 库旨在通过使用在 POJO 类上编写equals 、 hashCode和compareTo方法时帮助删除一些样板。 请注意,此库依赖于 Java 8。 ###组件初始化指令###要使用此库,调用builder的方法Aequum...
  • java中的compareto方法

    千次阅读 2021-12-04 21:42:12
    一.java中的compareto方法 1.返回参与比较的前后两个字符串的asc码的差值,如果两个字符串首字母不同,则该方法返回首字母的asc码的差值 String a1 = “a”; String a2 = “c”; System.out.println(a1.compareTo(a2...

    一.java中的compareto方法

    1.返回参与比较的前后两个字符串的asc码的差值,如果两个字符串首字母不同,则该方法返回首字母的asc码的差值

    String a1 = “a”;
    String a2 = “c”;
    System.out.println(a1.compareTo(a2));//结果为-2

    2.即参与比较的两个字符串如果首字符相同,则比较下一个字符,直到有不同的为止,返回该不同的字符的asc码差值,

    String a1 = “aa”;
    String a2 = “ad”;
    System.out.println(a1.compareTo(a2));//结果为-3
    3.如果两个字符串不一样长,可以参与比较的字符又完全一样,则返回两个字符串的长度差值

    String a1 = “aa”;
    String a2 = “aa12345678”;
    System.out.println(a1.compareTo(a2));//结果为-8
    4.返回为正数表示a1>a2, 返回为负数表示a1<a2, 返回为0表示a1==a2;

    5.数字类型不能用compareTo,nt跟int的比较不能用compareTo方法,直接用大于(>) 小于(<) 或者 等于(==) 不等于(!=)来比较即可

    int num1 = 4;
    int num2 = 5;
    num1.compareTo(num2);//Cannot invoke compareTo(int) on the primitive type int
    你可以先把你的int型变量转换成String再进行比较

    复制代码
         int num1 = 4;
    int num2 = 5;

        //parse int to String    
        System.out.println((num1+"").compareTo(num2+""));//-1
        System.out.println(new Integer(num1).toString(). compareTo(new Integer(num2).toString()));//-1
        System.out.println(String.valueOf(num1).compareTo(String.valueOf(num2)));//-1
    

    复制代码
    6.compareToIgnoreCase忽略大小写

    不考虑大小写,按字典顺序比较两个字符串。此方法返回一个整数,它的正负号是调用 compareTo 的正负号,调用时使用了字符串的规范化版本,其大小写差异已通过对每个字符调用 Character.toLowerCase(Character.toUpperCase(character)) 得以消除。
    注意,此方法不 考虑语言环境,因此可能在某些特定的语言环境中产生不理想的排序。java.text 包提供 Collators 来完成语言环境敏感的排序。

    7.int型可以直接比较,所以没有用到compareTo比较,如果声明的是Date、String、Integer、或者其他的,可以直接使用compareTo比较,

      Integer n1 = 5;
        Integer n2 = 6;
        System.out.println(n1.compareTo(n2));//-1        
    

    二. Comparable接口中的compareTo

    compareTo方法内必须做非空判断(规范问题),当然int类型就不用了。

    注意事项:

    1、模型必须实现Comparable接口

    2、Collection.sort(list)会自动调用compareTo,如果没有这句,list是不会排序的,也不会调用compareTo方法

    3、如果是数组则用Arrays.sort(a)方法

    注意要非空判断,这里实例就不判断了

    复制代码
      private int bookId;

    private String bookName;
    
    private int bookPrice;
    
    @Override
    public int compareTo(Book o) {
        // TODO Auto-generated method stub
        
    //return this.bookPrice-o.bookPrice;//按价格排序 升序
    //return o.bookPrice-this.bookPrice;//按价格排序 降序
        
    //return this.bookName.compareTo(o.bookName);//按书名排序 升序
        
    //先按 id 再按价格 最后按书名排序 升序
        int result = this.bookId - o.bookId;
        if(result == 0){
            result =this.bookPrice - o.bookPrice;
        }
        if(result == 0){
            result = this.bookName.compareTo(o.bookName);
        }        
        return result;
        
    }
    

    复制代码
    复制代码
    package com.my.test.compare;

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;

    public class TestCompare {
    public static void main(String[] args) {
    Book b1 = new Book(1, “语文”, 20);
    Book b2 = new Book(2, “数学”, 10);
    Book b3 = new Book(5, “英语”, 10);
    Book b4 = new Book(4, “化学”, 50);
    Book b5 = new Book(3, “化学”, 10);
    //Book b6 = null;//不能为null,Collections.sort调用compareTo会报空指针异常

        List<Book> books = new ArrayList<>();         
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);
        books.add(b5);
        System.out.println("Collections 排序前");
        
        for (Book book : books) {
            System.out.println(book);
            
        }
        Collections.sort(books);
        System.out.println("Collections 排序后");
    
        for (Book book : books) {
            System.out.println(book);
            
        }
        
        Book[] b = new Book[5];
        System.out.println(b.length);
    
        b[0] = b1;
        b[1] = b2;
        b[2] = b3;
        b[3] = b4;
        b[4] = b5;
        
        System.out.println("Arrays 排序前" );
        for (Book book : b) {
            System.out.println(book);
        }
        
        Arrays.sort(b);
        
        System.out.println("Arrays 排序后" );
        for (Book book : b) {
            System.out.println(book);
        }
        
        
    }
    

    }
    复制代码
    在应用中我们为了好判断状态,一般处理为

    复制代码
        if(this.bookId<o.bookId){
    return -1;
    }else if(this.bookId>o.bookId){
    return 1;
    }else{
    return 0;
    }
    复制代码

    返回值为 1,0.-1:

    三。 Comparator接口

    源码:

    复制代码
    @FunctionalInterface
    public interface Comparator {
    // 核心方法,用来比较两个对象,如果o1小于o2,返回负数;等于o2,返回0;大于o2返回正数
    int compare(T o1, T o2);
    // 好像很少用到,一般都用对象自带的equals
    boolean equals(Object obj);

    /**-----------下面的都是JDK1.8新增的接口,挑几个放进去----------*/

    //返回反向排序比较器
    default Comparator reversed() {
    return Collections.reverseOrder(this);
    }
    //根据名字知道,先进行compare比较后,再进行一次比较
    default Comparator thenComparing(Comparator<? super T> other) {
    Objects.requireNonNull(other);
    return (Comparator & Serializable) (c1, c2) -> {
    int res = compare(c1, c2);
    return (res != 0) ? res : other.compare(c1, c2);
    };
    }
    //对int类型的key进行比较
    public static Comparator comparingInt(ToIntFunction<? super T> keyExtractor) {
    Objects.requireNonNull(keyExtractor);
    return (Comparator & Serializable)
    (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }
    //返回正常顺序的比较器
    public static <T extends Comparable<? super T>> Comparator naturalOrder() {
    return (Comparator) Comparators.NaturalOrderComparator.INSTANCE;
    }
    }
    复制代码
    一起来看一下如何使用,先来看一下JDK1.8以前的用法:

    复制代码
    Collections.sort(books,new Comparator() {

            @Override
            public int compare(Book o1, Book o2) {
                // TODO Auto-generated method stub
                
                return o1.getBookPrice() - o2.getBookPrice();
                
            }
        });
    

    复制代码
    或者创建一个比较器

    复制代码
    package com.my.test.compare;

    import java.util.Comparator;

    public class SimpleCompator implements Comparator {

    @Override
    public int compare(Book o1, Book o2) {
        // TODO Auto-generated method stub
        return o1.getBookPrice() -o2.getBookPrice();
    }
    

    }
    复制代码

    Collections.sort(books,new SimpleCompator());
    JDK1.8以前的用法要自己手动实现Comparator接口,然后调用Collections.sort(),传入实现类来完成排序,非常麻烦,而JDK1.8则相对来说简单了很多:

        Collections.sort(books,(Book a, Book b) -> { return a.getBookPrice()-b.getBookPrice(); });
    

    或者可以简单的写为

        Collections.sort(books,(Book a, Book b) ->  a.getBookPrice()-b.getBookPrice());
    

    甚至,我们可以不使用Collections.sort:

    books.sort((Book a, Book b) -> a.getBookPrice()-b.getBookPrice() );
    详见:http://www.manongjc.com/article/8005.html

    compator 在 treeMap 中的 应用(基于key的排序):

    treeMap默认的是基于key的从小到大 的排列

    自定义排序也是基于key的,如果key object类型 可以自定义各种排序

            TreeMap<String, Person> treeMap = new TreeMap<>((String a,String b)-> b.compareTo(a));//降序
            TreeMap<String, Person> treeMap = new TreeMap<>((String a,String b)-> a.compareTo(b));//升序
    

    TreeMap的按value排序(转换成entry list 然后排序)汉字是按ascii码排序的,不是汉语拼音

    复制代码
    Person p1 = new Person(1, “A小红”);
    Person p2 = new Person(5, “D赵明”);
    Person p3 = new Person(2, “W孙宇”);
    Person p4 = new Person(9, “C黎明”);

        TreeMap<String, Person> treeMap = new TreeMap<>();
    
        treeMap.put("45", p1);
        treeMap.put("12", p2);
        treeMap.put("85", p3);
        treeMap.put("33", p4);
    
    
        List<Map.Entry<String, Person>> entries = new ArrayList<>(treeMap.entrySet());
    
        Collections.sort(entries,
                (Map.Entry<String, Person> e1, Map.Entry<String, Person> e2) -> ((Person) e1.getValue()).getPersonName()
                        .compareTo(((Person) e2.getValue()).getPersonName()));
        System.out.println("按名字顺序排列");
        for (Entry<String, Person> entry : entries) {
            System.out.println(entry.getValue());
            
        }
    

    一.java中的compareto方法

    1.返回参与比较的前后两个字符串的asc码的差值,如果两个字符串首字母不同,则该方法返回首字母的asc码的差值

    String a1 = “a”;
    String a2 = “c”;
    System.out.println(a1.compareTo(a2));//结果为-2

    2.即参与比较的两个字符串如果首字符相同,则比较下一个字符,直到有不同的为止,返回该不同的字符的asc码差值,

    String a1 = “aa”;
    String a2 = “ad”;
    System.out.println(a1.compareTo(a2));//结果为-3
    3.如果两个字符串不一样长,可以参与比较的字符又完全一样,则返回两个字符串的长度差值

    String a1 = “aa”;
    String a2 = “aa12345678”;
    System.out.println(a1.compareTo(a2));//结果为-8
    4.返回为正数表示a1>a2, 返回为负数表示a1<a2, 返回为0表示a1==a2;

    5.数字类型不能用compareTo,nt跟int的比较不能用compareTo方法,直接用大于(>) 小于(<) 或者 等于(==) 不等于(!=)来比较即可

    int num1 = 4;
    int num2 = 5;
    num1.compareTo(num2);//Cannot invoke compareTo(int) on the primitive type int
    你可以先把你的int型变量转换成String再进行比较

    复制代码
         int num1 = 4;
    int num2 = 5;

        //parse int to String    
        System.out.println((num1+"").compareTo(num2+""));//-1
        System.out.println(new Integer(num1).toString(). compareTo(new Integer(num2).toString()));//-1
        System.out.println(String.valueOf(num1).compareTo(String.valueOf(num2)));//-1
    

    复制代码
    6.compareToIgnoreCase忽略大小写

    不考虑大小写,按字典顺序比较两个字符串。此方法返回一个整数,它的正负号是调用 compareTo 的正负号,调用时使用了字符串的规范化版本,其大小写差异已通过对每个字符调用 Character.toLowerCase(Character.toUpperCase(character)) 得以消除。
    注意,此方法不 考虑语言环境,因此可能在某些特定的语言环境中产生不理想的排序。java.text 包提供 Collators 来完成语言环境敏感的排序。

    7.int型可以直接比较,所以没有用到compareTo比较,如果声明的是Date、String、Integer、或者其他的,可以直接使用compareTo比较,

      Integer n1 = 5;
        Integer n2 = 6;
        System.out.println(n1.compareTo(n2));//-1        
    

    二. Comparable接口中的compareTo

    compareTo方法内必须做非空判断(规范问题),当然int类型就不用了。

    注意事项:

    1、模型必须实现Comparable接口

    2、Collection.sort(list)会自动调用compareTo,如果没有这句,list是不会排序的,也不会调用compareTo方法

    3、如果是数组则用Arrays.sort(a)方法

    注意要非空判断,这里实例就不判断了

    复制代码
      private int bookId;

    private String bookName;
    
    private int bookPrice;
    
    @Override
    public int compareTo(Book o) {
        // TODO Auto-generated method stub
        
    //return this.bookPrice-o.bookPrice;//按价格排序 升序
    //return o.bookPrice-this.bookPrice;//按价格排序 降序
        
    //return this.bookName.compareTo(o.bookName);//按书名排序 升序
        
    //先按 id 再按价格 最后按书名排序 升序
        int result = this.bookId - o.bookId;
        if(result == 0){
            result =this.bookPrice - o.bookPrice;
        }
        if(result == 0){
            result = this.bookName.compareTo(o.bookName);
        }        
        return result;
        
    }
    

    复制代码
    复制代码
    package com.my.test.compare;

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;

    public class TestCompare {
    public static void main(String[] args) {
    Book b1 = new Book(1, “语文”, 20);
    Book b2 = new Book(2, “数学”, 10);
    Book b3 = new Book(5, “英语”, 10);
    Book b4 = new Book(4, “化学”, 50);
    Book b5 = new Book(3, “化学”, 10);
    //Book b6 = null;//不能为null,Collections.sort调用compareTo会报空指针异常

        List<Book> books = new ArrayList<>();         
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);
        books.add(b5);
        System.out.println("Collections 排序前");
        
        for (Book book : books) {
            System.out.println(book);
            
        }
        Collections.sort(books);
        System.out.println("Collections 排序后");
    
        for (Book book : books) {
            System.out.println(book);
            
        }
        
        Book[] b = new Book[5];
        System.out.println(b.length);
    
        b[0] = b1;
        b[1] = b2;
        b[2] = b3;
        b[3] = b4;
        b[4] = b5;
        
        System.out.println("Arrays 排序前" );
        for (Book book : b) {
            System.out.println(book);
        }
        
        Arrays.sort(b);
        
        System.out.println("Arrays 排序后" );
        for (Book book : b) {
            System.out.println(book);
        }
        
        
    }
    

    }
    复制代码
    在应用中我们为了好判断状态,一般处理为

    复制代码
        if(this.bookId<o.bookId){
    return -1;
    }else if(this.bookId>o.bookId){
    return 1;
    }else{
    return 0;
    }
    复制代码

    返回值为 1,0.-1:

    三。 Comparator接口

    源码:

    复制代码
    @FunctionalInterface
    public interface Comparator {
    // 核心方法,用来比较两个对象,如果o1小于o2,返回负数;等于o2,返回0;大于o2返回正数
    int compare(T o1, T o2);
    // 好像很少用到,一般都用对象自带的equals
    boolean equals(Object obj);

    /**-----------下面的都是JDK1.8新增的接口,挑几个放进去----------*/

    //返回反向排序比较器
    default Comparator reversed() {
    return Collections.reverseOrder(this);
    }
    //根据名字知道,先进行compare比较后,再进行一次比较
    default Comparator thenComparing(Comparator<? super T> other) {
    Objects.requireNonNull(other);
    return (Comparator & Serializable) (c1, c2) -> {
    int res = compare(c1, c2);
    return (res != 0) ? res : other.compare(c1, c2);
    };
    }
    //对int类型的key进行比较
    public static Comparator comparingInt(ToIntFunction<? super T> keyExtractor) {
    Objects.requireNonNull(keyExtractor);
    return (Comparator & Serializable)
    (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }
    //返回正常顺序的比较器
    public static <T extends Comparable<? super T>> Comparator naturalOrder() {
    return (Comparator) Comparators.NaturalOrderComparator.INSTANCE;
    }
    }
    复制代码
    一起来看一下如何使用,先来看一下JDK1.8以前的用法:

    复制代码
    Collections.sort(books,new Comparator() {

            @Override
            public int compare(Book o1, Book o2) {
                // TODO Auto-generated method stub
                
                return o1.getBookPrice() - o2.getBookPrice();
                
            }
        });
    

    复制代码
    或者创建一个比较器

    复制代码
    package com.my.test.compare;

    import java.util.Comparator;

    public class SimpleCompator implements Comparator {

    @Override
    public int compare(Book o1, Book o2) {
        // TODO Auto-generated method stub
        return o1.getBookPrice() -o2.getBookPrice();
    }
    

    }
    复制代码

    Collections.sort(books,new SimpleCompator());
    JDK1.8以前的用法要自己手动实现Comparator接口,然后调用Collections.sort(),传入实现类来完成排序,非常麻烦,而JDK1.8则相对来说简单了很多:

        Collections.sort(books,(Book a, Book b) -> { return a.getBookPrice()-b.getBookPrice(); });
    

    或者可以简单的写为

        Collections.sort(books,(Book a, Book b) ->  a.getBookPrice()-b.getBookPrice());
    

    甚至,我们可以不使用Collections.sort:

    books.sort((Book a, Book b) -> a.getBookPrice()-b.getBookPrice() );
    详见:http://www.manongjc.com/article/8005.html

    compator 在 treeMap 中的 应用(基于key的排序):

    treeMap默认的是基于key的从小到大 的排列

    自定义排序也是基于key的,如果key object类型 可以自定义各种排序

            TreeMap<String, Person> treeMap = new TreeMap<>((String a,String b)-> b.compareTo(a));//降序
            TreeMap<String, Person> treeMap = new TreeMap<>((String a,String b)-> a.compareTo(b));//升序
    

    TreeMap的按value排序(转换成entry list 然后排序)汉字是按ascii码排序的,不是汉语拼音

    复制代码
    Person p1 = new Person(1, “A小红”);
    Person p2 = new Person(5, “D赵明”);
    Person p3 = new Person(2, “W孙宇”);
    Person p4 = new Person(9, “C黎明”);

        TreeMap<String, Person> treeMap = new TreeMap<>();
    
        treeMap.put("45", p1);
        treeMap.put("12", p2);
        treeMap.put("85", p3);
        treeMap.put("33", p4);
    
    
        List<Map.Entry<String, Person>> entries = new ArrayList<>(treeMap.entrySet());
    
        Collections.sort(entries,
                (Map.Entry<String, Person> e1, Map.Entry<String, Person> e2) -> ((Person) e1.getValue()).getPersonName()
                        .compareTo(((Person) e2.getValue()).getPersonName()));
        System.out.println("按名字顺序排列");
        for (Entry<String, Person> entry : entries) {
            System.out.println(entry.getValue());
            
        }
    
    展开全文
  • 一.java中的compareto方法1.返回参与比较的前后两个字符串的asc码的差值,如果两个字符串首字母不同,则该方法返回首字母的asc码的差值String a1 = "a";String a2= "c";System.out.println(a1.compareTo(a2));//结果...

    一.java中的compareto方法

    1.返回参与比较的前后两个字符串的asc码的差值,如果两个字符串首字母不同,则该方法返回首字母的asc码的差值

    String a1 = "a";

    String a2= "c";

    System.out.println(a1.compareTo(a2));//结果为-2

    2.即参与比较的两个字符串如果首字符相同,则比较下一个字符,直到有不同的为止,返回该不同的字符的asc码差值,

    String a1 = "aa";

    String a2= "ad";

    System.out.println(a1.compareTo(a2));//结果为-3

    3.如果两个字符串不一样长,可以参与比较的字符又完全一样,则返回两个字符串的长度差值

    String a1 = "aa";

    String a2= "aa12345678";

    System.out.println(a1.compareTo(a2));//结果为-8

    4.返回为正数表示a1>a2, 返回为负数表示a1

    5.数字类型不能用compareTo,nt跟int的比较不能用compareTo方法,直接用大于(>)小于(

    int num1 = 4;int num2 = 5;

    num1.compareTo(num2);//Cannot invoke compareTo(int) on the primitive type int

    你可以先把你的int型变量转换成String再进行比较

    int num1 = 4;int num2 = 5;//parse int to String

    System.out.println((num1+"").compareTo(num2+""));//-1

    System.out.println(new Integer(num1).toString(). compareTo(new Integer(num2).toString()));//-1

    System.out.println(String.valueOf(num1).compareTo(String.valueOf(num2)));//-1

    6.compareToIgnoreCase忽略大小写

    不考虑大小写,按字典顺序比较两个字符串。此方法返回一个整数,它的正负号是调用 compareTo 的正负号,调用时使用了字符串的规范化版本,其大小写差异已通过对每个字符调用 Character.toLowerCase(Character.toUpperCase(character)) 得以消除。

    注意,此方法不 考虑语言环境,因此可能在某些特定的语言环境中产生不理想的排序。java.text 包提供 Collators 来完成语言环境敏感的排序。

    7.int型可以直接比较,所以没有用到compareTo比较,如果声明的是Date、String、Integer、或者其他的,可以直接使用compareTo比较,

    Integer n1 = 5;

    Integer n2= 6;

    System.out.println(n1.compareTo(n2));//-1

    二. Comparable接口中的compareTo

    compareTo方法内必须做非空判断(规范问题),当然int类型就不用了。

    注意事项:

    1、模型必须实现Comparable接口

    2、Collection.sort(list)会自动调用compareTo,如果没有这句,list是不会排序的,也不会调用compareTo方法

    3、如果是数组则用Arrays.sort(a)方法

    注意要非空判断,这里实例就不判断了

    private intbookId;privateString bookName;private intbookPrice;

    @Overridepublic intcompareTo(Book o) {//TODO Auto-generated method stub//return this.bookPrice-o.bookPrice;//按价格排序 升序//return o.bookPrice-this.bookPrice;//按价格排序 降序//return this.bookName.compareTo(o.bookName);//按书名排序 升序//先按 id 再按价格 最后按书名排序 升序

    int result = this.bookId -o.bookId;if(result == 0){

    result=this.bookPrice -o.bookPrice;

    }if(result == 0){

    result= this.bookName.compareTo(o.bookName);

    }returnresult;

    }

    packagecom.my.test.compare;importjava.util.ArrayList;importjava.util.Arrays;importjava.util.Collections;importjava.util.List;public classTestCompare {public static voidmain(String[] args) {

    Book b1= new Book(1, "语文", 20);

    Book b2= new Book(2, "数学", 10);

    Book b3= new Book(5, "英语", 10);

    Book b4= new Book(4, "化学", 50);

    Book b5= new Book(3, "化学", 10);//Book b6 = null;//不能为null,Collections.sort调用compareTo会报空指针异常

    List books = new ArrayList<>();

    books.add(b1);

    books.add(b2);

    books.add(b3);

    books.add(b4);

    books.add(b5);

    System.out.println("Collections 排序前");for(Book book : books) {

    System.out.println(book);

    }

    Collections.sort(books);

    System.out.println("Collections 排序后");for(Book book : books) {

    System.out.println(book);

    }

    Book[] b= new Book[5];

    System.out.println(b.length);

    b[0] =b1;

    b[1] =b2;

    b[2] =b3;

    b[3] =b4;

    b[4] =b5;

    System.out.println("Arrays 排序前");for(Book book : b) {

    System.out.println(book);

    }

    Arrays.sort(b);

    System.out.println("Arrays 排序后");for(Book book : b) {

    System.out.println(book);

    }

    }

    }

    在应用中我们为了好判断状态,一般处理为

    if(this.bookId

    }else if(this.bookId>o.bookId){return 1;

    }else{return 0;

    }

    返回值为 1,0.-1:

    三。 Comparator接口

    源码:

    @FunctionalInterfacepublic interface Comparator{//核心方法,用来比较两个对象,如果o1小于o2,返回负数;等于o2,返回0;大于o2返回正数

    intcompare(T o1, T o2);//好像很少用到,一般都用对象自带的equals

    booleanequals(Object obj);/**-----------下面的都是JDK1.8新增的接口,挑几个放进去----------*/

    //返回反向排序比较器

    default Comparatorreversed() {return Collections.reverseOrder(this);

    }//根据名字知道,先进行compare比较后,再进行一次比较

    default Comparator thenComparing(Comparator super T>other) {

    Objects.requireNonNull(other);return (Comparator & Serializable) (c1, c2) ->{int res =compare(c1, c2);return (res != 0) ?res : other.compare(c1, c2);

    };

    }//对int类型的key进行比较

    public static Comparator comparingInt(ToIntFunction super T>keyExtractor) {

    Objects.requireNonNull(keyExtractor);return (Comparator &Serializable)

    (c1, c2)->Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));

    }//返回正常顺序的比较器

    public static > ComparatornaturalOrder() {return (Comparator) Comparators.NaturalOrderComparator.INSTANCE;

    }

    }

    一起来看一下如何使用,先来看一下JDK1.8以前的用法:

    Collections.sort(books,new Comparator() {

    @Overridepublic intcompare(Book o1, Book o2) {//TODO Auto-generated method stub

    return o1.getBookPrice() -o2.getBookPrice();

    }

    });

    或者创建一个比较器

    packagecom.my.test.compare;importjava.util.Comparator;public class SimpleCompator implements Comparator{

    @Overridepublic intcompare(Book o1, Book o2) {//TODO Auto-generated method stub

    return o1.getBookPrice() -o2.getBookPrice();

    }

    }

    Collections.sort(books,new SimpleCompator());

    JDK1.8以前的用法要自己手动实现Comparator接口,然后调用Collections.sort(),传入实现类来完成排序,非常麻烦,而JDK1.8则相对来说简单了很多:

    Collections.sort(books,(Book a, Book b) -> { return a.getBookPrice()-b.getBookPrice(); });

    或者可以简单的写为

    Collections.sort(books,(Book a, Book b) -> a.getBookPrice()-b.getBookPrice());

    甚至,我们可以不使用Collections.sort:

    books.sort((Book a, Book b) -> a.getBookPrice()-b.getBookPrice() );

    详见:http://www.manongjc.com/article/8005.html

    compator 在 treeMap 中的 应用(基于key的排序):

    treeMap默认的是基于key的从小到大 的排列

    自定义排序也是基于key的,如果key object类型 可以自定义各种排序

    TreeMap treeMap = new TreeMap<>((String a,String b)-> b.compareTo(a));//降序

    TreeMap treeMap = new TreeMap<>((String a,String b)-> a.compareTo(b));//升序

    TreeMap的按value排序(转换成entry list 然后排序)汉字是按ascii码排序的,不是汉语拼音

    Person p1 = new Person(1, "A小红");

    Person p2= new Person(5, "D赵明");

    Person p3= new Person(2, "W孙宇");

    Person p4= new Person(9, "C黎明");

    TreeMap treeMap = new TreeMap<>();

    treeMap.put("45", p1);

    treeMap.put("12", p2);

    treeMap.put("85", p3);

    treeMap.put("33", p4);

    List> entries = new ArrayList<>(treeMap.entrySet());

    Collections.sort(entries,

    (Map.Entry e1, Map.Entry e2) ->((Person) e1.getValue()).getPersonName()

    .compareTo(((Person) e2.getValue()).getPersonName()));

    System.out.println("按名字顺序排列");for (Entryentry : entries) {

    System.out.println(entry.getValue());

    }

    展开全文
  • java compareTo 方法 和 Comparator 接口

    千次阅读 2022-03-14 20:31:52
    compareTo 方法是接口 Comparable 的实现 返回值是整型,它是先比较对应字符的大小(ASCII码顺序),如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的长度差值,如果第一个字符和参数的第一个字符相等...
    1. compareTo 方法是接口 Comparable 的实现

    返回值是整型,它是先比较对应字符的大小(ASCII码顺序),如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的长度差值,如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方结束。

    • 如果参数字符串等于此字符串,则返回值 0;
    • 如果此字符串小于字符串参数,则返回一个小于 0 的值;
    • 如果此字符串大于字符串参数,则返回一个大于 0 的值。

    说明:

    如果第一个字符和参数的第一个字符不等,结束比较,返回第一个字符的ASCII码差值。

    如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至不等为止,返回该字符的ASCII码差值。 如果两个字符串不一样长,可对应字符又完全一样,则返回两个字符串的长度差值。

    Integer 和 String 实现了compareTo 方法

    实体对象实现方法

    package com.study.stream;
    
    import java.util.Objects;
    
    public class Person implements Comparable<Person>{
        private String name;
        private Integer age;
        private Integer height;
    
        public Person(String name, Integer age, Integer height) {
            this.name = name;
            this.age = age;
            this.height = height;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public Integer getHeight() {
            return height;
        }
    
        public void setHeight(Integer height) {
            this.height = height;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return name.equals(person.name) &&
                    age.equals(person.age);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    
        @Override
        public String toString() {
            return String.format("姓名:%s;年龄:%s;身高:%s;",this.name,this.age,this.height);
        }
    
    
        /**
         * Compares this object with the specified object for order.  Returns a
         * negative integer, zero, or a positive integer as this object is less
         * than, equal to, or greater than the specified object.
         *
         * <p>The implementor must ensure <tt>sgn(x.compareTo(y)) ==
         * -sgn(y.compareTo(x))</tt> for all <tt>x</tt> and <tt>y</tt>.  (This
         * implies that <tt>x.compareTo(y)</tt> must throw an exception iff
         * <tt>y.compareTo(x)</tt> throws an exception.)
         *
         * <p>The implementor must also ensure that the relation is transitive:
         * <tt>(x.compareTo(y)&gt;0 &amp;&amp; y.compareTo(z)&gt;0)</tt> implies
         * <tt>x.compareTo(z)&gt;0</tt>.
         *
         * <p>Finally, the implementor must ensure that <tt>x.compareTo(y)==0</tt>
         * implies that <tt>sgn(x.compareTo(z)) == sgn(y.compareTo(z))</tt>, for
         * all <tt>z</tt>.
         *
         * <p>It is strongly recommended, but <i>not</i> strictly required that
         * <tt>(x.compareTo(y)==0) == (x.equals(y))</tt>.  Generally speaking, any
         * class that implements the <tt>Comparable</tt> interface and violates
         * this condition should clearly indicate this fact.  The recommended
         * language is "Note: this class has a natural ordering that is
         * inconsistent with equals."
         *
         * <p>In the foregoing description, the notation
         * <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
         * <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
         * <tt>0</tt>, or <tt>1</tt> according to whether the value of
         * <i>expression</i> is negative, zero or positive.
         *
         * @param o the object to be compared.
         * @return a negative integer, zero, or a positive integer as this object
         * is less than, equal to, or greater than the specified object.
         * @throws NullPointerException if the specified object is null
         * @throws ClassCastException   if the specified object's type prevents it
         *                              from being compared to this object.
         */
        @Override
        public int compareTo(Person o) {
            return this.getAge().compareTo(o.getAge());
        }
    }
    

    实体对象排序:

    2.Comparator 接口

    Java提供了一个用于比较的接口Comparable,提供了一个比较的方法,所有实现该接口的类,都动态的实现了该比较方法。实际上Java中除了比较一个接口外,还提供了一个接口,该接口也是具有比较的功能,但该接口注重的却是比较容器,然后对其排序,这就是Comparator

    源码:

    package java.util;
     
    import java.io.Serializable;
    import java.util.function.Function;
    import java.util.function.ToIntFunction;
    import java.util.function.ToLongFunction;
    import java.util.function.ToDoubleFunction;
    import java.util.Comparators;
     
    @FunctionalInterface
    public interface Comparator<T> {
     
        int compare(T o1, T o2);
     
        boolean equals(Object obj);
     
     
        default Comparator<T> reversed() {
            return Collections.reverseOrder(this);
        }
     
        default Comparator<T> thenComparing(Comparator<? super T> other) {
            Objects.requireNonNull(other);
            return (Comparator<T> & Serializable) (c1, c2) -> {
                int res = compare(c1, c2);
                return (res != 0) ? res : other.compare(c1, c2);
            };
        }
     
        default <U> Comparator<T> thenComparing(
                Function<? super T, ? extends U> keyExtractor,
                Comparator<? super U> keyComparator)
        {
            return thenComparing(comparing(keyExtractor, keyComparator));
        }
     
        default <U extends Comparable<? super U>> Comparator<T> thenComparing(
                Function<? super T, ? extends U> keyExtractor)
        {
            return thenComparing(comparing(keyExtractor));
        }
     
        default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
            return thenComparing(comparingInt(keyExtractor));
        }
     
        default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
            return thenComparing(comparingLong(keyExtractor));
        }
     
        default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
            return thenComparing(comparingDouble(keyExtractor));
        }
        public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
            return Collections.reverseOrder();
        }
     
        @SuppressWarnings("unchecked")
        public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
            return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
        }
     
        public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
            return new Comparators.NullComparator<>(true, comparator);
        }
     
        public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
            return new Comparators.NullComparator<>(false, comparator);
        }
     
        public static <T, U> Comparator<T> comparing(
                Function<? super T, ? extends U> keyExtractor,
                Comparator<? super U> keyComparator)
        {
            Objects.requireNonNull(keyExtractor);
            Objects.requireNonNull(keyComparator);
            return (Comparator<T> & Serializable)
                (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                                  keyExtractor.apply(c2));
        }
     
        public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
                Function<? super T, ? extends U> keyExtractor)
        {
            Objects.requireNonNull(keyExtractor);
            return (Comparator<T> & Serializable)
                (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
        }
     
     
        public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
            Objects.requireNonNull(keyExtractor);
            return (Comparator<T> & Serializable)
                (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
        }
     
        public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
            Objects.requireNonNull(keyExtractor);
            return (Comparator<T> & Serializable)
                (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
        }
     
     
        public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
            Objects.requireNonNull(keyExtractor);
            return (Comparator<T> & Serializable)
                (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
        }
    }

    案例:

    List list; 代表某集合

    //返回 对象集合以类属性一升序排序

    list.stream().sorted(Comparator.comparing(类::属性一));

    //返回 对象集合以类属性一降序排序 注意两种写法

    list.stream().sorted(Comparator.comparing(类::属性一).reversed());

    //先以属性一升序,结果进行属性一降序

    list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));

    //以属性一降序

    //返回 对象集合以类属性一升序 属性二升序

    list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));

    //返回 对象集合以类属性一降序 属性二升序 注意两种写法

    list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));

    //先以属性一升序,升序结果进行属性一降序,再进行属性二升序

    list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));

    //先以属性一降序,再进行属性二升序

    //返回 对象集合以类属性一降序 属性二降序 注意两种写法

    list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));

    //先以属性一升序,升序结果进行属性一降序,再进行属性二降序

    list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));

    //先以属性一降序,再进行属性二降序

    //返回 对象集合以类属性一升序 属性二降序 注意两种写法

    list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());

    //先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序

    list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));

    //先以属性一升序,再进行属性二降序

    通过以上例子我们可以发现

    1. Comparator.comparing(类::属性一).reversed();

    2. Comparator.comparing(类::属性一,Comparator.reverseOrder());

    两种排序是完全不一样的,一定要区分开来 1 是得到排序结果后再排序,2是直接进行排序,很多人会混淆导致理解出错,2更好理解,建议使用

    代码:

    System.out.println("***************--sorted 定义排序规则 身高,年龄排序--***************************");
    personList.stream().sorted(Comparator.comparing(Person::getHeight,Comparator.naturalOrder()).thenComparing(Person::getAge,Comparator.naturalOrder())).forEach(System.out::println);
    

    展开全文
  • 我们在学习java基础的时候知道,基本数据类型...但是如果我们是对象数组的话,则对象所在的类必须实现comparable接口,覆写它的compareTo方法,并且要有不同的返回值,代表升序和降序。但是会有一个疑问:为什么对...
  • 重写CompareTo

    2021-09-18 17:00:34
    CompareTo( Object o ) compare默认被当前对象调用,比较属性时可以用this.调用,而这个参数 Object o 代表前一个对象。当向Set集合中新添加一个元素的时候,这个元素会和之前集合里面的所有元素进行比较,从而选择...
  • 不同的是, "foo".equals((String)null)返回false,而"foo".compareTo((String)null) == 0引发NullPointerException。 所以即使对于string,它们也不总是可以互换的。当比较平等时,你应该使用equals() ,因为它以一...
  • java compareTo方法增加中英文排序 默认排序(hash值排序) java代码 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class T { public static void main(String[] ...
  • Comparable接口和compareTo()函数

    千次阅读 多人点赞 2019-07-24 14:16:57
    Comparable接口和compareTo()函数 Comparable Comparable可以认为是一个内比较器,实现了Comparable接口的类有一个特点,就是这些类是可以和自己比较的,至于具体和另一个实现了Comparable接口的类如何比较,则依赖...
  • 以及依赖于该接口的集合实现(Collection implementation)进行协作"比如:字母排序,按数字排序,年代排序等等某种**定制排序**Comparable接口public interface Comparable{int compareTo(T t);}int compar...
  • java compareto 排序

    2021-03-08 06:17:13
    Java笔试题 将集合中的学生信息按照学生的年龄升序排列_计算机软件及应用_IT/计算机_专业资料。... // 如果学制相同则返回按年龄排序 if(j==0){ return arg0.getCCC().compareTo(arg1.getCCC()); } r...
  • java中compareTo比较两个日期大小我们对两个日期进行比较的时候,或者是日期的string进行比较的时候,以前我一直以为,如果大于的话compareTo的返回值应该是1,等于的话是0,小于的话是-1,网上很多也是这样说,但是...
  • obj1.compareTo(obj2):如果该方法返回0,则表示两个对象相等,如果该方法返回一个正整数,则表明obj1大于obj2;如果该方法返回一个负整数,则表明obj1小于obj2。 当compare(a,b)方法返回值大于0(为true)时,交换o1...
  • compareTo方法 public int compareTo(ChronoLocalDateTime<?> other) { if (other instanceof LocalDateTime) { return compareTo0((LocalDateTime) other); } return ChronoLocalDateTime.super.compareTo(other);...
  • compareTo()方法

    2022-03-19 14:37:22
    compareTo()方法详解
  • Java compareTo() 方法

    2021-02-25 20:13:05
    看下 compareTo 的源码:/**如果参数字符串等于此字符串,则返回值 0;*如果此字符串按字典顺序小于字符串参数,则*返回一个小于 0 的值;*如果此字符串按字典顺序大于字符串参数,则返回一个大于 0 的值。*/public ...
  • compareTo比较大小

    千次阅读 2021-12-06 10:39:37
    public class TestInteger { public static void main(String[] args) { //比较大小 Integer i1=new Integer(3); Integer i2=new Integer(5); System.out.println(i1.compareTo(i2));...compareTo()..
  • 比较金额大小compareTo

    2022-03-16 11:35:38
    金额类BigDecimal常用的比较大小方法compareTo 代码示例: public static void main(String[] args) { String orderAmt = "12.30"; String payAmt = "12.3"; BigDecimal bigDecimal = new BigDecimal...
  • 会自动调用compareTo()方法,对集合进行排序。 一般步骤: 要排序的类要实现Comparable<?>接口,然后重写compareTo()方法;最后再调用sort(Collection)方法。 代码: public class CollectionTest1 ...
  • CompareTo的比较原理: 先读取出字符串的第一个“字母”进行比较,比较的方法是ascii码表的值(字符所对应的十进制值),如果前面的大那么返回1,后面的大返回-1;此位置相同,继续比较下一位,直到最后一位,如果都...
  • 重写compareTo方法

    2021-08-16 18:44:33
    public int compareTo(Object o) { if(!(o instanceof Student)) { throw new ClassCastException("集合中的对象不是指定类型"); } Student s=(Student)o; if(this.age>s.age) { return 1; }else if(th.....
  • compareTo()用法

    2021-09-13 15:05:09
    compareTo() 方法用于将 Number 对象与方法的参数进行比较。可用于比较 Byte, Long, Integer等。该方法用于两个相同数据类型的比较,两个不同类型的数据不能用此方法来比较。 语法 public int compareTo( ...
  • ==、Equals、CompareTo、Compare
  • // 返回类信息字符串 } public int compareTo(Object obj) {// Comparable接口中的方法 Book b = (Book) obj; return this.id - b.id; // 按书的id比较大小,用于默认排序 } public static void main(String[] args...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 204,495
精华内容 81,798
关键字:

compareto

友情链接: I2C.zip