在之前的集合课程中都没有涉及到集合的排序问题，本节课中，我们将来学习集合排序的问题。
那么，集合如何进行排序呢？首先我们要回忆一下数组是如何进行排序的：

  1. int[] arr = new int{1,8,91,3,7,6,2,9};
  2. Arrays.sort(arr);//数组排序

其实集合排序也会使用到sort(List<T> list)方法。只是这个sort(List<T> list)方法，存在于Collections类中。

注意Collections类和Collection接口

因为在集合中，List集合才是有序的。所以，集合排序通常是针对List集合而言。
小结：

  • 使用Collections类中sort(List<T> list)方法对List集合进行排序Collections.sort(list);
  • sort(List<T> list)方法根据元素的自然顺序对指定列表按升序进行排序，比如字符串或者字符数据按照Ascall码值进行排序

    对基本数据类型和字符串类型进行排序

    对整型排序

    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.List;
    4. public class IntSort {
    5.   public static void main(String[] args) {
    6.       // 对存储在List中的整型数据进行排序
    7.       List<Integer> list=new ArrayList<Integer>();
    8.       list.add(5);
    9.       list.add(9);
    10.       list.add(3);
    11.       list.add(1);
    12.       System.out.println("排序前：");
    13.       for(int n:list){
    14.           System.out.print(n+"    ");
    15.       }
    16.       System.out.println();
    17.       //对List中的数据进行排序
    18.       Collections.sort(list);
    19.       System.out.println("排序后：");
    20.       for(int n:list){
    21.           System.out.print(n+"    ");
    22.       }
    23.   }
    24. }
    小结：
  1. 泛型中的数据类型不能使用基本数据类型要使用包装类，因为List不同与数组，参数是Object类型，都是对象，所以泛型的时候要用包装类。不能使用int，应该使用
    • List<Integer>list = new ArrayList<Integer>();
  2. 集合中使用了泛型统一,则输出时候可以用for-each循环
  3. 使用Collections.sort(list);方法对集合中的内容进行升序排序;

    对字符串排序

    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.List;
    4. public class StringSort {
    5.  public static void main(String[] args) {
    6.      // 对存放在List中的字符串进行排序
    7.      List<String> list=new ArrayList<String>();
    8.      list.add("orange");
    9.      list.add("blue");
    10.      list.add("yellow");
    11.      list.add("gray");
    12.      System.out.println("排序前：");
    13.      for(String s:list){
    14.          System.out.print(s+"   ");
    15.      }
    16.      System.out.println();
    17.      Collections.sort(list);
    18.      System.out.println("排序后：");
    19.      for(String s:list){
    20.          System.out.print(s+"   ");
    21.      }
    22.  }
    23. }
    小结：字符串是按照其首字母对应的ASCII码值进行排序的。

    Comparator接口

    Comparator接口
  • 强行对某个对象进行整体排序的比较函数。
  • 可以将Comparator接口作为参数，传递给sort方法（如Collections.sort或Arrays.sort）
  • 在Comparator接口存在int compare(T o1, T o2)方法，比较用来排序的两个参数
    • 对于其返回值，如果o1o2，返回正整数

  • Comparator接口中还存在boolean equals(Object obj)方法，指示某个其他对象是否“等于”此Comparator,此方法可以被Object类中的equals方法覆盖，不必重写。

    案例：宠物猫排序

    1. public class Cat {
    2.   private String name; //名字
    3.   private int month; //年龄
    4.   private String species;//品种
    6.   //构造方法
    7.   public Cat(String name, int month, String species) {
    8.       super();
    9.       this.name = name;
    10.       this.month = month;
    11.       this.species = species;
    12.   }
    13.   //getter与setter方法
    14.   public String getName() {
    15.       return name;
    16.   }
    17.   public void setName(String name) {
    18.       this.name = name;
    19.   }
    20.   public int getMonth() {
    21.       return month;
    22.   }
    23.   public void setMonth(int month) {
    24.       this.month = month;
    25.   }
    26.   public String getSpecies() {
    27.       return species;
    28.   }
    29.   public void setSpecies(String species) {
    30.       this.species = species;
    31.   }
    32.   @Override
    33.   public String toString() {
    34.       return "[名字：" + name + ", 年龄：" + month + ", 品种：" + species + "]";
    35.   }
    36. }
    1. import java.util.Comparator;
    2. public class AgeComparator implements Comparator<Cat>{
    3.   @Override
    4.   public int compare(Cat o1, Cat o2) {
    5.       // 按年龄降序排序
    6.       int age1=o1.getMonth();
    7.       int age2=o2.getMonth();
    8.       return age2-age1;
    9.   }
    10. }
    1. import java.util.Comparator;
    2. public class NameComparator implements Comparator<Cat> {
    3.   @Override
    4.   public int compare(Cat o1, Cat o2) {
    5.       // 按名字升序排序
    6.       String name1=o1.getName();
    7.       String name2=o2.getName();
    8.       int n=name1.compareTo(name2);
    9.       return n;
    10.   }
    11. }
    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.List;
    4. public class CatTest {
    5.   public static void main(String[] args) {
    6.       // 按名字升序排序
    7.       Cat huahua=new Cat("huahua",5,"英国短毛猫");
    8.       Cat fanfan=new Cat("fanfan",2,"中华田园猫");
    9.       Cat maomao=new Cat("maomao",3,"中华田园猫");
    10.       List<Cat> catList=new ArrayList<Cat>();
    11.       catList.add(huahua);
    12.       catList.add(fanfan);
    13.       catList.add(maomao);
    14.       //排序前
    15.       System.out.println("排序前：");
    16.       for(Cat cat:catList){
    17.           System.out.println(cat);
    18.       }
    19.       //按名字进行升序排序
    20.       Collections.sort(catList, new NameComparator());
    21.       System.out.println("按名字升序排序后：");
    22.       for(Cat cat:catList){
    23.           System.out.println(cat);
    24.       }
    25.       //按年龄进行降序排序
    26.       Collections.sort(catList, new AgeComparator());
    27.       System.out.println("按年龄降序排序后：");
    28.       for(Cat cat:catList){
    29.           System.out.println(cat);
    30.       }
    31.   }
    32. }

    Comparable接口

    Comparable接口

  • 此接口强行对实现它的每个类别的对象进行整体排序；

  • 这种排序被称为类的自然比较方法；
  • int compareTo（T o）方法——比较的其实是当前对象和参数对象，该对象（实现Comparable接口的对象）小于，等于或大于指定对象（compareTo方法中的参数对象）则分别返回负整数，零或正整数。

    案例：商品排序

    1. public class Goods implements Comparable<Goods> {
    2.   private String id;//商品编号
    3.   private String name;//商品名称
    4.   private double price;//商品价格
    5.   //构造方法
    6.   public Goods(String id,String name,double price){
    7.       this.id=id;
    8.       this.name=name;
    9.       this.price=price;
    10.   }
    11.   //getter和setter方法
    12.   public String getId() {
    13.       return id;
    14.   }
    15.   public void setId(String id) {
    16.       this.id = id;
    17.   }
    18.   public String getName() {
    19.       return name;
    20.   }
    21.   public void setName(String name) {
    22.       this.name = name;
    23.   }
    24.   public double getPrice() {
    25.       return price;
    26.   }
    27.   public void setPrice(double price) {
    28.       this.price = price;
    29.   }
    30.   public String toString(){
    31.       return "商品编号："+id+",商品名称："+name+"，商品价格："+price;
    32.   }
    33.   @Override
    34.   public int compareTo(Goods o) {
    35.       // 取出商品价格
    36.       double price1=this.getPrice();
    37.       double price2=o.getPrice();
    38.       int n=new Double(price2-price1).intValue();
    39.       return n;
    40.   }
    41. }
    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.List;
    4. public class GoodsTest {
    5.   public static void main(String[] args) {
    6.       Goods g1 = new Goods("s00001", "手机", 2000);
    7.       Goods g2 = new Goods("s00002", "冰箱", 5000);
    8.       Goods g3 = new Goods("s00003", "电视机", 3000);
    9.       List<Goods> goodsList = new ArrayList<Goods>();
    10.       goodsList.add(g1);
    11.       goodsList.add(g2);
    12.       goodsList.add(g3);
    13.       // 排序前
    14.       System.out.println("排序前：");
    15.       for (Goods goods : goodsList) {
    16.           System.out.println(goods);
    17.       }
    18.       Collections.sort(goodsList);
    19.       // 排序后
    20.       System.out.println("排序后：");
    21.       for (Goods goods : goodsList) {
    22.           System.out.println(goods);
    23.       }
    24.   }
    25. }

    排序接口区别

    区别：
  1. 实现了java.lang.Comparable的对象直接就可以成为一个可以比较的对象，不过得在类中进行方法定义；
  2. java.util.Comparator在对象外比较，不修改实体类；
  3. 实现了Comparable的意思是我可以把自己和另一个对象进行比较；而实现了Comparator的意思是我可以比较其他两个对象；也就是说Comparable是一个可比较的对象可以将自己与另一个对象进行比较；而Comparator是比较两个不同的对象。
  4. 使用Comparable需要修改原先的实体类，是属于一种自然排序。而Comparator则不用修改原先类。即使修改了Comparable实体类，Comparable也仅有一种比较规则。而Comparator可以实现多个，来提供多个比较规则。

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