按名字对对象数组进行排序：
Arrays.sort(people,Comparator.comparing(Person::getName);

可以把比较器与thenComparing方法串起来，来处理比较结果相同的情况：
Arrays.sort(people,Comparator.comparing(Person::getLasrName).thenComparing(Person::getFirstName));

根据人名长度完成排序：
Arrays.sort(people,Comparator.comparing(Person::getName,(s,t)->Integer.compare(s.length(),t.length())));

要完成上面的操作，还有一种更容易的做法：
Arrays.sort(people,Comparator.comparingInt(p->p.getName().length()));

Comparator comparator=new Comparator(){
  public int compare(Object o1, Object o2) {
   // TODO Auto-generated method stub
   return 0;
  }
  
 };

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)));

输出结果:

前面我们讲过Java提供了一个用于比较的接口Comparable,提供了一个比较的方法,所有实现该接口的类,都动态的实现了该比较方法。实际上Java中除了比较一个接口外，还提供了一个接口，该接口也是具有比较的功能，但该接口注重的却是比较容器，然后对其排序，这就是Comparator，下面我们就来具体认识一下。

1. 接口概述

　　Comparator并不想Comparable那样有许许多多的实现类，该接口的实现类只有两个Collator, RuleBasedCollator，但是该接口提供的两个方法，仍然是十分有用的，下面我们就来详细通过API介绍一下接口，下节介绍接口方法；

查看API：

public interface Comparator<T>

　　强行对某个对象 collection 进行整体排序的比较函数。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

　　当且仅当对于一组元素 S 中的每个e1和e2 而言，c.compare(e1, e2)==0与 e1.equals(e2) 具有相等的布尔值时，Comparator c 强行对 S 进行的排序才叫做与 equals 一致的排序。

　　当使用具有与 equals 不一致的强行排序能力的 Comparator 对有序 set（或有序映射）进行排序时，应该小心谨慎。假定一个带显式 Comparator c 的有序 set（或有序映射）与从 set S 中抽取出来的元素（或键）一起使用。如果 c 强行对 S 进行的排序是与 equals 不一致的，那么有序 set（或有序映射）将是行为“怪异的”。尤其是有序 set（或有序映射）将违背根据 equals 所定义的 set（或映射）的常规协定。 例如，假定使用 Comparator c 将满足 (a.equals(b) && c.compare(a, b) != 0) 的两个元素 a 和 b 添加到一个空 TreeSet 中，则第二个 add 操作将返回 true（树 set 的大小将会增加），因为从树 set 的角度来看，a 和 b 是不相等的，即使这与 Set.add 方法的规范相反。

　　注：通常来说，让 Comparator 也实现 java.io.Serializable 是一个好主意，因为它们在可序列化的数据结构（像 TreeSet、TreeMap）中可用作排序方法。为了成功地序列化数据结构，Comparator（如果已提供）必须实现 Serializable。

在算术上，定义给定 Comparator c 对给定对象 set S 实施强行排序 的关系式 为：

       {(x, y) such that c.compare(x, y) <= 0}.

此整体排序的商 (quotient) 为：

       {(x, y) such that c.compare(x, y) == 0}.

　　它直接遵循 compare 的协定，商是 S 上的等价关系，强行排序是 S 上的整体排序。当我们说 c 强行对 S 的排序是与 equals 一致 的时，意思是说排序的商是对象的 equals(Object) 方法所定义的等价关系：

       {(x, y) such that x.equals(y)}.

此接口是 Java Collections Framework 的成员。



2. 接口方法详解

　　作为接口Comparator提供了两个抽象方法，如下：


			
int
			
			

			
compare(T o1, T o2) 比较用来排序的两个参数。
			
		

			
 boolean
			
			

			
equals(Object obj) 指示某个其他对象是否“等于”此 Comparator。
			
		
　　通过API，我们来解读接口方法：

　　Compare（）比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。 在前面的描述中，符号 sgn(expression) 表示 signum 数学函数，根据 expression 的值为负数、0 还是正数，该函数分别返回 -1、0 或 1。

实现程序必须确保对于所有的 x 和 y 而言，都存在 sgn(compare(x, y)) == -sgn(compare(y, x))。（这意味着当且仅当 compare(y, x) 抛出异常时 compare(x, y) 才必须抛出异常。）
	
实现程序还必须确保关系是可传递的：((compare(x, y)>0) && (compare(y, z)>0)) 意味着 compare(x, z)>0。
	
最后，实现程序必须确保 compare(x, y)==0 意味着对于所有的 z 而言，都存在 sgn(compare(x, z))==sgn(compare(y, z))。
　　虽然这种情况很普遍，但并不 严格要求 (compare(x, y)==0) == (x.equals(y))。一般说来，任何违背这个条件的 Comparator 都应该清楚地指出这一事实。推荐的语言是“注意：此 Comparator 强行进行与 equals 不一致的排序。”

  　　可能抛出异常ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较。

　　Equals（）指示某个其他对象是否“等于”此 Comparator。此方法必须遵守 Object.equals(Object) 的常规协定。此外，仅当 指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时，此方法才返回 true。因此，comp1.equals(comp2) 意味着对于每个对象引用 o1 和 o2 而言，都存在 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))。

　　注意，不重写 Object.equals(Object) 方法总是安全的。然而，在某些情况下，重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序，从而提高性能。

覆盖： 类 Object 中的 equals

参数： obj - 要进行比较的引用对象。

返回： 仅当指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时才返回 true。

3. 接口方法实践操作

　　上面我们对接口中的两个方法进行了一番概述，那么接下来我们就来实践操作一下这两个方法。

package cn.comparator.A;
import java.util.Comparator;
/**
     * 我们考虑这样一种情况,那么就是一个String类型的数组,我们希望数组的排序是
     * 按照字符串的长度来排序,而不是字典书序,那么此时显然String的compareTo不适用了,
     * 并且String是final类,也不允许我们更改,那么此时该怎么做呢?
     * Arrays提供了一个用于排序的sort方法,如果不传递比较器的话,
     * 那么默认使用该类型的比较器进行比较,这里要比较的是String,String的比较器不符合我们
     * 的需求,那么最好的做法就是自己定义个比较器,然后传递进去,下面来试一下
     */
public class ComparatorLength implements Comparator<String>{
    /**
     * 如果参数1的长度大于参数2的长度,那么返回1,否则返回-1
     */
    @Override
    public int compare(String o1, String o2) {
        int len1 = o1.length();
        int len2 = o2.length();
        return (len1 - len2 > 0) ? 1 : -1;
    }
}

@Test
    public void test2(){
        String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
        Comparator com1 = new ComparatorLength();
        Comparator com2 = new ComparatorLength();
        Arrays.sort(str, com1);
        System.out.println(Arrays.toString(str));
        Arrays.sort(str, com2);
        System.out.println(Arrays.toString(str));
        System.out.println((com1 == com2) +"--"+ (com1.equals(com2)));
    }

 



　　上面我们简单对Comparator的方法进行了实践，那么我们考虑对数组进行更详细的排序，按照字符排序，并且重写equals方法，注意equals方法是重写Object的，Comparator虽然具有equals，但是使用Eclipse快捷重写该方法时，没有任何提示，下面我们来看一下：

 

package cn.comparator.A;
import java.util.Comparator;
public class ComparatorLeng implements Comparator<String>{
    /**
     * 比较字符串元素
     */
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
    @Override
    public boolean equals(Object o) {
        Comparator com = (Comparator) o;
        return this.compare(o1, o2) == com.compare(o1, o2);
    }
}

 

@Test
    public void test3(){
        String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
        Comparator com1 = new ComparatorLeng();
        Comparator com2 = new ComparatorLeng();
        Arrays.sort(str, com1);
        System.out.println(Arrays.toString(str));
        Arrays.sort(str, com2);
        System.out.println(Arrays.toString(str));
        System.out.println((com1 == com2) +"--"+ (com1.equals(com2)));
    }

 

 

我们看到实现了既定操作，我们考虑一下，我们是学习过排序算法的，那么试验一下：

 

package cn.comparator.A;
import java.util.Comparator;
public class ComparatorLeng implements Comparator<String>{
    String o1 = "sacWDVWdvWDSCDXCsfsdf";
    String o2 = "FWEFxsafcsdavxFWEFVcss";
    /**
     * 比较字符串元素
     */
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
    @Override
    public boolean equals(Object o) {
        Comparator com = (Comparator) o;
        return this.compare(o1, o2) == com.compare(o1, o2);
    }
    public Comparable[] sort(Comparable<String>[] arr){
        //将数组按照升序排列
        int len = arr.length;
        for (int i = 0; i < len; i++) {
            //将arr[i]插入到arr[i-1],arr[i-2]....之中去
            for (int j = i; j > 0 && less(arr[j], arr[j-1]); j--) {
                //交换arr[j]和arr[j-1]元素
                exch(arr, j, j-1);
            }
        }
        return arr;
    }
    //比较数组元素
    public boolean less(Comparable c1,Comparable c2){
        return c1.compareTo(c2) < 0;
    }
    //交换元素
    public void exch(Comparable[] com, int i,int j){
        Comparable ce = com[i];
        com[i] = com[j];
        com[j] = ce;
    }
}

 

@Test
    public void test4(){
        String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
        String[] str1 = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
        ComparatorLeng com1 = new ComparatorLeng();
        str = (String[]) com1.sort(str);
        System.out.println(Arrays.toString(str));
        Arrays.sort(str1, com1);
        System.out.println(Arrays.toString(str1));
    }

 



特别注意：首先，排序并不是完全由三个返回值0，-1，１三个数字决定的，可以通过修改测试代码的两个参数o1和o2的位置，即原来o1 > o2改成o2 > o1,返回值不变，排序就乱了。我的理解是返回值决定位置是否需要调整，谁的位置呢？o1和o2，o1和o2是有顺序的，理解这点很重要，也就是o1排在o2后面（原数组），这样o1 > o2如果返回-1表示位置需要调整，即倒序（因为值大的o1要排到值小的o2前面去）；同理，如果o2 > o1如果返回-1也表示位置需要调整，这时候变成升序了（因为值大的o2要排到值小的o1后面去）

多个条件排序示例如下：

一、需求

    假设现在有个如此的需求：需要对一个这样的雇员列表进行排序，排序规则如下：

    1、首先级别最高的排在前面，

    2、如果级别相等，那么按工资排序，工资高的排在前面，

    3、如果工资相当则按入职年数排序，入职时间最长的排在前面。

雇员对象包含级别、工资和入职年份，代码如下：

   

package com.lyz.sort.bean;
     
    import java.io.Serializable;
     
     
    /**
     * 雇员信息
     * @author liuyazhuang
     *
     */
    public class Employee implements Serializable {
     
        private static final long serialVersionUID = 4775629632953317597L;
          /**
         * ID
         */
        public int id;
        /**
         * 级别
         */
        public int level;
        /**
         * 工资
         */
        public int salary;
        /**
         * 入职年数
         */
        public int year;
     
        public int getId() {
            return id;
        }
     
        public void setId(int id) {
            this.id = id;
        }
     
        public int getLevel() {
            return level;
        }
     
        public void setLevel(int level) {
            this.level = level;
        }
     
        public int getSalary() {
            return salary;
        }
     
        public void setSalary(int salary) {
            this.salary = salary;
        }
     
        public int getYear() {
            return year;
        }
     
        public void setYear(int year) {
            this.year = year;
        }
     
        public Employee(int id, int level, int salary, int year) {
            this.id = id;
            this.level = level;
            this.salary = salary;
            this.year = year;
        }
    }

二、实现Comparator接口

这里我们实现Java.util.Comparator接口，用于对雇员列表进行排序，代码如下：

   

package com.lyz.sort;
     
    import java.util.Comparator;
     
    import com.lyz.sort.bean.Employee;
     
    /**
     * 核心排序类
     * @author liuyazhuang
     *
     */
    public class EmpComparator implements Comparator<Employee> {
     
        @Override
        public int compare(Employee employee1, Employee employee2) {
              int cr = 0;
              //按级别降序排列
              int a = employee2.getLevel() - employee1.getLevel();
              if (a != 0) {
                  cr = (a > 0) ? 3 : -1;
              } else {
                  //按薪水降序排列
                  a = employee2.getSalary() - employee1.getSalary();
                  if (a != 0) {
                      cr = (a > 0) ? 2 : -2;
                  } else {
                      //按入职年数降序排列
                      a = employee2.getYear() - employee1.getYear();
                      if (a != 0) {
                          cr = (a > 0) ? 1 : -3;
                      }
                  }
              }
              return cr;
        }
     
    }

三、验证排序结果

下面用一个单元测试，来验证排序结果是否正确

   

package com.lyz.sort.test;
     
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
     
    import org.junit.Test;
     
    import com.lyz.sort.EmpComparator;
    import com.lyz.sort.bean.Employee;
     
    /**
     * 测试排序类
     *
     * @author liuyazhuang
     *
     */
    public class SortTest {
        @Test
        public void sortTest() throws Exception {
            List<Employee> employeeList = new ArrayList<Employee>() {
                {
                    add(new Employee(1, 9, 10000, 10));
                    add(new Employee(2, 9, 12000, 7));
                    add(new Employee(3, 5, 10000, 12));
                    add(new Employee(4, 5, 10000, 6));
                    add(new Employee(5, 3, 5000, 3));
                    add(new Employee(6, 1, 2500, 1));
                    add(new Employee(7, 5, 8000, 10));
                    add(new Employee(8, 3, 8000, 2));
                    add(new Employee(9, 1, 3000, 5));
                    add(new Employee(10, 1, 2500, 4));
                    add(new Employee(11, 2, 2000, 4));
                }
            };
            Collections.sort(employeeList, new EmpComparator());
            System.out.println("ID\tLevel\tSalary\tYears");
            System.out.println("=============================");
            for (Employee employee : employeeList) {
                System.out.printf("%d\t%d\t%d\t%d\n", employee.getId(), employee.getLevel(), employee.getSalary(),
                        employee.getYear());
            }
            System.out.println("=============================");
        }
    }

运行结果：