Collections：集合工具類

常用功能

java.utils.Collections是集合工具類，用來對集合進行操作。部分方法如下：

• public static <T> boolean addAll(Collection<T> c, T... elements)：往集合中添加一些元素。
• public static void shuffle(List<?> list)：打亂集合順序。
• public static <T> void sort(List<T> list)：將集合中元素按照默認規則排序。
• public static <T> void sort(List<T> list，Comparator<? super T> )：將集合中元素按照指定規則排序。

代碼演示：

import java.util.ArrayList;
import java.util.Collections;

public class Demo01Collections {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        
        Collections.addAll(list,"a","b","c","d","e");
        System.out.println(list); // [a, b, c, d, e]

        Collections.shuffle(list);
        System.out.println(list); // [b, d, c, a, e],[b, d, c, a, e]
        //排序方法 
        Collections.sort(list);
        System.out.println(list);
    }
}

結果：

[a, b, c, d, e]
[c, a, e, b, d]
[a, b, c, d, e]

集合元素排序

說到排序了，簡單的說就是兩個對象之間比較大小，那麼在java中提供了兩種比較方法:

1. 一種是比較死板的採用java.lang.Comparable接口去實現。
2. 一種是靈活的當需要做排序的時候在去選擇的java.util.Comparator接口完成。

Comparable接口

默認規則：升序

將集合中元素按照默認規則排序。【升序】

public static <T> void sort(List<T> list);

存儲的字符串類型，代碼：

public class CollectionsDemo2 {
    public static void main(String[] args) {
        ArrayList<String>  list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法
        Collections.sort(list);
        System.out.println(list);
    }
}

結果：

[aba, cba, nba, sba]

自定義排序規則

若集合裏存儲的元素是自定義類型，必須實現Comparable接口，重寫compareTo方法，自定義排序規則。

public class Person implements Comparable<Person>{ 
    
    @Override
    public int compareTo(Person o) {
 		return this.age() - o.age(): // 升序         
    }
}

排序規則:

• 自己(this) - 參數：升序

 this.getAge() - o.getAge():升序 

代碼：

Person 類

public class Person implements Comparable<Person>{ 
    private String name;
    private int age;

    // 重寫排序的規則
    @Override
    public int compareTo(Person o) {
        // 自定義比較的規則,比較兩個人的年齡(this,參數Person)
        // 年齡升序排序 | this:指調用方法的這個人 o: 傳遞參數過來的這個人
 		return this.age() - o.age(): // 升序         
        //return this.getAge() - o.getAge();  作用相同
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
	// 省略構造器和getterandSetter方法
}

測試類：

import java.util.ArrayList;
import java.util.Collections;

public class Demo02Sort {
    public static void main(String[] args) {

        ArrayList<Person> list = new ArrayList<>();
        list03.add(new Person("rose",18));
        list03.add(new Person("jack",16));
        list03.add(new Person("abc",16));
        list03.add(new Person("ace",17));
        list03.add(new Person("mark",16));
        
        // sort(List<T> list) 重寫Comparable接口
        Collections.sort(list03); // 按年齡降序
        for (Person p : list) {
            System.out.println(p);
        }
    }
}

結果：

Person{name='jack', age=16}
Person{name='abc', age=16}
Person{name='mark', age=16}
Person{name='ace', age=17}
Person{name='rose', age=18} // 按年齡降序

String類實現了這個接口（瞭解）

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    // ...
}

Comparator接口

這個接口，位於java.util包下，該接口代表一個比較器，可以將對象進行排序！

public static <T> void sort(List<T> list，Comparator<? super T> );

比較方法

• 比較其兩個參數的順序

public int compare(String o1, String o2)

演示：

		Collections.sort(list01, new Comparator<Integer>() {
            // 重寫比較的規則
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;  // 升序
               // return o2 - o1;  // 降序
            }
        });

規則

兩個對象比較的結果有三種：大於，等於，小於。

如果要按照升序排序，o1 - o2

• 返回負數：小於
• 0：相等
• 正數：大於

如果要按照降序排序，o2 - o1

• 返回負數：小於
• 0：相等
• 正數：大於

應用

按照數值排序：

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

public class Demo03Sort {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);  // [1, 3, 2]

        Collections.sort(list01, new Comparator<Integer>() {
            // 重寫比較的規則
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;  // 升序
//                return o2 - o1;  // 降序
            }
        });
        System.out.println(list01);

結果：

[1, 3, 2]
[1, 2, 3]

按照年齡排序：

Collections.sort(list, new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o2.getAge()-o1.getAge(); // 按年齡降序
    }
});

效果：

Person{name='rose', age=18}
Person{name='ace', age=17}
Person{name='jack', age=16}
Person{name='abc', age=16}
Person{name='mark', age=16} // 按年齡降序

如果想要規則更多一些，可以參考下面代碼：

Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 年齡降序
                int result = o2.getAge()-o1.getAge(); // 按年齡降序

                if(result==0){ // 若年齡相同 下一個規則 姓名的首字母 升序
                    result = o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return result;
            }
});

效果如下：

Person{name='rose', age=18}
Person{name='ace', age=17}
Person{name='abc', age=16}
Person{name='jack', age=16}
Person{name='mark', age=16} // 按年齡降序

兩個接口的區別

Comparable

1. 強行對實現它的每個類的對象進行整體排序。這種排序被稱爲類的自然排序
2. 類的compareTo方法被稱爲它的自然比較方法。只能在類中實現compareTo()一次，不能經常修改類的代碼實現自己想要的排序。
3. 實現此接口的對象列表（和數組）可以通過Collections.sort（和Arrays.sort）進行自動排序，對象可以用作有序映射中的鍵或有序集合中的元素，無需指定比較器。
4. 自己和別人（參數）比較，自己需要實現Comparable接口，重寫比較規則compareTo方法

Comparator

1. 強行對某個對象進行整體排序。可以將Comparator 傳遞給sort方法（如Collections.sort或 Arrays.sort），從而允許在排序順序上實現精確控制。
2. 還可以使用Comparator來控制某些數據結構（如有序set或有序映射）的順序，或者爲那些沒有自然順序的對象collection提供排序。
3. 找一個第三方裁判，來比較兩個人