数组是如何进行排序的：

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

其实集合排序也会使用到sort(List list)方法。只是这个sort(List list)方法，存在于Collections类中。
注意Collections类和Collection接口
因为在集合中，List集合才是有序的。所以，集合排序通常是针对List集合而言。
小结：

  • 使用Collections类中sort(List list)方法对List集合进行排序
  • sort(List 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，应该使用Listlist = new ArrayList();
  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方法覆盖，不必重写。

    案例：宠物猫排序

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

  //构造方法
  public Cat(String name, int month, String species) {
      super();
      this.name = name;
      this.month = month;
      this.species = species;
  }
  //getter与setter方法
  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 getSpecies() {
      return species;
  }
  public void setSpecies(String species) {
      this.species = species;
  }
  @Override
  public String toString() {
      return "[名字：" + name + ", 年龄：" + month + ", 品种：" + species + "]";
  }
}

    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.Comparator;
public class NameComparator implements Comparator<Cat> {
  @Override
  public int compare(Cat o1, Cat o2) {
      // 按名字升序排序
      String name1=o1.getName();
      String name2=o2.getName();
      int n=name1.compareTo(name2);
      return n;
  }
}

    import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CatTest {
  public static void main(String[] args) {
      // 按名字升序排序
      Cat huahua=new Cat("huahua",5,"英国短毛猫");
      Cat fanfan=new Cat("fanfan",2,"中华田园猫");
      Cat maomao=new Cat("maomao",3,"中华田园猫");
      List<Cat> catList=new ArrayList<Cat>();
      catList.add(huahua);
      catList.add(fanfan);
      catList.add(maomao);
      //排序前
      System.out.println("排序前：");
      for(Cat cat:catList){
          System.out.println(cat);
      }
      //按名字进行升序排序
      Collections.sort(catList, new NameComparator());
      System.out.println("按名字升序排序后：");
      for(Cat cat:catList){
          System.out.println(cat);
      }
      //按年龄进行降序排序
      Collections.sort(catList, new AgeComparator());
      System.out.println("按年龄降序排序后：");
      for(Cat cat:catList){
          System.out.println(cat);
      }
  }
}

    Comparable接口

    Comparable接口

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

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

    案例：商品排序

    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;
  }
  //getter和setter方法
  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;
  }
  public String toString(){
      return "商品编号："+id+",商品名称："+name+"，商品价格："+price;
  }
  @Override
  public int compareTo(Goods o) {
      // 取出商品价格
      double price1=this.getPrice();
      double price2=o.getPrice();
      int n=new Double(price2-price1).intValue();
      return n;
  }
}

    import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class GoodsTest {
  public static void main(String[] args) {
      Goods g1 = new Goods("s00001", "手机", 2000);
      Goods g2 = new Goods("s00002", "冰箱", 5000);
      Goods g3 = new Goods("s00003", "电视机", 3000);
      List<Goods> goodsList = new ArrayList<Goods>();
      goodsList.add(g1);
      goodsList.add(g2);
      goodsList.add(g3);
      // 排序前
      System.out.println("排序前：");
      for (Goods goods : goodsList) {
          System.out.println(goods);
      }
      Collections.sort(goodsList);
      // 排序后
      System.out.println("排序后：");
      for (Goods goods : goodsList) {
          System.out.println(goods);
      }
  }
}

    排序接口区别

    区别：
  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接口则用于一个类的扩展排序