精华内容
下载资源
问答
  • 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自定义排序

    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 自定义排序

    2012-11-07 11:01:48
    数据库有一列的数据为 A01,A02-A11 B01,B02-B11 C01,C02…… 我现在要把它按照我的规则排序。 我要 A01,B01,C01… 然后再A02,B02
  • 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升序降序的记法】

    万次阅读 多人点赞 2017-12-25 18:57:26
    环境java: 1.7需求今天在写排序时,忘了是返回1,是正序,还是-1为正序。 或者说,正序或者降序我应该如何返回。例子说明Collections.sort(companyList, new Comparator() { @Override public int compare...

    环境

    java: 1.7

    需求

    今天在写排序时,忘了是返回1,是正序,还是-1为正序。
    或者说,正序或者降序我应该如何返回。

    例子说明

    Collections.sort(companyList, new Comparator<String>() {
                    @Override
                    public int compare(String o1, String o2) {
                        if(o1.compareTo(o2) < 0 ){
                            return -1;
                        }else if(o1.compareTo(o2) == 0){
                            return 0;
                        }else{
                            return 1;
                        }
                    }
                });

    说明:

    我的记法:

    顺序其实主要是看-1-1决定其是否要调整顺序:

    if(o1.compareTo(o2) < 0 ){
        return ?;
    }
    //这里o1表示位于前面的字符,o2表示后面的字符
    //上面的条件是,o1比o2小,这个时候,我们需要需要调整它们的顺序
    //如果你想升序,那么o1比o2小就是我想要的;所以返回-1,类比成false;表示我不想调整顺序
    
    //如果你想降序,那么o1比o2小不是我想要的;所以返回1,类比成true;表示我想调整顺序

    这里o1表示位于前面的字符,o2表示后面的字符
    上面的条件是,o1o2小,这个时候,我们需不需要调整它们的顺序:

    如果你想升序,那么o1比o2小就是我想要的;所以返回-1,类比成false;表示我不想调整顺序
    如果你想降序,那么o1比o2小不是我想要的;所以返回1,类比成true;表示我想调整顺序

    以上纯属自我总结,没有任何官方参考依据。
    自己的一种记法。。。

    展开全文
  • Java自定义排序

    2012-05-29 17:05:43
    Java自定义排序
  • java数组自定义排序

    2017-10-31 15:35:59
    java中数组的自定义排序,种类繁多,简单实现,可自由操控。
  • java自定义排序

    2020-01-28 22:41:38
    java自定义排序,(o1,o2)->{ code... return 1; } PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> { String frontstr = o1+...
  • Java自定义排序

    2020-02-02 13:43:24
    之前用C++做题,结构体排序一般都是重载sort,最近用java遇到排序的,返回值也总是记混,在此记录一下。 下面用的是Collections类中的sort方法对list排序,并重写了Comparator。 import java.util.Comparator; ...
  • Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在...
  • 对象排序有两种方法,自定义排序和实现Java中的比较器接口排序。 对自定义对象排序,我们可以根据自定义对象的数据结构,自定义排序规则来实现。也可以用Java中的两个常用的接口Comparable和Comparator,实现将...
  • 主要介绍了简单了解java自定义和自然排序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java 自定义map排序

    2019-12-25 10:49:36
    package test; public class Test { public static void main(String[] args) throws IOException { Map<String, String> sourceMap = new HashMap<>();... sourceMap.put( "201...
  • 主要介绍了Java针对ArrayList自定义排序的2种实现方法,结合实例形式总结分析了Java操作ArrayList自定义排序的原理与相关实现技巧,需要的朋友可以参考下
  • java 自定义对象排序

    2018-09-05 07:21:02
    自定义对象排序 Arrays 位置 java.util包, 其中.sort 对指定数据进行升序的方式排序   方法一:对自定义对象 必需 要实现 Comparable 接口 并且重写里面 compareTo 方法 import java.util.Arrays; /** * ...
  • java中Comparator自定义排序

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

    万次阅读 2016-09-13 15:00:23
    Java ArrayList的自定义排序
  • Java ArrayList自定义排序

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

    千次阅读 2020-03-09 14:55:28
    package ... import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.LinkedList; import java.util.List; import java.ut...
  • 主要介绍了Java自定义比较器实现中文排序,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Java自定义数组排序

    千次阅读 2019-04-15 21:00:23
    import java.util.Arrays; import java.util.Comparator; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.n...
  • java:自定义排序

    千次阅读 2018-09-06 17:04:40
    /** * 升序 如果o1小于o2,返回一个负数;如果o1大于o2,返回一个正数;如果他们相等,则返回0; */ Comparator&lt;Object&gt; comparator_up = new Comparator&... public int compare(Object ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 144,550
精华内容 57,820
关键字:

java自定义排序

java 订阅