精华内容
下载资源
问答
  • Java自定义排序

    千次阅读 2019-07-20 19:56:29
    Java自定义排序可以通过实现Comparator接口或Comparable接口来完成。 关键:实现Comparator接口的关键在于重写compare()方法,Comparable接口的关键在于重写compareTo()方法。JDK中大部分的类都实现了Comparable...

    Java中自定义排序可以通过实现Comparator接口或Comparable接口来完成。
    关键:实现Comparator接口的关键在于重写compare()方法,Comparable接口的关键在于重写compareTo()方法。JDK中大部分的类都实现了Comparable接口,拥有compareTo方法。如Integer,String等。但是对于自己定义类,如果需要自定义排序,则要实现Comparable接口并重写compareTo()方法,若不重写就进行自定义排序,会报错。
    方法:将实现好的接口作为参数传入Arrays.sort()中或Collections.sort()中即可。


    上述两个静态方法都可以进行排序,简单区别:
    1.Arrays.sort()方法可以对原始类型(基本数据类型)和对象类型进行排序,而Collections.sort()只能对List进行排序。
    2.查看源码发现,Collections.sort()也是通过Arrays.sort()方法实现的


    Comparator具体使用方法:

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class CustomSort {
    	public static void main(String args[]){
    		Integer numbers1[] = {32, 3, 321};
    		List<Integer> list1 = Arrays.asList(numbers1);
    		//注意list1中元素类型必须是对象类型,写原始类型会报错
    		Collections.sort(list1, new MyComparator2());
    		for (Integer integer : list1) {
    			System.out.print(integer+" ");
    		}
    		
    		System.out.println("\n---------------");
    		
    		//使用arrays.sort()方法自定义排序
    		Integer numbers2[] = {1,51,6,1,465,496,-156};
    		Arrays.sort(numbers2, new MyComparator2());
    		for (Integer integer : numbers2) {
    			System.out.print(integer+" ");
    		}
    		
    		System.out.println("\n*************************");
    		
    		Student2 st1 = new Student2(123, "Bob");
    		Student2 st2 = new Student2(122, "Bob");
    		Student2 st3 = new Student2(124, "Allen");
    		//使用collections.sort()方法
    		List<Student2> list3 = new ArrayList<>();
    		list3.add(st1);list3.add(st2);list3.add(st3);
    		Collections.sort(list3, new MyComparator2());
    		for (Student2 student : list3) {
    			System.out.print(student);
    		}
    
    		System.out.println("\n---------------");
    		
    		Student2 ss1[] = {st1, st2, st3};
    		//使用Arrays.sort()方法
    		Arrays.sort(ss1, new MyComparator2());
    		for (Student2 student : ss1) {
    			System.out.print(student);
    		}
    	}
    }
    class MyComparator2 implements Comparator<Object>{
    	@Override
    	public int compare(Object o1, Object o2){
    		//如果两个都是整数才调用该比较方法
    		if(o1 instanceof Integer && o2 instanceof Integer){
    			Integer i1 = (Integer) o1;
    			Integer i2 = (Integer) o2;
    			return -i1.compareTo(i2);
    		}
    		//如果两个都是student2类型
    		if(o1 instanceof Student2 && o2 instanceof Student2){
    			Student2 s1 = (Student2)o1;
    			Student2 s2 = (Student2)o2;
    			//先按名字字典序排序,再按学号升序排序
    			int t = s1.getName().compareTo(s2.getName());
    			if(t == 0){
    				return s1.getId().compareTo(s2.getId());
    			}else return t;
    		}
    		return 0;
    	}
    }
    //自定义一个学生类,然后对学生进行排序
    class Student2{
    	Integer id;
    	String name;
    	
    	public Student2(Integer id, String name) {
    		super();
    		this.id = id;
    		this.name = name;
    	}
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "[id=" + id + ", name=" + name + "] ";
    	}
    }
    

    运行结果:

    321 32 3 
    ---------------
    496 465 51 6 1 1 -156 
    *************************
    [id=124, name=Allen] [id=122, name=Bob] [id=123, name=Bob] 
    ---------------
    [id=124, name=Allen] [id=122, name=Bob] [id=123, name=Bob] 
    

    Comparable具体使用方法:

    public class TestComparable {
    	public static void main(String args[]){
    		Student3 st1 = new Student3(123, "Bob");
    		Student3 st2 = new Student3(122, "Bob");
    		Student3 st3 = new Student3(124, "Allen");
    		//使用Collections.sort()方法进行排序
    		List<Student3> list1 = new ArrayList<>();
    		list1.add(st1);list1.add(st2);list1.add(st3);
    		Collections.sort(list1);
    		for (Student3 student : list1) {
    			System.out.print(student);
    		}
    		
    		System.out.println("\n-------------");
    		
    		//使用Arrays.sort()方法进行排序
    		Student3 s[] = {st1, st2, st3};
    		Arrays.sort(s);
    		for (Student3 student : s) {
    			System.out.print(student);
    		}
    	}
    }
    //实现Comparable接口
    class Student3 implements Comparable<Student3>{
    	Integer id;
    	String name;
    	
    	public Student3(Integer id, String name) {
    		super();
    		this.id = id;
    		this.name = name;
    	}
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "[id=" + id + ", name=" + name + "] ";
    	}
    	//重写compareTo方法,自定义排序规则
    	@Override
    	public int compareTo(Student3 stu){
    		//先按名字字典序排序,再按学号升序排序
    		int t = this.name.compareTo(stu.name);
    		if(t == 0){
    			return this.id.compareTo(stu.id);
    		}else return t; 
    	}
    }
    

    运行结果:

    [id=124, name=Allen] [id=122, name=Bob] [id=123, name=Bob] 
    -------------
    [id=124, name=Allen] [id=122, name=Bob] [id=123, name=Bob] 
    

    弄懂Java中排序的一些使用方法后,手是不是有点痒。试试下面这个题目吧。
    题目出处参考《剑指offer》:把数组排成最小的数
    题目描述
       输入一个正整数数组,把数组里所有数字拼接起来排成一个数,打印能拼接出的所有数字中最小的一个。
    例如输入数组{3,32,321},则打印出这三个数字能排成的最小数字为321323。

    输入描述
       多组输入
    每组测试样例第一行为n,表示数组有n个整数,接下来一行n个整数

    输入描述
       每组输入输出一行,整个数组排成的最小的数字
    sample input
       5
    6 2 87 15 2
    3
    3 32 321

    sample output
       1522687
    321323

    source
       《剑指offer》:把数组排成最小的数

        起初可能会没有思路,但是仔细想想过后,你会发现这是一道排序题,通过自定义排序规则就可以做到排出来的数字最小。
    思路:假设两个数m和n,试考虑m和n应该怎么排列才能使得m和n拼接的数字最小?这个应该很好办,无非就是两种拼接方式都试一遍,比较一下mn和nm的大小即可。这样一来,两个数扩展到n个数也是一样的。我们只需要两两进行拼接进行比较,知道最后全部比完,这也就相当于一个排序。
        当mn < nm时,我们想要的是mn这种拼接方式,所以m应该排在n前面。而当mn = nm时,无论哪种方式都可以。同理当mn > nm时,我们定义n排在m前面。
        那么问题来了,怎么进行拼接?很直观的可以想到两个数值拼接起来,但是这样是有可能溢出的。所以我们采用字符串拼接,把数字看成字符串,然后进行比较。下面代码中调用的是String自带的compareTo方法(按照字典序)。
    示例代码:

    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Scanner;
    
    public class OfferSort {
    	public static void main(String args[]){
    		Scanner sc = new Scanner(System.in);
    		int n;
    		
    		while(sc.hasNext()){
    			n = sc.nextInt();
    			//输入
    			int arr[] = new int[n];
    			for(int i = 0; i < n; i++)
    				arr[i] = sc.nextInt();
    			
    			//转化为字符串
    			String s[] = new String[arr.length];
    			for(int i = 0; i < arr.length; i++)
    				s[i] = String.valueOf(arr[i]);
    			
    			//按照自定义的规则排序
    			Arrays.sort(s, new MyComparator5());
    			//组装答案并输出
    			String ans = "";
    			for (String str : s) 
    				ans += str;
    			System.out.println(ans);
    		}
    	}
    }
    class MyComparator5 implements Comparator<Object>{
    	@Override
    	public int compare(Object o1, Object o2){
    		if(o1 instanceof String && o2 instanceof String){
    			String s1 = (String)o1;
    			String s2 = (String)o2;
    			String s3 = s1+s2;
    			String s4 = s2+s1;
    			int t = s3.compareTo(s4);
    			if(t > 0)//若s3>s4,即s1s2 > s2s1,所以我们s2排在s1的前面
    				return 1;
    			else if(t < 0)//s3<s4, 所以s1应该排在s2前面
    				return -1;
    			else return 0;
    		}
    		return 0;
    	}
    }
    
    展开全文
  • Java自定义排序多种方式三种方式在创建时写Comparator 定制排序compare接口重写 compareTo 方法 三种方式 在创建时写 第一次见,记录一下,之后两种是正常写法,改变排序也方便改,这个适合leetcode TreeMap<...


    摘录自 参考文章

    四种写法 两种方式

    传入匿名内部类

    第一次见,记录一下,最后两种是正常写法以及方式,改变排序也方便改,这个适合leetcode

     TreeMap<Person, String> treeMap = new TreeMap<>(new Comparator<Person>() {
                @Override
                public int compare(Person person1, Person person2) {
                    int num = person1.getAge() - person2.getAge();
                    return Integer.compare(num, 0);
                }
            });
    

    Lamda表达式

    上面的简化版

    TreeMap<Person, String> treeMap = new TreeMap<>((person1, person2) -> {
      int num = person1.getAge() - person2.getAge();
      return Integer.compare(num, 0);
    });
    

    Comparator 定制排序

    java.util

    Collections.sort(arrayList, new Comparator<Integer>() {
    
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1.compareTo(o2);
                }
            });
    

    compare接口重写 compareTo 方法

    java.lang

    public  class Person implements Comparable<Person>{
    	@Override
        public int compareTo(Person o) {
            if (this.age > o.getAge()) {
                return 1;
            }
            if (this.age < o.getAge()) {
                return -1;
            }
            return 0;
        }
    }
    
    展开全文
  • 主要介绍了JAVA使用Comparator接口实现自定义排序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JAVA自定义排序

    2019-09-27 14:42:47
    import java.util.Arrays; //实现Comparable接口可以进行比较大小 public class People implements Comparable<People>{ private String name; private Integer age; public People(String name, ...
    import java.util.Arrays;
    
    //实现Comparable接口可以进行比较大小
    public class People implements Comparable<People>{
    
        private String name;
        private Integer age;
    
        public People(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "People{" +
                    "name='" + name + '\'' +
                    ", 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;
        }
    
        //实现Comparable接口 需要实现compareTo比较方法
        @Override
        public int compareTo(People o) {
            //当前对象this和o进行大小比较
            //返回值有三种情况
            //负数 this < o
            //0   this = o
            //正数 this > o
            //如果修改 比较结果 就可以实现 倒序排列 如 a>b 返回 -1
    
            if (this.age > o.getAge()){
                return 1;
            }else if (this.getAge() < o.getAge()){
                return -1;
            }else {
                return 0;
            }
    
            //同样可以实现
    //        return this.getAge() - o.getAge();
    //        return o.getAge() - this.getAge();
        }
    
    
        public static void main(String[] args) {
    
            People p1 = new People("zhangsna",20);
    
            People p2 = new People("lisi",30);
    
            //使用比较方法
            System.out.println(p1.compareTo(p2));
    
            //Java中所有的排序都依赖于compareTo 进行大小比较,并且都是升序
            //不能控制排序方式,但是可以控制比较结果
            //通过控制大小比较结果来影响排序结果
            //如将compareTo方法中的 -1 和 1 颠倒 就可以倒序排列
    
            People[] peoples = {p2,p1};//p1,p2位置不影响排序结果
    
            Arrays.sort(peoples);//对数组进行排序(默认升序 )
    
            for (People p : peoples){
                System.out.println(p);
                System.out.println("==========");
    
            }
        }
    }
    
    
    展开全文
  • Java使用Comparable接口自定义排序

    千次阅读 2017-04-19 21:01:01
    Java经典编程300例之实例063 使用Comparable接口自定义排序 案例见 实例说明 默认情况下,保存在List集合中的数组是不进行排序的,不过可以通过使用Comparable接口自定义排序规则并自动排序。本实例将介绍如何...

    Java经典编程300例之实例063 使用Comparable接口自定义排序

    案例见http://blog.csdn.net/the_star_is_at/article/details/70245219


    实例说明

    默认情况下,保存在List集合中的数组是不进行排序的,不过可以通过使用Comparable接口自定义排序规则并自动排序。本实例将介绍如何使用Comparable接口自定义排序规则并自动排序。

     

    实现过程

    新建一个Java类,名称为Employee。在该类中首先定义3个属性,分别是id(表示员工的编号)、name(表示员工的姓名)和age(表示员工的年龄),然后在构造方法中初始化这3个属性,最后再实现接口中定义的compareTo()方法,将对象按编号升序排列。

    Employee.java

    [java]  view plain  copy
    1. public class Employee implements Comparable<Employee> {  
    2.     private int id;  
    3.     private String name;  
    4.     private int age;  
    5.     public Employee(int id, String name, int age) { //利用构造方法初始化各个域  
    6.         this.id = id;  
    7.         this.name = name;  
    8.         this.age = age;  
    9.     }  
    10.     @Override  
    11.     public int compareTo(Employee o) {              //利用编号实现对象间的比较  
    12.         if (id > o.id) {  
    13.             return 1;  
    14.         } else if (id < o.id) {  
    15.             return -1;  
    16.         }  
    17.         return 0;  
    18.     }  
    19.     @Override  
    20.     public String toString() {                      //重写toString()方法  
    21.         StringBuilder sb = new StringBuilder();  
    22.         sb.append("员工的编号:" + id + ",");  
    23.         sb.append("员工的姓名:" + name + "\t,");  
    24.         sb.append("员工的年龄:" + age);  
    25.         return sb.toString();  
    26.     }  
    27. }  

    重写接口中的方法时,要将访问权限限定符设为public,因为接口中的方法默认就是public的。

     

    再新建一个名称为Test的类,用于进行测试。在该类中首先定义一个List集合来保存3Employee对象,并通过遍历输出集合中的元素,再通过Collections.sort()方法执行自动排序,最后再通过遍历输出排序后的集合中的元素。

    Test.java

    [java]  view plain  copy
    1. import java.util.ArrayList;  
    2. import java.util.Collections;  
    3. import java.util.List;  
    4.   
    5. public class Test {  
    6.     public static void main(String[] args) {  
    7.         List<Employee> list = new ArrayList<Employee>();  
    8.         list.add(new Employee(2"Java"20));  
    9.         list.add(new Employee(1"C"30));  
    10.         list.add(new Employee(3"C#"10));  
    11.         System.out.println("排序前");  
    12.         for (Employee employee : list) {  
    13.             System.out.println(employee);  
    14.         }  
    15.         System.out.println("排序后");  
    16.         Collections.sort(list);  
    17.         for (Employee employee : list) {  
    18.             System.out.println(employee);  
    19.         }  
    20.     }  
    21. }  

    编译运行

    $javac Employee.Java Test.java

    $java Test

    排序前

    员工的编号:2,员工的姓名:Java,员工的年龄:20

    员工的编号:1,员工的姓名:C,员工的年龄:30

    员工的编号:3,员工的姓名:C#,员工的年龄:10

    排序后

    员工的编号:1,员工的姓名:C,员工的年龄:30

    员工的编号:2,员工的姓名:Java,员工的年龄:20

    员工的编号:3,员工的姓名:C#,员工的年龄:10

     

    技术要点

    本实例主要一个月java.lang包中的Comparable接口来实现自定义排序规则。Comparable接口用于强行对实现它的每个类的对象进行整体排序,用于指定排序规则。Comparable接口的定义如下:

    publicinterface Comparable<T> {

       int compareTo(T o);

    }

    当需要对一个对象进行排序时,该对象应该实现Comparable接口,并实现其唯一的方法compareTo()。在该方法中定义自己的排序规则,当调用Arrays.sort(Object[]a)或Collectons.sort(List<T> list)方法时会回调compareTo()方法,并按照自己的规则对对象数组或列表进行排序。

    返回值及比较规则:

    1、返回负值---->小于

    2、返回零------>等于

    3、返回正值---->大于

     

    如果一个类要实现这个接口,可以使用如下语句声明:

    publicclass Employee implements Comparable<Employee> {}

     

    Employee中必须实现接口中定义的compareTo()方法。实现该方法后,如果将该对象保存在列表中,那么可以通过执行Collections.sort()方法进行自动排序;如果保存在数组中,那么可以通过执行Arrays.sort()方法进行自动排序。

     

    如果不想实现在接口中定义的方法,则可以将类声明为抽象类,将接口中定义的方法声明为抽象方法。


    展开全文
  • 除了利用数据库的sql语句排序还可以利用java的Comparable接口自定义排序。 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Employee implements Comparable&...
  • JAVA 使用Comparator接口实现自定义排序 1、原则 Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法: int compare(Object o1, Object o2) 返回一个基本类型的整型 ...
  • 下面小编就为大家带来一篇java中实现Comparable接口实现自定义排序的示例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Arrays.sort()方法可对任何实现compareble接口的对象数组排序。 源代码 EmployeeSortTest.java import java.util.*; /** * This program demonstrates the use of the Comparable interface. * @version 1.30...
  • 综上所述,学习一下排序接口来实现对复杂对象的排序还是很有必要的。Java中有两个用来实现排序的接口Comparator和Comparable接口,本人比较喜欢使用java的Comparator接口,在程序里实现Comparator接口里的compare...
  • Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在...
  • 2、使用Comparator接口规则:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法。升序是前者减去后者,降序是后者减去前者。 3、代码测试:同时也是牛客网中某题。 题目描述: 搜狐...
  • 排序的算法,大家都不陌生,有冒泡排序、选择排序、插入排序,快速排序等等。如果现在有学生类,学校添加了很多学生,要你给学生按照学号... 咱们java功能很强大,库里自带给数组排序的方法Arrays.sort(); 来看看...
  • java自定义对象实现排序

    千次阅读 2019-04-15 16:31:20
    对象排序有两种方法,自定义排序和实现Java中的比较器接口排序。 对自定义对象排序,我们可以根据自定义对象的数据结构,自定义排序规则来实现。也可以用Java中的两个常用的接口Comparable和Comparator,实现将...
  • java中Comparator自定义排序

    千次阅读 2018-07-30 21:58:18
    java中Comparator自定义排序: Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法: int compare(Object o1, Object o2) 返回一个基本类型的整型 如果要按照升序排序,则o1 小于o2,...
  • java 自定义对象排序

    2018-09-05 07:21:02
    方法一:对自定义对象 必需 要实现 Comparable 接口 并且重写里面 compareTo 方法 import java.util.Arrays; /** * 使用arrays对指定数据进行升序排序 * @author Administrator,,这里是调用处 *...
  • Java ArrayList自定义排序

    千次阅读 2018-02-01 16:09:24
    ArrayList实现自定义排序主要通过两种方法 需要进行排序的对象类实现Comparable接口,重写compareTo(Object o)方法,在其中定义排序规则,那么就可以直接调用Collections.sort()来排序对象数组。 实现比较器接口...
  • Java ArrayList的自定义排序

    万次阅读 2016-09-13 15:00:23
    Java ArrayList的自定义排序
  • 使用Comparator接口:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法。 题目描述: 从A、B、C、D、E5个方面对每一家酒店进行评价收集,并给出1-5星的评分(整数),排序规则如下...
  • 如果要按照某一个属性来对这个对象数组进行升序或降序排序,那么就需要用Arrays.sort(),但是这个创建的类一定要继承Comparable这个接口并重写compareTo方法。代码如下: package 排序; import java.util.Arrays; ...
  • Java自定义的类排序: Comparable接口 Comparable接口作用: comparaTo方法: 利用comparator接口实现排序的方法步骤: 例程源码: 例题: Java自定义的类排序: Comparable接口 Comparable接口作用: ...
  • Java对象排序的实现Java中,可以使用Java.util.Collection的sort方法对自定的对象进行排序排序规则可以通过重载java.util.Comparator接口的compare方法定义。参考如下代码:Collection.sort(ObjectList, new ...
  • java jdk 排序
  • Java的Set、Map和数组的自定义排序 该文章讲述下面三点并给出相应实例 Set的三种自定义排序和遍历 Map的三种自定义排序和遍历 数组的三种自定义排序 1.Set的三种自定义排序和遍历 这里的三种自定义排序分别是 ...
  • 默认情况下,保存在List集合中的数组是不进行排序的,不过可以通过使用Comparable接口自定义排序规则并自动排序。本实例将介绍如何使用Comparable接口自定义排序规则并自动排序。   实现过程 新建一个Java类,...
  • Java自定义类型的排序

    2015-06-05 14:11:21
    自定义类型的排序方法: 1、要排序的类实现Comparable接口; 2、自定义Comparator;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,443
精华内容 39,777
关键字:

java自定义排序的接口

java 订阅