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