精华内容
下载资源
问答
  • java的Comparator和Comparable
  • java的Comparator和Comparable  当需要排序的集合或数组不是单纯的数字型时,通常可以使用Comparator或Comparable,以简单的方式实现对象排序或自定义排序。   一、Comparator  强行对某个对象collection进行...

    java的Comparator和Comparable 
    当需要排序的集合或数组不是单纯的数字型时,通常可以使用Comparator或Comparable,以简单的方式实现对象排序或自定义排序。 
         一、Comparator 
    强行对某个对象collection进行整体排序的比较函数,可以将Comparator传递给Collections.sort或Arrays.sort。 
    接口方法: 
      /** 
       * @return o1小于、等于或大于o2,分别返回负整数、零或正整数。 
       */ 
      int compare(Object o1, Object o2); 
    案例: 
    import java.util.Arrays; 
    import java.util.Comparator; 
    public class SampleComparator implements Comparator<String> { 
      public int compare(String o1, String o2) { 
        return toInt(o1) - toInt(o2); 
      } 
      private int toInt(String str) { 
        str = str.replaceAll("一", "1"); 
        str = str.replaceAll("二", "2"); 
        str = str.replaceAll("三", "3"); 
       
        return Integer.parseInt(str); 
      } 
      /** 
       * 测试方法 
       */ 
      public static void main(String[] args) { 
        String[] array = new String[] { "一二", "三", "二" }; 
        Arrays.sort(array, new SampleComparator()); 
        for (int i = 0; i < array.length; i++) { 
          System.out.println(array[i]); 
        } 
      } 

          二、Comparable 
    强行对实现它的每个类的对象进行整体排序,实现此接口的对象列表(和数组)可以通过Collections.sort或Arrays.sort进行自动排序。 
    接口方法: 
      /** 
       * @return 该对象小于、等于或大于指定对象o,分别返回负整数、零或正整数。 
       */ 
      int compareTo(Object o); 
    假设对象User,需要按年龄排序: 
    public class User { 
      private String id; 
      private int age; 
      public User(String id, int age) { 
        this.id = id; 
        this.age = age; 
      } 
      public int getAge() { 
        return age; 
      } 
      public void setAge(int age) { 
        this.age = age; 
      } 
      public String getId() { 
        return id; 
      } 
      public void setId(String id) { 
        this.id = id; 
      } 

    改造后的对象: 
    import java.util.Arrays; 
    public class User implements Comparable<User> { 
      private String id; 
      private int age; 
      public User(String id, int age) { 
        this.id = id; 
        this.age = age; 
      } 
      public int getAge() { 
        return age; 
      } 
      public void setAge(int age) { 
        this.age = age; 
      } 
      public String getId() { 
        return id; 
      } 
      public void setId(String id) { 
        this.id = id; 
      } 
      public int compareTo(User u) { 
        return this.age - u.getAge(); 
      } 
      /** 
       * 测试方法 
       */ 
      public static void main(String[] args) { 
        User[] users = new User[] { new User("a", 30), new User("b", 20) }; 
        Arrays.sort(users); 
        for (int i = 0; i < users.length; i++) { 
          User user = users[i]; 
          System.out.println(user.getId() + " " + user.getAge()); 
        } 
      } 

          三、Comparator和Comparable的区别 
      先看一下使用Comparator对User集合实现排序的方式:一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的,这个类对象组成的集合就可以直接使用sort方法排序。 
    Comparator可以看成一种算法的实现,将算法和数据分离,Comparator也可以在下面两种环境下使用: 
    1、类的设计师没有考虑到比较问题而没有实现Comparable,可以通过Comparator来实现排序而不必改变对象本身 
    2、可以使用多种排序标准,比如升序、降序等 
    在TreeSet和TreeMap中添加的自定义对象必须实现Comparable接口

    ------------------------------------------------------------

    关于引用数据类型的排序(自然排序和客户化排序):
    1.对象本身实现Comparable接口,那么该类的实例就是可以排序的(实现其comparTo()方法).

    只要实现了Comparable接口,就可以调用Collections的sort方法对集合中的元素排序.

    2.实现Comparator接口的一个实例也可以实现排序功能.

    看一下Comparator的全部内容:
    public interface Comparator {
      int compare(Object o1, Object o2);
      boolean equals(Object obj);
    }
    定义了两个方法,我们一般都只需要实现compare方法。

    为什么呢?
    因为所有自定义类默认extends Object,而Object中已经将equals()实现
    Comparator一般都作为一个匿名类出现,对于没有实现Comparable的对象的集合,排序的时候
    需要指定一个Comparator.

    这里举例说明
    对于实现了Comparable的类(自然排序)我们就用最简单的Integer
    List list=new ArrayList();
    list.add(new Integer(3));
    list.add(new Integer(53));
    list.add(new Integer(34));
    Collections.sort(list);

    对于没有实现Comparable的,我们就用Object,按照hashCode大小来排序.
    List list= new ArrayList();
    list.add(new Object());
    list.add(new Object());
    list.add(new Object());
    Collections.sort(list,new Comparator(){ public int compare(Object o1, Object o2){
                        return (o1.hashCode()-o2.hashCode());
                    })

    这里定义了一个排序规则,以匿名类的形式出现,当然你也可以定义一个自定义的类实现Comparator,
    这样这个“排序规则”就能得以保存。
    那Comparable 和 Comparator 接口有什么区别呢?
    “白话文”的解释:用自定义类实现Comparable接口,那么这个类就具有排序功能,Comparable和具体你要进行排序的类的实例邦定。而Comparator比较灵活,它没有和任何类绑定,实现它的自定义类仅仅定义了一种排序方式或排序规则。不言而喻,这种方式比较灵活。我们的要排序的类可以分别和多个实现Comparator接口的类绑定,从而达到可以按自己的意愿实现按多种方式排序的目的。Comparable——“静态绑定排序”,Comparator——“动态绑定排序”。

    转载:http://zhengweisincere.blog.163.com/blog/static/4984464920112149312408/

    展开全文
  • java的Comparator接口详解

    万次阅读 2019-07-01 13:52:43
    实际上Java中除了比较一个接口外,还提供了一个接口,该接口也是具有比较功能,但该接口注重却是比较容器,然后对其排序,这就是Comparator,下面我们就来具体认识一下; 首先看一下源码: package java.util...

    前面我们讲过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));
        }
    }
    

     

    我们设计类的时候,可能没有考虑到让类实现Comparable接口,那么就需要用到另外的一个比较器接口Comparator。

    从之前的实例我们可以发现,compareTo(T o)只有一个参数,而Comparator接口中必须要实现的compare(T o1,T o2)就有两个参数。

    例如:

    class StudentComparator implements Comparator<Student>{  
      
        @Override  
        public int compare(Student o1, Student o2) {  
            // TODO Auto-generated method stub  
            if(o1.getScore()>o2.getScore())  
                return -1;  
            else if(o1.getScore()<o2.getScore())  
                return 1;  
            else{  
                if(o1.getAge()>o2.getAge())  
                    return 1;  
                else if(o1.getAge()<o2.getAge())  
                    return -1;  
                else   
                    return 0;  
            }  
        }  
          
    }  
      
      
    public class ComparableDemo02 {  
        public static void main(String[] args) {  
            // TODO Auto-generated method stub  
      
            Student stu[]={new Student("zhangsan",20,90.0f),  
                    new Student("lisi",22,90.0f),  
                    new Student("wangwu",20,99.0f),  
                    new Student("sunliu",22,100.0f)};  
            java.util.Arrays.sort(stu,new StudentComparator());  
            for(Student s:stu)  
            {  
                System.out.println(s);  
            }  
        } 

    上面依然是对student对象数组进行排序,用的都是Array.sort方法,不同的是实现comparator接口时,sort方法需要传进来两个参数,即stu对象数组,以及重写的实现了comparator比较方法类。

    我们这里只是简单了解了Comparator的方法

    展开全文
  • java的Comparator接口如何对指定类型进行排序。 实例代码如下: import java.util.Arrays; import java.util.Comparator; 方法如下: Arrays.sort(resps, new Comparator() { @Override public int ...

    java的Comparator接口如何对指定类型进行排序。

    实例代码如下:

    import java.util.Arrays;
    import java.util.Comparator;


    方法如下:

    Arrays.sort(resps, new Comparator<ChartRequest>() {
    @Override
    public int compare(ChartRequest o1, ChartRequest o2) {
    return o2.getTotal() - o1.getTotal();    //自定义比较两个ChartRequest类的对象的大小(顺序)的比较规则。
    }
    });


    ChartRequest 类如下:

    public class ChartRequest implements Serializable {
    private static final long serialVersionUID = 1976139290649977049L;

    private int total;

    public int getTotal() {
    return total;
    }
    public void setTotal(int total) {
    this.total = total;
    }

    }

    展开全文
  • Java的Comparator顺序

    2016-03-10 21:51:47
    序 本文主要记录comparator的返回值与排序关系。 实例 //order by time asc if(CollectionTool.isNotEmpty(commentVos)){ Collections.sort(commentVos,new Comparator<...
        

    本文主要记录comparator的返回值与排序的关系。

    实例

    //order by time asc
                if(CollectionTool.isNotEmpty(commentVos)){
                    Collections.sort(commentVos,new Comparator<CommentVo>(){
                        @Override
                        public int compare(CommentVo o1, CommentVo o2) {
                            return o1.getTime().compareTo(o2.getTime());
                        }
                    });
                }

    说明

    返回-1,表示o1排在o2前面,asc
    返回1,表示o1排在o2后面,desc

    展开全文
  • Comparator 接口产生背景是排序 默认 compareTo 方法是比较 字符码值...如果我们需要实现比较字符长度比较排序:在 Arrays.sort(数组对象,一个实现了Comparator的比较器): 这个比较器一般这么写: ...
  • 在使用Java自带排序函数时,往往需要根据自己需求自定义比较器。以前一直对Comparator的升序降序疑惑。现在记录一下,加深下印象。 先给结论: 实现Comparator接口,必须实现下面这个函数: @Override public ...
  • Java 的Comparator比较器用法

    千次阅读 2019-09-03 21:20:45
    1.定义:Comparator是外部比较器,用于比较来对象与对象之间,两个对象进行比较,多用于集合排序,而Comparable可以认为是一个内比较器,根据对象某一属性进行排序 2.使用方法 1)定义节点信息 class Node{ ...
  • list,Comparator<? super T> c);方法 例如有如下集合: List<Map<String, Object>> list = new ArrayList<Map<String,Object>>(); 集合内值为: {name=zs, a...
  • Lambda表达式结构:( ) -> { }; 注意: Lambda要求实现接口中只有一个方法; 简化:当方法体只有一个语句时候,{}可以省略;另外,return关键字也被省略了,原因是编译器会认为,既然只有一个语句,那么这个...
  • Comparator接口中有两个方法 compare和equals 实践中,equals方法不实现也不会报错 关于这个问题,java核心技术I有相关答案,原文如下: (为了便于理解,建议加两个字:难道)...(java API中一些接口会重新声明...
  • Java的Comparator和Comparable对比

    千次阅读 2014-12-04 20:53:22
    Java的基本类型如int, float, double都可以直接使用java.util.Arrays.sort(Object[])对比排序,那对象是如何比较排序的呢?我们定义的类都是继承Object类的,Object类的equals的方法,默认是比较两个对象是否相等...
  • interface Comparator: 强行对某个对象Collection进行整体排序...还可以使用Comparator来控制某些数据结构顺序,或者为那些没有自然排序对象collection提供排序。 方法:compare(T t1,T t2) 比较用来排序两个
  • 当需要排序集合或数组不是单纯数字型时,通常可以使用Comparator或Comparable,以简单方式实现对象排序或自定义排序。 一、Comparator强行对某个对象collection进行整体排序比较函数,可以将Comparator传递...
  • 使用Comparator接口:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中compare()方法。 题目描述: 从A、B、C、D、E5个方面对每一家酒店进行评价收集,并给出1-5星评分(整数),排序规则如下...
  • javaComparator的用法

    万次阅读 多人点赞 2017-02-15 00:50:52
    comparator 是javase中接口,位于java.util包下,javase中所有接口抽象度都很高,有必要重视 2. 网上太多文章告诉大家comparator是用来排序;确实,可以用来排序,但不仅限于排序 3. 工作中实际需求出现很...
  • 主要给大家介绍了关于Java 8 Comparator: 列表排序相关资料,文中通过示例代码介绍非常详细,对大家学习或者使用Java8具有一定参考学习价值,需要朋友们下面来一起学习学习吧
  • Java8 Comparator

    2017-11-01 15:18:12
    java8 Comparator比较器使用 //下面做一个排序例子,来讲解Collection中sort List names = Arrays.asList("zhangsan", "lisi", "wangwu"); /*Collections.sort(names, new Comparator(){ @Override
  • javaComparator的用法

    2014-06-17 11:09:44
    javaComparator的用法 在java中,如果要对集合对象或数组对象进行排序,需要实现Comparator接口以达到我们想要目标。   接下来我们模拟下在集合对象中对日期属性进行排序 一、实体类Step package ...
  • JavaComparator的用法

    千次阅读 2017-02-22 21:52:05
    Java中,如果要对集合对象或数组对象进行排序,需要实现Comparator接口以达到我们想要目标。
  • 再谈Java8 Comparator

    2021-01-21 19:05:20
    之前在Java8 Comparator技巧谈过通过Java8中Comparator提供了一些方法,我们可以很容易构造出自定义的Comparator。 在一些常见的排序操作中非常实用,当时我以为我对Java8的Comparator那绝对是无死角的了解了,直到...
  • Java8 Comparator的深入学习

    万次阅读 2017-11-03 09:56:08
    package com.lgx.jdk8.part02; import java.util.*; import java.util.stream.Collectors; /** * Comparator比较器使用 */ public class Test12Comparator { public static void main(String[] args) {
  • JAVAcomparator的使用

    万次阅读 2018-06-30 16:28:39
    Collections.sort(list,new Comparator&lt;Integer&gt;(){ public int compare(Integer str1,Integer str2){ String s1=str1+""+str2; String s2=str2+""+str1; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,332
精华内容 3,332
关键字:

java的comparator

java 订阅