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自定义排序多种方式
 
四种写法 两种方式
传入匿名内部类
Lamda表达式
Comparator 定制排序
compare接口重写 compareTo 方法
 


 摘录自
参考文章
 
四种写法 两种方式
 
传入匿名内部类
 
第一次见，记录一下，最后两种是正常写法以及方式，改变排序也方便改，这个适合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;
    }
}

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经典编程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 
   
 
   
 
   
  
 
 
 
 
 public class Employee implements Comparable<Employee> {  
     private int id;  
     private String name;  
     private int age;  
     public Employee(int id, String name, int age) { //利用构造方法初始化各个域  
         this.id = id;  
         this.name = name;  
         this.age = age;  
     }  
     @Override  
     public int compareTo(Employee o) {              //利用编号实现对象间的比较  
         if (id > o.id) {  
             return 1;  
         } else if (id < o.id) {  
             return -1;  
         }  
         return 0;  
     }  
     @Override  
     public String toString() {                      //重写toString()方法  
         StringBuilder sb = new StringBuilder();  
         sb.append("员工的编号：" + id + "，");  
         sb.append("员工的姓名：" + name + "\t，");  
         sb.append("员工的年龄：" + age);  
         return sb.toString();  
     }  
 }  
 
 

 
 
重写接口中的方法时，要将访问权限限定符设为public，因为接口中的方法默认就是public的。
 
  
 
再新建一个名称为Test的类，用于进行测试。在该类中首先定义一个List集合来保存3个Employee对象，并通过遍历输出集合中的元素，再通过Collections.sort()方法执行自动排序，最后再通过遍历输出排序后的集合中的元素。
 
 Test.java
 
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
   
  
 
 
 
 
 import java.util.ArrayList;  
 import java.util.Collections;  
 import java.util.List;  
   
 public class Test {  
     public static void main(String[] args) {  
         List<Employee> list = new ArrayList<Employee>();  
         list.add(new Employee(2, "Java", 20));  
         list.add(new Employee(1, "C", 30));  
         list.add(new Employee(3, "C#", 10));  
         System.out.println("排序前");  
         for (Employee employee : list) {  
             System.out.println(employee);  
         }  
         System.out.println("排序后");  
         Collections.sort(list);  
         for (Employee employee : list) {  
             System.out.println(employee);  
         }  
     }  
 }  
 
 

 
 
 编译运行
 
$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()方法进行自动排序。
 
  
 
 如果不想实现在接口中定义的方法，则可以将类声明为抽象类，将接口中定义的方法声明为抽象方法。