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 的应用。
