摘要：類比根據定制排序，返回最大元素，排序規則由類控制。返回指定支持的同步線程安全的。將返回的列表更改為寫入數組。字符串表示由數組元素的列表組成，括在方括號中。
1. Collections類的常見操作：
1.1. 排序操作：
集合類庫使用的是歸并排序比快速排序要慢一些，快速排序是通用排序算法的傳統選擇。但是，歸并排序有一個主要的優點就是穩定。
void reverse(List list)//反轉
void shuffle(List list)//隨機排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由Comparator控制排序邏輯
void swap(List list, int i , int j)//交換兩個索引位置的元素
void rotate(List list, int distance)//旋轉。當distance為正數時，將list后distance個元素整體移到前面。當distance為負數時，將 list的前distance個元素整體移到后面。
示例代碼：
ArrayList arrayList = new ArrayList();
arrayList.add(-1);
arrayList.add(3);
arrayList.add(3);
arrayList.add(-5);
arrayList.add(7);
arrayList.add(4);
arrayList.add(-9);
arrayList.add(-7);
System.out.println("原始數組:");
System.out.println(arrayList);
// void reverse(List list)：反轉
Collections.reverse(arrayList);
System.out.println("Collections.reverse(arrayList):");
System.out.println(arrayList);
Collections.rotate(arrayList, 4);
System.out.println("Collections.rotate(arrayList, 4):");
System.out.println(arrayList);
// void sort(List list),按自然排序的升序排序
Collections.sort(arrayList);
System.out.println("Collections.sort(arrayList):");
System.out.println(arrayList);
// void shuffle(List list),隨機排序
Collections.shuffle(arrayList);
System.out.println("Collections.shuffle(arrayList):");
System.out.println(arrayList);
// 定制排序的用法
Collections.sort(arrayList, new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
});
System.out.println("定制排序后：");
System.out.println(arrayList);
1.2. 查找，替換操作：
int binarySearch(List list, Object key)//對List進行二分查找，返回索引，注意List必須是有序的
int max(Collection coll)//根據元素的自然順序，返回最大的元素。 類比int min(Collection coll)
int max(Collection coll, Comparator c)//根據定制排序，返回最大元素，排序規則由Comparatator類控制。類比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。
int frequency(Collection c, Object o)//統計元素出現次數
int indexOfSubList(List list, List target)//統計targe在list中第一次出現的索引，找不到則返回-1，類比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替換舊元素
示例代碼：
ArrayList arrayList = new ArrayList();
arrayList.add(-1);
arrayList.add(3);
arrayList.add(3);
arrayList.add(-5);
arrayList.add(7);
arrayList.add(4);
arrayList.add(-9);
arrayList.add(-7);
ArrayList arrayList2 = new ArrayList();
arrayList2.add(-3);
arrayList2.add(-5);
arrayList2.add(7);
System.out.println("原始數組:");
System.out.println(arrayList);
System.out.println("Collections.max(arrayList):");
System.out.println(Collections.max(arrayList));
System.out.println("Collections.min(arrayList):");
System.out.println(Collections.min(arrayList));
System.out.println("Collections.replaceAll(arrayList, 3, -3):");
Collections.replaceAll(arrayList, 3, -3);
System.out.println(arrayList);
System.out.println("Collections.frequency(arrayList, -3):");
System.out.println(Collections.frequency(arrayList, -3));
System.out.println("Collections.indexOfSubList(arrayList, arrayList2):");
System.out.println(Collections.indexOfSubList(arrayList, arrayList2));
System.out.println("Collections.binarySearch(arrayList, 7):");
// 對List進行二分查找，返回索引，List必須是有序的
Collections.sort(arrayList);
System.out.println(Collections.binarySearch(arrayList, 7));
1.3. 同步控制：
Collectons提供了多個synchronizedXxx()方法·，該方法可以將指定集合包裝成線程同步的集合，從而解決多線程并發訪問集合時的線程安全問題。
我們知道HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap都是線程不安全的。Collections提供了多個靜態方法可以把他們包裝成線程同步的集合。
方法如下：
synchronizedCollection(Collection c) //返回指定 collection 支持的同步（線程安全的）collection。
synchronizedList(List list)//返回指定列表支持的同步（線程安全的）List。
synchronizedMap(Map m) //返回由指定映射支持的同步（線程安全的）Map。
synchronizedSet(Set s) //返回指定 set 支持的同步（線程安全的）set。
1.4. 設置不可變集合：
emptyXxx(): 返回一個空的、不可變的集合對象，此處的集合既可以是：List，Set，Map.如emptyList（）：返回空列表（immutable）， 此列表是可序列化的。
singletonXxx(): 返回一個只包含指定對象（只有一個或一個元素）的不可變的集合對象，此處的集合可以是：List，Set，Map。如：singletonList(T o)：返回一個只包含指定對象的不可變列表。，返回的列表是可序列化的。
unmodifiableXxx(): 返回指定集合對象的不可變視圖，此處的集合可以是：List，Set，Map。如：unmodifiableList(List list)：返回指定列表的不可修改視圖。
上面三類方法的參數是原有的集合對象，返回值是該集合的"只讀"版本。
1. Arrays類的常見操作：
排序 :sort()
查找 :binarySearch()
比較: equals
填充 :fill
轉列表: asList()
哈希:hashCode()
轉字符串 :toString()
示例代碼：
/**
* TODO Arrays類方法測試
* 包含用于操作數組的各種方法（如排序和搜索）。 該類還包含一個靜態工廠，可以將數組視為列表。
* 如果指定的數組引用為空，則該類中的方法都拋出一個NullPointerException ，除非另有說明。
* @author 寇爽
* @date 2017年11月20日
* @version 1.8
*/
public class ArraysMethodsDemo {
public static void main(String[] args) {
// *************排序 sort****************
int a[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
// sort(int[] a)方法按照數字順序排列指定的數組。
Arrays.sort(a);
System.out.println("Arrays.sort(a):");
for (int i : a) {
System.out.print(i);
}
// 換行
System.out.println();
// sort(int[] a,int fromIndex,int toIndex)按升序排列數組的指定范圍
int b[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
Arrays.sort(b, 2, 6);
System.out.println("Arrays.sort(b, 2, 6):");
for (int i : b) {
System.out.print(i);
}
// 換行
System.out.println();
int c[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
// parallelSort(int[] a) 按照數字順序排列指定的數組。同sort方法一樣也有按范圍的排序
Arrays.parallelSort(c);
System.out.println("Arrays.parallelSort(c)：");
for (int i : c) {
System.out.print(i);
}
// 換行
System.out.println();
// parallelSort給字符數組排序，sort也可以
char d[] = { "a", "f", "b", "c", "e", "A", "C", "B" };
Arrays.parallelSort(d);
System.out.println("Arrays.parallelSort(d)：");
for (char d2 : d) {
System.out.print(d2);
}
// 換行
System.out.println();
// *************查找 binarySearch()****************
char[] e = { "a", "f", "b", "c", "e", "A", "C", "B" };
System.out.println("Arrays.binarySearch(e, "c")：");
int s = Arrays.binarySearch(e, "c");
System.out.println("字符c在數組的位置：" + s);
// *************比較 equals****************
char[] f = { "a", "f", "b", "c", "e", "A", "C", "B" };
/*
* 元素數量相同，并且相同位置的元素相同。 另外，如果兩個數組引用都是null，則它們被認為是相等的 。
*/
// 輸出true
System.out.println("Arrays.equals(e, f):" + Arrays.equals(e, f));
// 輸出false，因為數組d已經被排過序，所以數組d和e雖然由相同元素構成，但是相同位置的元素不同
System.out.println("Arrays.equals(d, e):" + Arrays.equals(d, e));
// *************填充fill(批量初始化)****************
int[] g = { 1, 2, 3, 3, 3, 3, 6, 6, 6 };
// 數組中所有元素重新分配值
Arrays.fill(g, 3);
System.out.println("Arrays.fill(g, 3)：");
// 輸出結果：333333333
for (int i : g) {
System.out.print(i);
}
// 換行
System.out.println();
int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
// 數組中指定范圍元素重新分配值
Arrays.fill(h, 0, 2, 9);
System.out.println("Arrays.fill(h, 0, 2, 9);：");
// 輸出結果：993333666
for (int i : h) {
System.out.print(i);
}
// 換行
System.out.println();
// *************復制copy****************
// copyOf方法實現數組復制,h為數組，6為復制的長度
int i[] = Arrays.copyOf(h, 6);
System.out.println("Arrays.copyOf(h, 6);：");
// 輸出結果：993333
for (int j : i) {
System.out.print(j);
}
// 換行
System.out.println();
// copyOfRange將指定數組的指定范圍復制到新數組中
int j[] = Arrays.copyOfRange(h, 6, 11);
System.out.println("Arrays.copyOfRange(h, 6, 11)：");
// 輸出結果66600(h數組只有9個元素這里是從索引6到索引11復制所以不足的就為0)
for (int j2 : j) {
System.out.print(j2);
}
// 換行
System.out.println();
// *************轉列表 asList()****************
/*
* 返回由指定數組支持的固定大小的列表。
* （將返回的列表更改為“寫入數組”。）該方法作為基于數組和基于集合的API之間的橋梁，與Collection.toArray()相結合 。
* 返回的列表是可序列化的，并實現RandomAccess 。
* 此方法還提供了一種方便的方式來創建一個初始化為包含幾個元素的固定大小的列表如下：
*/
List stooges = Arrays.asList("Larry", "Moe", "Curly");
System.out.println(stooges);
// *************哈希 Hash()****************
char[] k = { "a", "f", "b", "c", "e", "A", "C", "B" };
// 輸出數組k的hash值
System.out.println(Arrays.hashCode(k));
// *************轉字符串 toString()****************
/*
* 返回指定數組的內容的字符串表示形式。 字符串表示由數組元素的列表組成，括在方括號（ "[]" ）中。
* 相鄰的元素由字符", "分隔（逗號后跟一個空格）。 元素被轉換為字符串由String.valueOf(int)。
* 返回"null"如果a是null。
*/
// 輸出結果：[a, f, b, c, e, A, C, B]
System.out.println(Arrays.toString(k));
}
}
