Java集合Collections和元素排序之Comparable排序接口讲解

    Collections工具类： Java里关于集合的工具类，包含有各种有关集合操作的静态多态方法，不能实例化(把构造函数私有化) 。

    和Collection的区别 : Collection是接口，提供了对集合对象进行基本操作的通用接口方法，List、Set等多种具体的实现类。Collections是工具类，专门操作Collection接口实现类里面的元素。
    常用方法： 排序 sort(List list)
   按自然排序的升序排序

    可见， 默认排序后是按字母升序输出。

package Demo_1;

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

public class SortTest {
    public static void main(String[] args) {
        sortTest();
    }
    public static void sortTest() {
      List<String> list = new ArrayList<>();
      list.add("aaa");
      list.add("yyy");
      list.add("mmm");
      list.add("ddd");
      System.out.println("排序前:" + " " + list);
      Collections.sort(list);
      System.out.println("排序后:" + " " + list);

    当数组里包括大小写，排序输出结果为先排大写，再排小写。

package Demo_1;


public class SortTest {
    public static void main(String[] args) {
        sortTest();
    }
    public static void sortTest() {
      List<String> list = new ArrayList<>();
      list.add("AAA");
      list.add("yyy");
      list.add("MMM");
      list.add("ddd");
      System.out.println("排序前:" + " " + list);
      Collections.sort(list);
      System.out.println("排序后:" + " " + list);

    默认是升序,等于Collections.sort(list)， Collections.sort(list, Comparator.naturalOrder())
    降序： Collections.sort(list,Comparator.reverseOrder());

//默认升序
       Collections.sort(list, Comparator.naturalOrder());
       System.out.println("默认升序:" + " " + list);

 //降序
       Collections.sort(list, Comparator.reverseOrder());
      System.out.println("降序:" + " " + list);

    随机排序 shuffle(List list)： 可见输出排序顺序是随机的。

//随机排序
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");
        list.add("8");
        list.add("9");
        list.add("10");
        list.add("M");
        list.add("P");
        list.add("A");
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);

    获取最大元素 max(Collection coll, Comparator comparator) 其中 Comparator 是传入一个对象。以下用一个日常订单例子，讲解它的用法。

    创建一个 Customer 类，创建它的 get/set 方法

public class CollectionsTest {

    public static void main(String [] args){

    }
}

class Customer{

    private String name;

    private int order;

    public Customer(String name,int order){
        this.name = name;
        this.order = order;
    }

    public String getName() {
        return name;
    }

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

    public int getOrder() {
        return order;
    }

    public void setOrder(int order) {
        this.order = order;
    }

}

    创建一个 List 对象

    public static void main(String [] args){

        List<Customer> list = new ArrayList<>();
        list.add(new Customer("陈小姐",25));
        list.add(new Customer("王先生",30));
        list.add(new Customer("黄小姐",33));
        list.add(new Customer("伍小姐",18));
        list.add(new Customer("李先生",42));
        System.out.println(list);

    }

    打印这个 list，结果为一堆内存地址而已。

    我们可以通过添加调试方法，去获取详细的订单信息。

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

    通过调用 toString() 方法，可以生成每个客户的订单信息。

    获取 Max 值：创建 new Comparator() ，Comparator其实就是一个接口，通过底层代码可知，o1 - o2 是升序，当 o1 - o2 > 0, 证明 o1 > o2,就一直往上排，谁大谁排最上，因此结果为最大值的42

   

    相反，要获取最小值，o2 - o1 是降序，当 o2 - o1 < 0, 证明 o2 < o1,就一直往下排，谁细谁排最下。得出最小值为 18

    另外一种自定义写法，例如再创建多一个 CustomerComparator 类，实现 Comparator 接口。

package Demo_2;

import java.util.Comparator;

public class CustomerComparator implements Comparator<CollectionsTest.Customer> {

    @Override
    public int compare(CollectionsTest.Customer o1, CollectionsTest.Customer o2) {
        return o1.getOrder()-o2.getOrder();
    }
}

    同样调用 Collections.max，传入新建的 StudentComparator 对象。

   创建不可变集合unmodifiablleXXX() , 其中 XXX 为对象集合。

    当添加新的产品时，会出现报错。

    同样，也可以创建 Set、Map

    再添加内容后，同样也有报错。

    最后，再介绍 Comparable，它是一个接口，定制排序规则。对实现它的每个类的对象进行整体排序，里面 compareTo 方法是实现排序的具体方法，例如TreeSet、SortedSet、Collections.sort() 方法调用进行排序。String、Integer等类默认实现了这个接口，所以可以排序。

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

    compareTo方法，用于比较次对象和指定对象的顺序，o为要比较的对象，返回int类型。

    大于0, 表示this大于传进来的对象o ,则往后排，即升序
    等于0，表示this等于传进来的对象o
    小于0，表示this小于传进来的对象o

    创建一个 TreeSet 容器对象，添加以上同样的客户订单信息。

    同样，创建 Customer 类，并实现Comparable接口

    覆写 compareTo() 的方法，把 Customer 强转，返回 this.order - customer.order, 表示为升序，其中 this 就是当前的元素，例如当前是 set 里面的第1个，则 this就是第1个，如此类推。

  @Override
    public int compareTo(Object o) {
        Customer customer = (Customer)o;
        return this.order - customer.order;
    }

    另外一种相对标准的覆写写法, 通过 instanceof 条件去判断。作用是判断一个类是否实现了某个接口，或者判断一个实例对象是否属于一个类。但出现 " Missing return statement" 这样的一个报错。

    compareTo() 方法，其实它默认的是 return 0， 意思是当返回的数是0时，对比的两个对象是相同的。

@Override
    public int compareTo(Object o) {
//        Customer customer = (Customer) o;
//        return this.order - customer.order;
        if (o instanceof Customer) {
            Customer customer = (Customer) o;
            return this.order - customer.order;

        }
        return 0;
    }

    同理，如果要实现降序，只需要改为 customer.order - this.order 就可以。

    @Override
    public int compareTo(Object o) {
//        Customer customer = (Customer) o;
//        return this.order - customer.order;
        if (o instanceof Customer) {
            Customer customer = (Customer) o;
//            return this.order - customer.order;
            return customer.order - this.order;

        }
        return 0;
    }

    综合这一期和上一期介绍的 Python 和 Javascript 的排序，大家可以发现虽然 Java 的写法好像相对比较复杂，但其实都有部分原理基本一样的。在不同的场景各有各的应用优点。下一期将继续通过另外一个日常项目去详解 Collections 的应用。