精华内容
下载资源
问答
  • Comparator接口实现排序

    万次阅读 多人点赞 2017-12-22 11:21:38
    对任意类型集合对象进行整体排序排序时将此接口实现传递给Collections.sort方法或者Arrays.sort方法排序. 实现int compare(T o1, T o2);方法,返回正数,零,负数各代表大于,等于,小于。单一条件排序:举例: ...
    Interface Comparator<T>
    

    对任意类型集合对象进行整体排序,排序时将此接口的实现传递给Collections.sort方法或者Arrays.sort方法排序.
    实现int compare(T o1, T o2)方法。

    单一条件排序:

    举例:

    		List<Student> stus = new ArrayList<Student>(){
    			{
    				add(new Student("张三", 30));	
    				add(new Student("李四", 20));	
    				add(new Student("王五", 60));	
    			}
    		};
    		// 1.对学生集合按年龄进行排序
    		Collections.sort(stus, new Comparator<Student>() {
    
    			@Override
    			public int compare(Student s1, Student s2) {
    				// 升序
    				//return s1.getAge()-s2.getAge();
    				return s1.getAge().compareTo(s2.getAge());
    				// 降序
    				// return s2.getAge()-s1.getAge();
    				// return s2.getAge().compareTo(s1.getAge());
    			}
    		});
    		
    		// 2.对学生集合按姓名首字母排序
    		Comparator comparator = Collator.getInstance(Locale.CHINA);
    		Collections.sort(stus, new Comparator<Student>() {
    		
    			@Override
    			public int compare(Student s1, Student s2) {
    				return comparator.compare(s1.getName(), s2.getName());
    			}
    		
    		});
    		
    		// 输出结果
    		...
    		
    

    注: 还可以使用lambda表达式简化代码, 前提是JDK8开发环境, 如下:

    		List<Student> stus = new ArrayList<Student>(){
    			{
    				add(new Student("张三", 30));	
    				add(new Student("李四", 20));	
    				add(new Student("王五", 60));	
    			}
    		};
    		//对学生集合按年龄进行排序
    		Collections.sort(stus, (s1,s2)->(s1.getAge()-s2.getAge()));
    

    lambda表达式是JDK8新特性之一, 允许你通过表达式来代替功能接口; 细节请自行百度… 我也是刚接触, 啊哈哈, 不熟悉,谅解谅解

    多条件排序:

    举例:

    		List<Student> stus = new ArrayList<Student>(){
    			{
    				add(new Student("张三", 30, 1));	
    				add(new Student("李四", 20, 2));	
    				add(new Student("王五", 40, 3));	
    				add(new Student("赵六", 30, 4));	
    				add(new Student("陈七", 40, 5));	
    				add(new Student("周八", 20, 6));	
    			}
    		};
    		Collections.sort(stus,new Comparator<Student>() {
    
    			@Override
    			public int compare(Student s1, Student s2) {
    				int flag;
    				// 首选按年龄升序排序
    				flag = s1.getAge()-s2.getAge();
    				if(flag==0){
    					// 再按学号升序排序
    					flag = s1.getNum()-s2.getNum();
    				}
    				return flag;
    			}
    		});
    		
    		System.out.println("年龄       学号       姓名  ");
    		for(Student s : stus){
    			System.out.println(s.getAge()+"   "+s.getNum()+"   "+s.getName());
    		}
    

    输出结果:
    这里写图片描述

    自定义条件排序

    		String[] order = {"语文","数学","英语","物理","化学","生物","政治","历史","地理","总分"};
    		final List<String> definedOrder = Arrays.asList(order);
    		List<String> list = new ArrayList<String>(){
    			{
    				add("总分");
    				add("英语");
    				add("政治");
    				add("总分");
    				add("数学");
    			}
    		};
    		Collections.sort(list,new Comparator<String>() {
    
    			@Override
    			public int compare(String o1, String o2) {
    				int io1 = definedOrder .indexOf(o1);
    				int io2 = definedOrder .indexOf(o2);
    				return io1-io2;
    			}
    		});
    		
    		for(String s:list){
    			System.out.print(s+"   ");
    		}
    

    使用lambda表达式简化代码:

    Collections.sort(list, (o1, o2)->(definedOrder .indexOf(o1)-definedOrder .indexOf(o2)));
    

    输出结果:
    这里写图片描述

    展开全文
  • 1. 常见的内部类有String,Integer,Date都是实现了java.lang包下的Comparable接口,重写其中的compareTo()方法。 例如:String类中重写compareTo()方法首先按照取两个字符串的公共长度进行挨个比较,按照字符...

    Comaparable接口

    ---内置类

    1.  常见的内部类有String,Integer,Date都是实现了java.lang包下的Comparable接口,重写其中的compareTo()方法。

    例如:String类中重写compareTo()方法首先按照取两个字符串的公共长度进行挨个比较,按照字符顺序返回比较结果,若公共长度下两个字符串一样,则返回长度差

    比较结果:

    整数:大于

    负数:小于

    0:相等

    2,那么对于Arrays类的sort方法(对于数组的排序)和Collections的sorts方法(对于容器的排序),就取决于数组和容器中的元素类型来调用各自类的compareTo()方法,实现排序。

     

    ---自定义类

    那么对于自定义的排序我们同样实现了java lang包下的Comparable接口,重写其中的compareTo()方法。

    比如对于一些新闻条目进行时间,标题,点击量的排序,我们就可以自己实现

    import java.text.SimpleDateFormat;
    import java.util.Date;
    public class NewsItem implements Comparable<NewsItem>{
    private String title;
    private int hits;
    private Date pubTime;
    public NewsItem(){

    }
    public NewsItem(String title, int hits, Date pubTime) {
    super();
    this.title = title;
    this.hits = hits;
    this.pubTime = pubTime.;
    }

    /*加上setter和getter方法*/

          @Override
    public int compareTo(NewsItem o) {                 //重写compareTo方法,实现自己的比较规则
    int result=0;
    //时间降序,分别调用各自类型的comapreTo()方法
    result=-this.pubTime.compareTo(o.pubTime);  在sort排序是默认是升序,我们要降序所以在前面加负号

    if(result==0){

    result=this.hits-o.hits;    //点击量升序
    if(result==0){
    result=-this.title.compareTo(o.title);  //标题降序
    }
    }
    return result;

    }

    /**为了后面方面我们重写toString方法

    *注意在打印的时候,系统会自动调用toString()方法

    */

    @Override
    public String toString() {
    StringBuilder sb=new StringBuilder();
    sb.append("标题:").append(this.title);
    sb.append(" 点击量是:").append(this.hits);

    sb.append(“日期是”).

                    append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.pubTime)).

                    sb.append(" 点击量是:").append(this.hits).append('\n');

    return sb.toString();
    }

    }

    那后续对内容是NewsItem的数组或是列表,我们在调用sort()方法时,就会按照我们自己定义的排序规则进行排序。

    Comparator接口

    ---内置类

    首先Comparator是位于java.util下的接口,我们可以称之为比较类

    那比如有一个问题,当你想只通过字符串的长度比较两个字符串,那你调用String类自己的compareTo()方法显然是做不到的,这个时候我们就可以借助Comparator接口,实现接口中的compare方法。如下:

    public class StringComp implements Comparator<String>{
    /**
    * 按照长度比较
    */
    @Override
    public int compare(String o1, String o2) {
    int len1=o1.length();
    int len2=o2.length();
    return len1-len2;
    }
    }

    那比如我们有一个字符串列表

    List<String> list=new ArrayList();
    list.add("adc");
    list.add("a");
    list.add("abcd");
    list.add("adesc");
    list.add("de");

    我们通过Collections.sort(list,new StringComp())就可以实现按照长度对字符串进行排序

     

    ---自定义类

    如上所述,我们的自定义类都有自己的比较规则,那比如淘宝货物我们会点积按照价格排序,或者按照收藏排序也就是排序规则是独立的,这个时候我们用Comparable接口是实现不了的,解决方法是为每个排序规则实现比较类。

    首先我们定义货物类:

    //不实现任何接口的类
    public class Goods {
    //商品名称
    private String name;
    //商品价格
    private double price;
    //销量
    private int fav;
    public Goods(String name, double price, int fav) {
    super();
    this.name = name;
    this.price = price;
    this.fav = fav;
    }
    /*加上构造方法和setter,getter方法*/
    @Override
    public String toString() {
    return "Goods name=" + name + ", price=" + price + ", fav=" + fav+"\n";
    }

    }

    那我们先为价格的排序规则实现业务类实现Comparator类,重写compare方法:

    //按照价格排序:降序
    public class GoodsPriceComp implements java.util.Comparator<Goods>{
    @Override
    public int compare(Goods o1, Goods o2) {
    // TODO Auto-generated method stub
    return -(o1.getPrice()-o2.getPrice()>0?1:(o1.getPrice()-o2.getPrice()<0?-1:0));
    }

    }

    使用:

    public class GoodsApp {
    public static void main(String args[]){
    List<Goods> goods =new ArrayList();
    goods.add(new Goods("短袖",100,2000));
    goods.add(new Goods("大衣",400,158));
    goods.add(new Goods("短裤",150,1000));
    Collections.sort(goods, new GoodsPriceComp());
    System.out.print(goods);

    }

    }

    结果:

    [Goods name=大衣, price=400.0, fav=158
    , Goods name=短裤, price=150.0, fav=1000
    , Goods name=短袖, price=100.0, fav=2000
    ]

    那同理我们也可以为商品名称和销量各自实现排序类,这样与实体类分开,也可以方便修改排序规则,各个排序规则也清楚明白。

     

    展开全文
  • 主要介绍了JAVA使用Comparator接口实现自定义排序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JAVA 使用Comparator接口实现自定义排序 1、原则 Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法: int compare(Object o1, Object o2) 返回一个基本类型的整型 ...

    JAVA 使用Comparator接口实现自定义排序

    1、原则

    Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法:
    int compare(Object o1, Object o2) 返回一个基本类型的整型
    如果要按照升序排序,则o1 小于o2,返回-1(负数),相等返回0,01大于02返回1(正数)
    如果要按照降序排序,则o1 小于o2,返回1(正数),相等返回0,01大于02返回-1(负数)

     1 import java.util.ArrayList;
     2 import java.util.Comparator;
     3 import java.util.List;
     4 
     5 public class UserComparator implements Comparator < User > {
     6 
     7     public static void main( String[] args ) {
     8         List < User > users = new ArrayList < User >();
     9         users.add( new User( 10, "a" ) );
    10         users.add( new User( 11, "d" ) );
    11         users.add( new User( 15, "s" ) );
    12         users.add( new User( 6, "x" ) );
    13         users.add( new User( 17, "a" ) );
    14         users.add( new User( 17, "b" ) );
    15         users.add( new User( 17, "c" ) );
    16         users.add( new User( 17, "d" ) );
    17         UserComparator comparator = new UserComparator();
    18 
    19         users.sort( comparator );
    20         // 也可以使用:Collections.sort( users, comparator );
    21 
    22         for ( User u : users ) {
    23             System.out.println( u );
    24         }
    25     }
    26 
    27     @Override
    28     public int compare( User u1, User u2 ) {
    29         if ( u1.equals( u2 ) ) {
    30             return 0;
    31         }
    32         else if ( u1.getAge() < u2.getAge() ) {
    33             return 1;
    34         }
    35         else if ( u1.getAge() == u2.getAge() ) {
    36             int f = u1.getName().compareTo( u2.getName() );
    37             if ( f < 0 ) {
    38                 return -1;
    39             }
    40             return 0;
    41         }
    42         else {
    43             return -1;
    44         }
    45     }
    46 }
    47 
    48 class User {
    49     private int age;
    50     private String name;
    51 
    52     public User() {
    53 
    54     }
    55 
    56     public User( int age, String name ) {
    57         this.age = age;
    58         this.name = name;
    59     }
    60 
    61     public int getAge() {
    62         return age;
    63     }
    64 
    65     public void setAge( int age ) {
    66         this.age = age;
    67     }
    68 
    69     public String getName() {
    70         return name;
    71     }
    72 
    73     public void setName( String name ) {
    74         this.name = name;
    75     }
    76 
    77     @Override
    78     public String toString() {
    79         return "User [age=" + age + ", name=" + name + "]";
    80     }
    81 
    82 }
    User [age=17, name=a]
    User [age=17, name=b]
    User [age=17, name=c]
    User [age=17, name=d]
    User [age=15, name=s]
    User [age=11, name=d]
    User [age=10, name=a]
    User [age=6, name=x]

     

    posted @ 2018-10-19 14:34 孟阳miss 阅读( ...) 评论( ...) 编辑 收藏
    展开全文
  • 2、使用Comparator接口规则:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法。升序是前者减去后者,降序是后者减去前者。 3、代码测试:同时也是牛客网中某题。 题目描述: 搜狐...

    1、为节点排序。节点由3个字段组成,包括num ,weight ,height 。先按照weight升序排序,再按照height降序排序。

    2、使用Comparator接口规则:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法。升序是前者减去后者,降序是后者减去前者。

    3、代码测试:同时也是牛客网中某题。

    题目描述:

    搜狐员工小王最近利用假期在外地旅游,在某个小镇碰到一个马戏团表演,精彩的表演结束后发现团长正和大伙在帐篷前激烈讨论,小王打听了下了解到, 马戏团正打算出一个新节目“最高罗汉塔”,即马戏团员叠罗汉表演。考虑到安全因素,要求叠罗汉过程中,站在某个人肩上的人应该既比自己矮又比自己瘦,或相等。 团长想要本次节目中的罗汉塔叠的最高,由于人数众多,正在头疼如何安排人员的问题。小王觉得这个问题很简单,于是统计了参与最高罗汉塔表演的所有团员的身高体重,并且很快找到叠最高罗汉塔的人员序列。 现在你手上也拿到了这样一份身高体重表,请找出可以叠出的最高罗汉塔的高度,这份表中马戏团员依次编号为1到N。

    输入描述:

    首先一个正整数N,表示人员个数。 
    之后N行,每行三个数,分别对应马戏团员编号,体重和身高。

    输出描述:

    正整数m,表示罗汉塔的高度。
    示例1

    输入

    6
    1 65 100
    2 75 80
    3 80 100
    4 60 95
    5 82 101
    6 81 70
    

    输出

    4

    ac代码:dp部分参考了其他人思想,因为自己对dp一直不太熟悉,这次ide写了一遍,手写了好几遍去实现整个过程,总算是明白了。心累....

    package schooloffer;
    
    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Scanner;
    
    /**
     * Created by caoxiaohong on 17/9/22.
     * 搜狐员工小王最近利用假期在外地旅游,在某个小镇碰到一个马戏团表演,精彩的表演结束后发现团长正和大伙在帐篷前激烈讨论,....
     * 动态规划,用到了最长上升子序列问题。首先按照体重从小到大排序,体重相同时,身高高的在上,然后求最长身高上升子序列的长度。
     * 要求:叠罗汉过程中,站在某个人肩上的人应该既比自己矮又比自己瘦,或相等。
     */
    public class CircusTroup {
        static class People{
            int num;
            int weight;
            int height;
            public People(int num,int weight,int height){
                this.num=num;
                this.weight=weight;
                this.height=height;
            }
        }
        public static void main(String[] args) {
            Scanner scanner=new Scanner(System.in);
            int N;
            while (scanner.hasNext()){
                N=scanner.nextInt();
                String inValid=scanner.nextLine();//无效
                People[]  peoples=new People[N];
                for(int i=0;i<N;i++){
                    String[] str=scanner.nextLine().split(" ");
                    peoples[i]=new People(Integer.valueOf(str[0]),Integer.valueOf(str[1]),Integer.valueOf(str[2]));
                }
                //第一处:注意地方
                //先按照体重升序,再按照身高降序
                //为什么身高要降序?因为:体重相同时,只有身高也相同才可以站在自己肩上,比自己矮是不能站在自己肩上的。
                //而身高降序就保证了:体重相同时,身高不同为降序,不是升序序列,则不能站在自己肩上.
                Arrays.sort(peoples, new Comparator<People>() {
                    @Override
                    public int compare(People o1, People o2) {
                        if(o1.weight==o2.weight){
                            return o2.height-o1.height;
                        }else{
                            return o1.weight-o2.weight;
                        }
                    }
                });
    
                //第二处:注意地方 db部分开始
                //按身高求最大升序子序列,不是太会 
                int[] dp=new int[N];
                dp[0]=1;
                int level=0;
                for(int i=1;i<N;i++){
                    dp[i]=1;
                    for(int j=0;j<i;j++){//通过这里的代码,可以知道:子序列并不需要连续,只要满足if条件就可以
                        if(peoples[j].height<=peoples[i].height && dp[j]+1>dp[i])
                            dp[i]=dp[j]+1;
                    }
                }
                Arrays.sort(dp);
                level=dp[N-1];
                System.out.println(level);
            }
        }
    }
    




    展开全文
  • Java中有两个用来实现排序的接口Comparator和Comparable接口,本人比较喜欢使用java的Comparator接口,在程序里实现Comparator接口里的compare(Object o1,Object o2)方法,然后在程序中通过调用Arrays.s
  • 使用Comparator接口:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法。 题目描述: 从A、B、C、D、E5个方面对每一家酒店进行评价收集,并给出1-5星的评分(整数),排序规则如下...
  • 前言:排序算法是我们初学程序时常用的算法,每个人都尝试过排序,但只是局限于基本数据类型的简单排序。比如:将下列数字进行排序1,3,5,8,3,6,于是我们得出结果1,3,3,5,6,8。将下列字母(字符)进行排序...
  • Collections.sort(result,new Comparator(){ @Override public int compare(Object arg0, Object arg1){ Struct a = (Struct) arg0; Struct b = (Struct) arg1; if ( a.getNu
  • 通过Comparator接口实现比较

    千次阅读 2016-07-11 19:42:55
    通过Comparator接口实现比较
  • 使用Comparator比较接口实现排序 Comparator是比较接口,当我们需要对某个类进行排序而此类本身没有时Comparable时,我们可以建立一个该类的比较器来实现Comparator接口即可实现排序。 Comparator接口定义如下 ...
  • java jdk 排序
  • 使用Comparable、Comparator接口实现对对象数组、List集合的自定义排序
  • 最开始我是构造了一个学生类,存放学生信息,实现Comparator接口,遗憾的是,后台测试时,每一个测试用例皆显示程序运行超时。 public class Main ... class Student ... class StuCompare implements ...
  • 上一章简单介绍了Comparable 接口Comparator 接口实现(十一),如果没有看过,请观看上一章 一. Collator 类 字符串的比较 可以用 compareTo() 的方法,这个方法重写了 comparable 接口的compareTo() 的方法,采用...
  • map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简单介绍): HashMap:我们最常用的Map,它根据key的HashCode 值来存储数据,根据key可以直接...
  • import java.util.ArrayList; import java.util.Collections;...import java.util.Comparator; import java.util.List; /** * 容器排序 * @author 26920 * */ public class TestList { ...
  • 在日常写程序时,或做笔试题时总会遇到自己定义的类或者数据结构,如果把自己定义的类存入List这样的数组中,排序是很麻烦的,比如: 下面定义了一个Person类 class Person{ String name; int age; public Person...
  • Comparator接口实现List<Map<String, Object>>排序 List<Map<String, Object>> list = new ArrayList<Map<String, Object>>(); Collections.sort(list, new Comparator<...
  • 目录 对自定义的类排序:...利用comparator接口实现排序的方法步骤: 步骤1.//比较器实现类--实现Comparator接口和compare方法 步骤2.利用Collection.sort方法传入步骤1中比较器类对象 对自定义的类排...
  • TreeMap利用Comparator接口排序

    千次阅读 2016-07-15 09:32:31
    /*TreeMap利用Comparator接口排序 需求:对学生对象的年龄进行升序排序。 因为数据是以键值对形式存在的。 所以要使用可以排序的Map集合。TreeMap */ import java.util.*; class StuNameComparator implements ...
  • java的比较器有两类,分别是Comparable接口和Comparator接口。Comparable是排序接口,若一个类实现了Comparable接口,就意味着 该类支持排序实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort...
  • 实现comparator接口,进行排序

    千次阅读 2017-03-15 13:38:56
    项目中,常常需要排序,可能根据各种条件排序,这里记录一种,根据json数据中成人价格和成人税费的总和按照从小打到的顺序排列。贴上代码,应该很好懂。 @RequestMapping("/sortJson") @ResponseBody public List...
  • JAVA Comparator 接口排序用法

    千次阅读 2015-03-16 09:36:12
    java的比较器有两类,分别是Comparable接口和Comparator接口。 在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。 让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T ...
  • 针对Comparator接口实现类进行总结

    万次阅读 2021-01-21 21:35:18
    在做数组排成最小的数算法题时,对重写比较器进行了研究,现在进行总结。 ...&tqId=11185&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/...小根堆排序 https://leetcode-cn.com/problem
  • 背景:当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码(比如JDK当中的类), 或者实现了java.lang.Comparable接口排序规则不适合当前的操作,那 么可以考虑使用 Comparator 的对象来排序,强行对...
  • 若一个类实现了Comparable接口,就意味着“该类支持排序”。 实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素, 而不需要指定比较器。 Comparable 定义 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,942
精华内容 24,376
关键字:

comparator接口实现排序