集合排序Comparator和Comparable

1.Comparator

理论整理：
1.Comparator接口位于java.util包下
2.要在比较类外部实现接口
3.在调用sort()方法时，要指定Comparator的实现类，比如我们Cat类进行比较，那么这里就是两个要比较的Cat类的对象，所以可以有一个单独的类实现Comparator
代码实现

比较类

public class Cat {
        private String name;//名字
        private int month;//年龄
        private String specise;//品种

        //构造方法
        public Cat(String name, int month, String specise) {
            this.name = name;
            this.month = month;
            this.specise = specise;
        }

        public String getName() {
            return name;
        }

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

        public int getMonth() {
            return month;
        }

        public void setMonth(int month) {
            this.month = month;
        }

        public String getSpecise() {
            return specise;
        }

        public void setSpecise(String specise) {
            this.specise = specise;
        }

        @Override
        public String toString() {
            return "Cat{" +
                    "名字='" + name + '\'' +
                    ", 年龄=" + month +
                    ", 品种='" + specise + '\'' +
                    '}';
        }
}

接口类，这里有两个接口，按两种属性进行排序

import java.util.Comparator;
//按名字字母升序排序
//这里需要注意，接口后面需加上泛型
public class NameComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        String Name1 = o1.getName();
        String Name2 = o2.getName();
        //先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推，直至得到最终结果或者其
        //Name1>Name2返回正整数，相等时返回0，<时返回负整数
        int n =Name1.compareTo(Name2);
        return n;
    }
}

import java.util.Comparator;

public class AgeComparator implements Comparator<Cat> {
    //按年龄降序排序
    @Override
    public int compare(Cat o1, Cat o2) {
        int age1 = o1.getMonth();
        int age2 = o2.getMonth();
        return age2-age1;
    }
}

测试类

import java.util.*;

public class CompartorText {
    public static void main(String[] args) {
        //创建三个猫对象
        Cat huahua = new Cat("aomi",5,"英国短毛猫");
        Cat aryary = new Cat("aimi",6,"三花猫");
        Cat wang = new Cat("aiai",3,"蓝猫");
        List<Cat> list = new ArrayList<Cat>();
        list.add(huahua);
        list.add(aryary);
        list.add(wang);
        System.out.println("未排序的顺序：");
        for(Cat n:list){
            System.out.println(n);
        }
        System.out.println("***********");
        System.out.println("按名字升序排序后的顺序为");
        //指定Comparator的实现类，按名字排序的类
        Collections.sort(list,new NameComparator());
        for(Cat n:list){
            System.out.println(n);
        }
        System.out.println("**********");
        System.out.println("按年龄降序排序");
        Collections.sort(list,new AgeComparator());
        for(Cat n:list){
            System.out.println(n);
        }
    }
}

2.Comparable

理论整理
1.位于java.lang包
2.要在比较类上实现该接口
3.调用sort方法只需指定集合名即可

代码实例

比较类

//比较类
public class Goods implements Comparable<Goods> {
    private String id;
    private String name;
    private double price;
    //构造方法
    public Goods(String id,String name ,double price){
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "商品编号："+id+",商品名字："+name+",商品价格:"+price;
    }
    //比较中实现该接口
    @Override
    public int compareTo(Goods o) {
        //按商品价格降序排序
        double price1 = this.price;
        double price2 = o.price;
        int n =new Double(price2-price1).intValue();
        return n;
    }
}

测试类

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//按商品价格降序排序
public class GoodsText {
    public static void main(String[] args) {
        //创建商品对象
        Goods goods1 = new Goods("sooo1","冰箱",3000);
        Goods goods2 = new Goods("sooo2","电视",7000);
        Goods goods3 = new Goods("sooo3","电脑",4000);
        List list = new ArrayList();
        list.add(goods1);
        list.add(goods2);
        list.add(goods3);
        System.out.println("未排序前的顺序为：");
        Iterator<Goods> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("排序后的顺序为：");

        Collections.sort(list);
        it= list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }
}

于应用场景
一般情况下如果对某个类进行排序，比如Cat类，如果使用Comparable接口的方式，那么Cat类需要实现Comparable接口。
如果Cat类通过Comparable接口的方式实现排序，比如通过name排序了。那么我们还希望通过age进行排序，这时不希望修改Cat类，那此时就需要使Comparator接口了
因此，Comparable接口可以作为实现类的默认排序算法，Comparator接口则用于一个类的扩展排序