排序类

Comparable

Comparable<T> 接口的作用就是定义了一种 “自然顺序”。 实现了Comparable接口的类，它的对象就可以相互比较大小了。

INFO

实现 Complarable 接口之后，需要重写 compareTo() 方法，该方法返回一个 int 类型的值：

• 如果当前对象比参数对象大，返回一个正数，如 1。
• 如果当前对象比参数对象小，返回一个负数，如 -1。
• 如果两个对象相等，返回 0。

单个对象比较

@Test
public void junitTest1() {
  Product p1 = new Product("Huawei", 6999);
  Product p2 = new Product("Xiaomi", 4999);

  int i1 = p1.compareTo(p2); //1，表示 p1 大
  int i2 = p2.compareTo(p1); //-1，表示 p2 大
}

数组比较

@Test
public void junitTest2() {
  Product[] arr = new Product[5];
  arr[0] = new Product("Huawei", 6999.5);
  arr[1] = new Product("xiaomi", 6999.4);
  arr[2] = new Product("OPPO", 3499);
  arr[3] = new Product("vivo", 3499);
  arr[4] = new Product("Iphone", 7999);

  Arrays.sort(arr); //sort方法会调用 Product 类中的 compareTo 方法
  for (Product product : arr) {
    System.out.println(product);
  }
}

product

public class Product implements Comparable<Product> {
  private String name;
  private double price;

  public Product(String name, double price) {
    this.name = name;
    this.price = price;
  }

  @Override
  public String toString() {
    return "Product{" +
      "name='" + name + '\'' +
      ", price=" + price +
      '}';
  }

  @Override
  public int compareTo(Product other) {
    if (this == other) return 0;
    //先按照价格从小到大排序
    int value = Double.compare(this.price, other.price);
    //如果从大到小排序，可以在前面添加 - 号取相反数
    //int value = -Double.compare(this.price, other.price);
    //如果价格相同，再按照名字排序
    if (value == 0) {
      return this.name.compareTo(other.name);
    }
    return value;
  }
}

Comparator

Comparator<T> 接口允许我们按照自定义的规则对对象进行排序。

Comparator 接口提供了一个 compare(Object o1, Object o2) 方法，通过实现这个方法，我们可以指定两个对象之间的大小关系。

• 方式一：具体类继承Comparator接口

  Test

  @Test
  public void junitTest1() {
    PriceComparator[] arr = new PriceComparator[5];
    arr[0] = new PriceComparator("Huawei", 6999.5);
    arr[1] = new PriceComparator("xiaomi", 6999.4);
    arr[2] = new PriceComparator("OPPO", 3499);
    arr[3] = new PriceComparator("vivo", 3499);
    arr[4] = new PriceComparator("Iphone", 7999);
  
    Arrays.sort(arr, new PriceComparator());
  
    for (PriceComparator p : arr) {
      System.out.println(p);
    }
  }

  PriceComparator

  class PriceComparator implements Comparator<PriceComparator> {
    private String name;
    private double price;
  
    public PriceComparator() {
    }
  
    public PriceComparator(String name, double price) {
      this.name = name;
      this.price = price;
    }
  
    @Override
    public String toString() {
      return "PriceComparator{" +
        "name='" + name + '\'' +
        ", price=" + price +
        '}';
    }
  
    @Override
    public int compare(PriceComparator o1, PriceComparator o2) {
      //从大到小排列
      return -Double.compare(o1.price, o2.price);
    }
  }

• 方式二：使用匿名对象

  @Test
  public void junitTest() {
    Product[] arr = new Product[5];
    arr[0] = new Product("Huawei", 6999.5);
    arr[1] = new Product("xiaomi", 6999.4);
    arr[2] = new Product("OPPO", 3499);
    arr[3] = new Product("vivo", 3499);
    arr[4] = new Product("Iphone", 7999);
  
    //创建 Comparator 接口
    Comparator<Product> comparator = new Comparator<Product>() {
      @Override
      public int compare(Product o1, Product o2) {
        return Double.compare(o1.getPrice(), o2.getPrice());
      }
    };
    //上面的写法可以使用 lanmda 表达式简化
    Comparator<Product> comparator1 = (o1, o2) -> Double.compare(o1.getPrice(), o2.getPrice());
    
    //进行比较
    Arrays.sort(arr, comparator1);
  
    for (Product p : arr) {
      System.out.println(p);
    }
  }