Java对象排序：Comparable与Comparator接口详解-优快云博客

Comparable类

所谓的比较器指的是进行大小关系的确定判断。
如果要进行数组操作，一般都会使用java.util.Arrays的操作类完成，这个类中提供了很多常见的数组操作支持，包括对象数组的排序： public static void sort(Object[] a)；
范例：实现对象数组的排序

import java.util.Arrays;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        Integer[] data = new Integer[]{10, 9, 5, 2, 20};//对象数组
        Arrays.sort(data);//进行对象数组排序
        System.out.println(Arrays.toString(data));
        String[] strs = new String[]{"pear", "apple", "banana", "watermelon", "melon"};//对象数组
        Arrays.sort(strs);//进行对象数组排序
        System.out.println(Arrays.toString(strs));
        //[2, 5, 9, 10, 20]
        //[apple, banana, melon, pear, watermelon]
    }
}

java.lang.Integer与java.lang.String两个类都是由系统提供的程序类，那么如何实现自定义的类的排序处理呢？
范例：自定义的类进行排序处理（错误示范）

import java.util.Arrays;
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "【Person类对象】姓名：" + this.name + "、年龄：" + this.age;
    }
}
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        Person[] data = new Person[]{new Person("张三",30), new Person("李四",31), new Person("王五",28), new Person("赵六",38), new Person("孙七",37),};//对象数组
        Arrays.sort(data);//进行对象数组排序
        System.out.println(Arrays.toString(data));
        //运行时异常：Exception in thread "main" java.lang.ClassCastException: com.mldn.demo.Person cannot be cast to java.lang.Comparable
    }
}

任意一个类默认情况下是无法使用系统内部的类进行数组排序或比较需求的，因为类中并没有明确的表明比较的规则定义，在Java中为了统一比较规则的定义，所以从JDK1.2后提供了比较器的接口：Comparable接口。

public interface Comparable<T>{
    /**
     * 实现对象的比较处理操作
     * @param o 要比较的对象
     * @return this-o的值（int）当前数据比传入数据小返回负数，大于正数，等于0 
     */
    int compareTo(T o);
}
Comparable

在这里插入图片描述

范例：使用Comparable实现自定义的类排序处理

import java.util.Arrays;
class Person implements Comparable<Person>{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "【Person类对象】姓名：" + this.name + "、年龄：" + this.age;
    }

    @Override
    public int compareTo(Person person) {
        return this.age-person.age;//升序
//        return person.age-this.age;//降序
    }
}
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        Person[] data = new Person[]{new Person("张三",30), new Person("李四",31), new Person("王五",28), new Person("赵六",38), new Person("孙七",37),};//对象数组
        Arrays.sort(data);//进行对象数组排序
        System.out.println(Arrays.toString(data));
        //[【Person类对象】姓名：王五、年龄：28, 【Person类对象】姓名：张三、年龄：30, 【Person类对象】姓名：李四、年龄：31, 【Person类对象】姓名：孙七、年龄：37, 【Person类对象】姓名：赵六、年龄：38]
    }
}

在Java中要实现排序只需要有一个compareTo()方法进行排序规则的定义就可以了。

Comparator类

Comparator属于一种挽救的比较器支持，其主要的目的是解决一些没有实现Comparable接口的对象数组排序操作。

基于【Arrays】Comparator的排序处理：public static <T> void sort(T[] a, Comparator<? super T> c)；
在这里插入图片描述

在java.util.Comparator中，最初只定义了一个排序的compareTo()方法：int compare(T o1, T o2)；后来持续发展又增加了许多static的方法。
范例：使用Comparator定义排序规则

import java.util.Arrays;
import java.util.Comparator;
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "【Person类对象】姓名：" + this.name + "、年龄：" + this.age;
    }
}
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        Person[] data = new Person[]{new Person("张三",30), new Person("李四",31), new Person("王五",28), new Person("赵六",38), new Person("孙七",37),};//对象数组
        Arrays.sort(data, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();//升序
//                return o2.getAge()-o1.getAge();//降序
            }
        });//进行对象数组排序
        System.out.println(Arrays.toString(data));
        //[【Person类对象】姓名：王五、年龄：28, 【Person类对象】姓名：张三、年龄：30, 【Person类对象】姓名：李四、年龄：31, 【Person类对象】姓名：孙七、年龄：37, 【Person类对象】姓名：赵六、年龄：38]
    }
}

对于这种排序的操作如果不是必须的情况下，强烈不建议使用Comparator，最好以Comparable为主。

两者区别
java.lang.Comparable 是类定义的时候实现的父接口，主要用于定义牌型规则，里面有compareTo()
java.util.Comparator 是挽救的比较器操作，需要设置单独的比较器规则类实现排序，里面compare() ;

总体实现：

注：Arrays.sort :此实现是一种稳定的，自适应的迭代合并排序所需的比较少于n lg（n）它非常适合合并两个或多个排序后的数组：

package com.msc.senior;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;

class PersonCompareDesc implements Comparator<Person>{
	@Override
	public int compare(Person o1, Person o2) {
		// TODO Auto-generated method stub
		return o2.getAge()-o1.getAge();
	}
}
class Person implements Comparable<Person>{
	private int age ;
	private String name ;
	
	public Person(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	@Override
	public int compareTo(Person per) {
		// TODO Auto-generated method stub
		return this.age-per.age; ///asc
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return this.age + " " +this.name;
	}
}
public class CompareDemo {

	public static void main(String[] args) {
		Person[] per = {
				new Person(32,"Li Ming"),
				new Person(26, "Lucy"),
				new Person(65, "haha")	
		};
		System.out.println("------------No.1------------");
		Arrays.sort(per);
		for (Person person : per) {
			System.out.println(person);
		}
		System.out.println("------------No.2------------");
		Arrays.sort(per,new PersonCompareDesc());
		for (Person person : per) {
			System.out.println(person);
		}
		
		System.out.println("------------No.3------------");
		Arrays.sort(per,new Comparator<Person>() {
			@Override
			public int compare(Person o1, Person o2) {
				// TODO Auto-generated method stub
				return o1.getName().length()-o2.getName().length();
			}
			
		});
		for (Person person : per) {
			System.out.println(person);
		}
		
		System.out.println("------------No.4------------");
		Arrays.sort(per,(o1,o2)->{
			return o2.getName().length()-o1.getName().length();
		});
		for (Person person : per) {
			System.out.println(person);
		}
		
	}
}