Java两种比较机制Comparable与Comparator区别

一、Comparable

1、Comparable 自然排序 它对每个实现它的类的对象强加了排序规则。该排序称之为自然排序

在java.lang包下，是一个接口。
compareTo 方法的返回值有三种情况：

    <1> e1.compareTo(e2) > 0 即 e1 > e2

    <2> e1.compareTo(e2) = 0 即 e1 = e2

    <3> e1.compareTo(e2) < 0 即 e1 < e2

    实现了 Comparable 接口的 List 或则数组可以使用 Collections.sort() 或者 Arrays.sort() 方法进行排序

comparable接口定义一个方法:

    public interface Comparable<T> {
        public int compareTo(T o);
    }

2、举例

    public class TestComparable implements Comparable<TestComparable> {

        private String name;

        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return this.name + this.age;
        }

        @Override
        public int compareTo(TestComparable o) {

            if (this.age == o.age){
                return 0;
            }else if(this.age > o.age){
                return 1;
            }else {
                return -1;
            }
        }
    }

	public static void main(String[] arges){
        //定义一个TestComparable           
		TestComparable testComparable = new TestComparable();
        testComparable.setName("王三");
        testComparable.setAge(29);
        //定义一个TestComparable1    
		TestComparable testComparable1 = new TestComparable();
        testComparable1.setName("李四");
        testComparable1.setAge(28);

        List<TestComparable> testComparables = new ArrayList<>();
        testComparables.add(testComparable);
        testComparables.add(testComparable1);
        //排序前打印
        System.out.print(testComparables.toString());
        //排序(按年龄的大小)
        Collections.sort(testComparables);
        //排序后打印
        System.out.print(testComparables.toString());
    }

二、Comparator

1、Comparator 定制排序 是在外部制定排序规则 是一种策略模式

Comparator 在 java.util 包下，也是一个接口
JDK 1.8 以前只有两个方法：

    public interface Comparator<T> {

        public int compare(T lhs, T rhs);

        public boolean equals(Object object);
    }

JDK 1.8 以后又新增了很多方法

2、举例

    <1> 创建一个类实现Comparator接口，其中TestComparatorBean是自定义类
	
	    public class TestComparator implements Comparator<TestComparatorBean> {

            @Override
            public int compare(TestComparatorBean o1, TestComparatorBean o2) {
		        //排序规则
                return o1.getAge() - o2.getAge();
            }
        }
	
	    //自定义类TestComparatorBean

	    public class TestComparatorBean {

            private String name;
            private int age;

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }

            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            @Override
            public String toString() {
                return this.name + this.age;
            }
        }

	<2> 测试
	
	    public static void main(String[] arges){

            TestComparatorBean testComparatorBean = new TestComparatorBean();
            testComparatorBean.setName("找五");
            testComparatorBean.setAge(13);

            TestComparatorBean testComparatorBean1 = new TestComparatorBean();
            testComparatorBean1.setName("随六");
            testComparatorBean1.setAge(12);

            List<TestComparatorBean> testComparatorEnties = new ArrayList<>();
            testComparatorEnties.add(testComparatorBean);
            testComparatorEnties.add(testComparatorBean1);
            //排序前打印
            System.out.println(testComparatorEnties.toString());
            //排序
            Collections.sort(testComparatorEnties,new TestComparator());
            //排序后打印
            System.out.println(testComparatorEnties.toString());

        } 

三、Comparable和Comparator区别

 Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
 
 <1> 若一个类实现了Comparable接口直接就成为一个可以比较的对象，但是需要修改源代码。
 
 <2> Comparator是比较器，若需要控制某个类的次序，则需要定义一个外部类实现Comparator接口，
 
     当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了。不需要修改源代码。