精华内容
下载资源
问答
  • Comparator接口

    2020-04-14 11:26:36
    Comparator接口 今天来给大家介绍下java.utils包下的Comparator接口。该接口代表一个比较器,java数组工具类和集合工具类中提供对sort方法排序就是使用 Comparator接口来处理排序的。 Comparator接口中有一个方法int...

    Comparator接口

    今天来给大家介绍下java.utils包下的Comparator接口。该接口代表一个比较器,java数组工具类和集合工具类中提供对sort方法排序就是使用 Comparator接口来处理排序的。

    Comparator接口中有一个方法int compare(T o1, T o2)。这个方法返回值是int类型,如果返回值小于0,说明比较结果是o1<o2,如果返回值等于0,说明比较结果是o1=o2,如果返回值大于0,则说明比较结果是o1>o2。

    既然是接口,那么我们就可以实现它,来自定义其中对比较规则,即可实现在一个List列表中将元素按照某个属性进行排序。

    下面我们用代码举例说明,如下:

    package com.java.utils.Comparator;
     
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
     
    /**
    * 类说明:
    *	比较器Comparator接口的应用
    */
    public class ComparatorTest {
    	
    	/**
    	 * 实体对象类 
    	 */
    	static class User {
    		String name;
    		int age;
    		public User(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;
    		}
    		
    	}
    	
    	/**
    	 * 自定义比较器
    	 * 根据名称比较
    	 */
    	static class MyComparatorName implements Comparator<User>{
    		@Override
    		public int compare(User u1, User u2) {
    			return u1.getName().compareTo(u2.getName()) * -1;
    		}
    	}
    	
    	/**
    	 * 自定义比较器
    	 * 根据年龄比较
    	 */
    	static class MyComparatorAge implements Comparator<User>{
    		@Override
    		public int compare(User u1, User u2) {
    			return (u1.getAge() - u2.getAge());
    		}
    	}
    	
    	//测试
    	public static void main(String[] args) {
    		List<User> list =new ArrayList<User>();
    		User u1 = new User("a", 2);
    		User u2 = new User("d", 0);
    		User u3 = new User("c", 3);
    		list.add(u1);
    		list.add(u2);
    		list.add(u3);
    		
    		Collections.sort(list, new MyComparatorName());
    		for(User u :list){
    			System.out.println(u.getName());
    		}
    		
    		Collections.sort(list, new MyComparatorAge());
    		for(User u :list){
    			System.out.println(u.getAge());
    		}
    	}
    	
    }
    

    在上面对例子中,我们首先按照名称从大到小进行排序,输出结果是d、c、a然后又按照年龄从小到大进行排序,输出结果是0、2、3。

    需要注意的是,Collections.sort方法默认是按照返回结果从小到大进行排序,如果我们需要从大到小则在实现比较器大时候将返回结果乘以-1即可。

    是不是很简单?如果是我们自己实现比较器,那么我们就可以根据实际的业务需求去实现排序。

    展开全文
  • comparator接口

    2021-04-08 11:45:44
    PriorityQueue<ListNode> queue = new PriorityQueue<>(new Comparator<>(){ public int compare(ListNode l1,ListNode l2){ return l1.val - l2.val; } });
    PriorityQueue<ListNode> queue = new PriorityQueue<>(new Comparator<>(){
    			@Override
                public int compare(ListNode l1,ListNode l2){
                    return l1.val - l2.val;
                }
            });
    
    Arrays.sort(arr,new Comparator<>(){
                @Override
                public int compare(String a, String b){
                    return (b+a).compareTo(a+b);
                }
            });
    
    //不能使用基本数据类型
            Integer[] arr = {5,4,7,9,2,12,54,21,1};
            //降序
            Arrays.sort(arr, new Comparator<Integer>() {
            		//重写compare方法,最好加注解,不加也没事
                public int compare(Integer a, Integer b) {
                  	//返回值>0交换
                    return b-a;
                }
            });
    
    
    展开全文
  • JAVA Comparator接口Comparator接口

    千次阅读 2019-04-18 17:17:36
    java的比较器有两类,分别是Comparable接口和Comparator接口。 在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。 让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法...

    java的比较器有两类,分别是Comparable接口Comparator接口
    1、继承Comparable接口,并实现compareTo()方法;
    2、定义一个单独的对象比较器,继承自Comparator接口,实现compare()方法。

    在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。

    让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法,在其中定义排序规则,那么就可以直接调用java.util.Arrays.sort()来排序对象数组,实例如下:

    class Student implements Comparable<Student>{  
        private String name;  
        private int age;  
        private float score;  
          
        public Student(String name, int age, float score) {  
            this.name = name;  
            this.age = age;  
            this.score = score;  
        }  
          
        public String toString()  
        {  
            return name+"\t\t"+age+"\t\t"+score;  
        }  
      
        @Override  
        public int compareTo(Student o) {  
            // TODO Auto-generated method stub  
            if(this.score>o.score)//score是private的,为什么能够直接调用,这是因为在Student类内部  
                return -1;//由高到底排序  
            else if(this.score<o.score)  
                return 1;  
            else{  
                if(this.age>o.age)  
                    return 1;//由底到高排序  
                else if(this.age<o.age)  
                    return -1;  
                else  
                    return 0;  
            }  
        }  
    }  
      
    public class ComparableDemo01 {  
      
        /** 
         * @param args 
         */  
        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);  
            for(Student s:stu)  
            {  
                System.out.println(s);  
            }  
        }  
    }  
    

    在上面的程序中,实现了Comparable接口,并重写了compareTo方法,将学生先按成绩由大到小排名,成绩相同时候按照年龄由低到高排序。

    执行的结果是

    sunliu 22 100.0
    wangwu 20 99.0
    zhangsan 20 90.0
    lisi 22 90.0

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

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

    package edu.sjtu.ist.comutil;  
      
    import java.util.Comparator;  
      
    class Student {  
        private String name;  
        private int age;  
        private float score;  
          
        public Student(String name, int age, float score) {  
            this.name = name;  
            this.age = age;  
            this.score = score;  
        }  
      
        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;  
        }  
        public float getScore() {  
            return score;  
        }  
        public void setScore(float score) {  
            this.score = score;  
        }  
      
        public String toString()  
        {  
            return name+"\t\t"+age+"\t\t"+score;  
        }  
      
    }  
      
    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 {  
      
        /** 
         * @param args 
         */  
        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);  
            }  
        }  
      
    }  
    
    展开全文
  • Comparator接口位于:java.util包中。 Comparator接口:1. 强行对某个对象的Collection进行整体排序。值得注意的是:Comparator接口可以作为参数传到一些sort()方法中,例如:Collection.sort(List<T> list, ...

    Comparator接口位于:java.util包中。

    Comparator接口:
    1. 强行对某个对象的Collection进行整体排序。
    值得注意的是:
    Comparator接口可以作为参数传到一些sort()方法中,例如:
    Collection.sort(List<T> list, Comparator<? super T> c)、
    Arrays.sort(T[] a, Comparator<? super T> c);

    2. Comparator接口指定的顺序,可以不是字典顺序排序,但包含字典顺序排序!!!

    现在让我们仍然对User进行排序吧!!!
    Let's do it!!!

    3. 有的人会觉得 实现Comparator接口 有点奇怪,Comparator接口中明明有两个方法: compare()、equals()
    为什么实现此接口的类只用实现compare()方法呢?
    其实稍加思索,就明白了:实现Comparator接口的类没有实现equals方法,是因为类里有equals()方法了,
    所有的类都是从基类java.lang.Object中继承的,而Object类中已经有equals()方法了,
    故而在你创建完成这个类,就已经实现了equals()方法了,是不是恍然大悟呢?!!!

     

    User类的代码如下:

    package test;
    
    public class User {
    
    	private String name;
    	private Integer age;
    	
    	public User(String name, Integer age) {
    		this.name = name;
    		this.age = age;
    	}
    
    	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;
    	}
    
    	@Override
    	public String toString() {
    		return "User [name=" + name + ", age=" + age + "]";
    	}
    
    }
    

      看下实现Comparator接口的类UserComparator的代码:

    package test;
    
    import java.util.Comparator;
    
    public class UserComparator implements Comparator<User>{
    
    	@Override
    	public int compare(User o1, User o2) {
    		int flag = o1.getName().compareTo(o2.getName());
    		if(flag == 0) {
    			flag = o1.getAge().compareTo(o1.getAge());
    		}
    		return flag;
    	}
    
    }
    

      接着我们要进行测试了哈!UserTest.java的代码如下:

    package test;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;
    
    public class UserTest {
    	
    	public static void print(List<User> list) {
    		for(User u : list) {
    			System.out.println(u);
    		}
    	}
    	
    	public static void print(User[] array) {
    		for(int i=0; i<array.length; i++) {
    			System.out.println(array[i]);
    		}
    	}
    	
    	public static void main(String[] args) {
    		
    		List<User> users = new ArrayList<User>();
    		users.add(new User("a",12));
    		users.add(new User("C",25));
    		users.add(new User("B",12));
    		users.add(new User("A",15));
    		users.add(new User("b",19));
    		users.add(new User("c",17));
    		users.add(new User("a",22));
    		
    		User[] users2 = new User[]{
    				new User("a",12),
    				new User("C",25),
    				new User("B",12),
    				new User("A",15),
    				new User("b",19),
    				new User("c",17),
    				new User("a",22)
    		};
    		System.out.println("=========================Comparator接口的测试=========================");
    		System.out.println("List排序前:");
    		print(users);
    		
    		System.out.println();
    		System.out.println();
    		
    		System.out.println("List排序后:");
    		Collections.sort(users, new UserComparator());
    		print(users);
    		
    		System.out.println("--------------------------------------------");
    		System.out.println();
    		System.out.println();
    		System.out.println();
    		System.out.println();
    		
    		
    		System.out.println("Array排序前:");
    		print(users2);
    		
    		System.out.println();
    		System.out.println();
    		
    		System.out.println("Array排序后:");
    		Arrays.sort(users2, new UserComparator());
    		print(users2);
    		
    	}
    
    }
    

      测试的结果如下:

    =========================Comparator接口的测试=========================
    List排序前:
    User [name=a, age=12]
    User [name=C, age=25]
    User [name=B, age=12]
    User [name=A, age=15]
    User [name=b, age=19]
    User [name=c, age=17]
    User [name=a, age=22]
    
    
    List排序后:
    User [name=A, age=15]
    User [name=B, age=12]
    User [name=C, age=25]
    User [name=a, age=12]
    User [name=a, age=22]
    User [name=b, age=19]
    User [name=c, age=17]
    --------------------------------------------
    
    
    
    
    Array排序前:
    User [name=a, age=12]
    User [name=C, age=25]
    User [name=B, age=12]
    User [name=A, age=15]
    User [name=b, age=19]
    User [name=c, age=17]
    User [name=a, age=22]
    
    
    Array排序后:
    User [name=A, age=15]
    User [name=B, age=12]
    User [name=C, age=25]
    User [name=a, age=12]
    User [name=a, age=22]
    User [name=b, age=19]
    User [name=c, age=17]
    

    以上是按照字典顺序进行排序,今天想着实现一个字典顺序的倒序排序,大家一起来讨论下吧!!

    下面是UserComparator2的代码:

    package test;
    
    import java.util.Comparator;
    
    public class UserComparator2 implements Comparator<User>{
    
    	@Override
    	public int compare(User o1, User o2) {
    		int flag = 0;
    		flag = sort(o1.getName(), o2.getName());
    		if(flag == 0) {
    			flag = o1.getAge().compareTo(o2.getAge());
    		}
    		return flag;
    	}
    	
    	/*
    	 * 字典顺序的倒序排序,z是第一个,A是最后一个, 
    	 * 如果A<B,返回1
    	 * 	  A=B,返回0
    	 * 	  A>B,返回-1	
    	 */
    	public int sort(String s1, String s2) {
    		int flag = 0;
    		//获取s1、s2的字符序列
    		char[] c1 = s1.toCharArray();
    		char[] c2 = s2.toCharArray();
    		//设置循环的次数,取字符串长度小的
    		int length1 = s1.length();
    		int length2 = s2.length();
    		int longer = c1.length - c2.length;
    		int count = longer>=0 ? length2 : length1;
    		
    		for(int i=0; i<count; i++) {
    			//取出每个字符串上对应的字符,进行比较
    			char charS1 = c1[i];
    			char charS2 = c2[i];
    			
    			int result = charS1 - charS2;
    			if(result < 0) {
    				flag = 1;
    				break;
    			}else if(result > 0) {
    				flag = -1;
    				break;
    			}else {
    				flag = 0;
    			}
    		}
    		
    		//如果是这种情况:jim、jime,则jime排在前
    		if(flag == 0) {
    			if(longer < 0) {
    				//长度长的排前面
    				flag = 1;
    			}else if(longer > 0) {
    				flag = -1;
    			}else {
    				flag = 0;
    			}
    		}
    		
    		return flag;
    	}
    	
    
    }
    

      然后,让我们开始进行测试吧:

    package test;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class UserTest2 {
    	
    	public static void print(List<User> list) {
    		for(User u : list) {
    			System.out.println(u);
    		}
    	}
    	
    	public static void main(String[] args) {
    		List<User> users = new ArrayList<User>();
    		users.add(new User("jim",12));
    		users.add(new User("joe",25));
    		users.add(new User("jime",12));
    		users.add(new User("tom",15));
    		users.add(new User("tom",17));
    		users.add(new User("andy",19));
    		users.add(new User("cwayi",17));
    		users.add(new User("zendy",22));
    		users.add(new User("yorick",33));
    		users.add(new User("maomi",22));
    		
    		
    		System.out.println("=========================Comparator接口的测试=========================");
    		System.out.println("List排序前:");
    		print(users);
    		
    		System.out.println();
    		System.out.println();
    		
    		System.out.println("List排序后:");
    		Collections.sort(users, new UserComparator2());
    		print(users);
    		
    		System.out.println("--------------------------------------------");
    	}
    	/*
    	 * 预想的结果应该是:
    	 * 	zendy--22
    	 *  yorick--33
    	 *  tom--15
    	 *  tom--17
    	 *  maomi--22
    	 *  joe--25
    	 *  jime--12
    	 *  jim--12
    	 *  cwayi--17
    	 *  andy--19
    	 */
    	
    }
    

      程序运行的结果如下:

    =========================Comparator接口的测试=========================
    List排序前:
    User [name=jim, age=12]
    User [name=joe, age=25]
    User [name=jime, age=12]
    User [name=tom, age=15]
    User [name=tom, age=17]
    User [name=andy, age=19]
    User [name=cwayi, age=17]
    User [name=zendy, age=22]
    User [name=yorick, age=33]
    User [name=maomi, age=22]
    
    
    List排序后:
    User [name=zendy, age=22]
    User [name=yorick, age=33]
    User [name=tom, age=15]
    User [name=tom, age=17]
    User [name=maomi, age=22]
    User [name=joe, age=25]
    User [name=jime, age=12]
    User [name=jim, age=12]
    User [name=cwayi, age=17]
    User [name=andy, age=19]
    --------------------------------------------
    

      是不是很有意思呢?!以上就是Comparator接口的学习了,快来一起学习吧!

    转载于:https://www.cnblogs.com/yorickLi/p/5950559.html

    展开全文
  • Comparator比较器接口,重写compare方法; Comparable接口接口只有一个方法 public int compareTo(T obj); 其中,T是泛型,需要指定具体的对象类型 接口中通过 x.compareTo(y)来比较x和y的大小 x<y,...
  • comparator接口与Comparable接口的区别
  • Comparable接口和Comparator接口介绍 文章目录Comparable接口和Comparator接口介绍前言一、使用示例内比较器外比较器二、使用步骤1.引入库2.读入数据总结 前言 Comparable接口位于 java.lang包下,Comparator接口...
  • 一、comparator接口 1、list的比较 2、数组的比较 二、Comparable接口 Java提供了一个用于比较的接口Comparator和Comparable接口,提供了一个比较的方法,所有实现该接口的类,都动态的实现了该比较方法。 一、...
  • Comparable和Comparator接口简介 Comparable接口和Comparator接口的作用 : 用于给实现类规范比较(排序)的方法. 首先看两个接口的代码: Comparable接口 public interface Comparable<T> { public int ...
  • comparable 接口comparator 接口实现比较的区别和用法 1.定义 Comparable 接口:使用 Array 或 Collection 的排序方法时,自定义类需要实现 Java 提供 Comparable 接口的 compareTo(TOBJ)方法,它被排序方法所...
  • 文章目录Comparable接口Comparator接口小结 Comparable接口 定义:Comparable位于包java.lang下,Comparable接口将比较代码嵌入自身类中。此接口能够通过实现comparaTo方法来达到对它的类对象进行排序的功能。实现了...
  • 本文要来详细分析一下Java中Comparable和Comparator接口的区别,两者都有比较的功能,那么究竟有什么区别呢,感兴趣的Java开发者继续看下去吧
  • Comparable接口和Comparator接口的区别 Comparable接口位于java.lang包下;Comparator位于java.util包下 Comparable接口只提供了一个compareTo()方法;Comparator接口不仅提供了compara()方法,还提供了其他默认...
  • 一、实现Compare接口与Comparator接口的类,都是为了对象实例数组排序的方便,因为可以直接调用 java.util.Arrays.sort(对象数组名称),可以自定义排序规则。不同之处: 1 排序规则实现的方法不同 Comparable接口...
  • Comparable和Comparator接口的区别
  • 1 Comparator接口 1.1 Comparable的局限 1.2 Comparator的引入 2 Comparator和Comparable的区别 2.1 概述 2.2 举例 2.2.1 Comparable方式 2.2.2 Comparator方式 1 Comparator接口 1.1 Comparable的局限 举例说明: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,472
精华内容 2,588
关键字:

comparator接口