1、Arrays類

Arrays類常用方法概述：
本類所有方法都是靜態的，本類方法是針對陣列的操作。

//部分Arrays的靜態方法（JDK1.8）
static <T> List<T> asList(T... a) 
返回由指定陣列支援的固定大小的列表。 

static int binarySearch(byte[] a, byte key) 
使用二進位制搜尋演算法搜尋指定值的指定位元組陣列。  

static int[] copyOf(int[] original, int newLength) 
複製指定的陣列，用零擷取或填充（如有必要），以便複製具有指定的長度。  

static
 
 int[] copyOfRange(int[] original, int from, int to) 
將指定陣列的指定範圍複製到新陣列中。  

static boolean deepEquals(Object[] a1, Object[] a2) 
如果兩個指定的陣列彼此 深度相等 ，則返回 true 。 

static int deepHashCode(Object[] a) 
根據指定陣列的“深度內容”返回雜湊碼。  

static String deepToString(Object[] a) 
返回指定陣列的“深度內容”的字串表示形式。  

static boolean equals(int
 
[] a, int[] a2) 
如果兩個指定的int陣列彼此 相等 ，則返回 true 。  

static void fill(int[] a, int val) 
將指定的int值分配給指定的int陣列的每個元素。  

static int hashCode(int[] a) 
根據指定陣列的內容返回雜湊碼。  

static void parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op) 
對於陣列的給定子範圍執行 parallelPrefix(int[], IntBinaryOperator) 。  

static
 
 void parallelSetAll(int[] array, IntUnaryOperator generator) 
使用提供的生成函式來並行設定指定陣列的所有元素來計算每個元素。  

static void parallelSort(int[] a) 
按照數字順序排列指定的陣列。  

static void setAll(int[] array, IntUnaryOperator generator) 
使用提供的生成函式來計算每個元素，設定指定陣列的所有元素。  

static void sort(int[] a, int fromIndex, int toIndex) 
按升序排列陣列的指定範圍。  

static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive) 
返回Spliterator.OfInt覆蓋指定陣列的指定範圍內。  

static IntStream stream(int[] array) 
返回順序IntStream與指定的陣列作為源。  

static String toString(int[] a) 
返回指定陣列的內容的字串表示形式。  

1.1Arrays常用方法例項

asList

這個方法可以把陣列轉換成List,List提供了很多的操作方法，更便於使用。

        String[] array = new String[]{"a","c","2","1","b"};
        Integer[] ints = new Integer[]{5,1,4,3,2};
        List<String> lists = Arrays.asList(array);
        List<Integer> lints = Arrays.asList(ints);
        System.out.println(lists);
        System.out.println(lints);

執行結果：

[a, c, 2, 1, b]
[5, 1, 4, 3, 2]

sort排序和parallelSort並行排序

sort比較常用了，根據元素按照自然排序規則排序，也可以設定排序元素的起始位置。

        Arrays.sort(array);
        for(String str : array){
            System.out.print(str);
        }
        Arrays.sort(array,2,5);
        System.out.println(Arrays.deepToString(array));

執行結果：

12abc
[1, 2, a, b, c]

parallelSort則採用並行的排序演算法排序.但是我自己測試，可能資料量太小，速度上並沒有明顯的變化。

binarySearch

查詢目標元素所在的位置，注意需要先進行排序。

        //binarySearch需要保證是排好序的
        System.out.println(Arrays.binarySearch(array,"c"));//-6
        Arrays.sort(array);
        System.out.println(Arrays.binarySearch(array,"c"));//4

copyOf

拷貝陣列，第一種用法，如果目標長度不夠，會使用0進行補位。第二種用法，支援拷貝目標起始位置到結束為止的陣列。

       //如果位數不夠，需要補位
        Integer[] result = Arrays.copyOf(ints,10);
        for(int i=0;i<result.length;i++){
            System.out.print(result[i]+" ");
        }
        System.out.println();
        //如果位數夠，就取最小的陣列
        result = Arrays.copyOf(ints,3);
        for(int i : result){
            System.out.print(i+" ");
        }
        System.out.println();
        result = Arrays.copyOfRange(ints,2,4);
        for(int i : result){
            System.out.print(i+" ");
        }

執行結果：

5 1 4 3 2 null null null null null 
5 1 4 
4 3 

deepEquals深度比較、deepHashCode生成hashcode、deepToString深度列印

這幾個方法基本都是採用遞迴的寫法使用。

String[] array2 = new String[]{"a","c","2","1","b"};
System.out.println(Arrays.deepEquals(array,array2));//深度比較兩個陣列是否相同
System.out.println(Arrays.deepHashCode(array));
System.out.println(Arrays.deepHashCode(array2));//如果兩個陣列deepEquals，那麼他們的hashcode一定相同

//格式化輸出陣列
System.out.println(Arrays.deepToString(array));

執行結果：

true
121209664
121209664
[a, c, 2, 1, b]

equals比較

對比兩個陣列是否相等。

        String[] array2 = new String[]{"a","c","2","1","b"};

        //1 對比引用是否相同
        //2 對比是否存在null
        //3 對比長度是否相同
        //4 挨個元素對比
        System.out.println(Arrays.equals(array,array2));//true

fill

基於目標元素填充陣列

        Arrays.fill(array,"test");
        System.out.println(Arrays.deepToString(array));//[test, test, test, test, test]

toString

列印陣列元素

System.out.println(Arrays.toString(array));//[a, c, 2, 1, b]

toStream

把陣列轉換成stream,然後可以使用java8的stream特性了。

Arrays.stream(array).forEach(s-> System.out.println(s));

parallelPrefix

這個有點像spark的reduceByKey，即根據傳入的方法一次計算：

 Arrays.parallelPrefix(ints,(x,y)->(x+y));
 System.out.println(Arrays.deepToString(ints));//[5, 6, 10, 13, 15]

2、Collections類

Collections常用方法概述：
本類所有方法都是靜態的，本類方法都是針對集合的操作。

//部分Collections的靜態方法（JDK1.8）
static <T> boolean addAll(Collection<? super T> c, T... elements) 
將所有指定的元素新增到指定的集合。  

static <T> Queue<T> asLifoQueue(Deque<T> deque) 
返回Deque作為先進先出（ Lifo ） Queue的檢視 。

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 
使用二叉搜尋演算法搜尋指定物件的指定列表。  

static <E> Collection<E> checkedCollection(Collection<E> c, 類<E> type) 
返回指定集合的動態型別安全檢視。  

static <E> List<E> checkedList(List<E> list, 類<E> type) 
返回指定列表的動態型別安全檢視。  

static <K,V> Map<K,V> checkedMap(Map<K,V> m, 類<K> keyType, 類<V> valueType) 
返回指定地圖的動態型別安全檢視。 

static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m,
 類<K> keyType, 類<V> valueType) 
返回指定可導航地圖的動態型別安全檢視。  

static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, 類<E> type) 
返回指定的可導航集的動態型別安全檢視。 

static <E> Queue<E> checkedQueue(Queue<E> queue, 類<E> type) 
返回指定佇列的動態型別安全檢視。  

static <E> Set<E> checkedSet(Set<E> s, 類<E> type) 
返回指定集合的動態型別安全檢視。  

static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, 類<K> keyType, 類<V> valueType) 
返回指定排序對映的動態型別安全檢視。 

static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, 類<E> type) 
返回指定排序集的動態型別安全檢視。  

static <T> void copy(List<? super T> dest, List<? extends T> src) 
將所有元素從一個列表複製到另一個列表中。  

static boolean disjoint(Collection<?> c1, Collection<?> c2) 
如果兩個指定的集合沒有共同的元素，則返回 true 。

static <T> Enumeration<T> emptyEnumeration() 
返回沒有元素的列舉。  

static <T> Iterator<T> emptyIterator() 
返回沒有元素的迭代器。  

static <T> List<T> emptyList() 
返回空列表（immutable）。

static <T> ListIterator<T> emptyListIterator() 
返回沒有元素的列表迭代器。  

static <K,V> Map<K,V> emptyMap() 
返回空的地圖（不可變）。  

static <K,V> NavigableMap<K,V> emptyNavigableMap() 
返回空導航地圖（不可變）。

static <E> NavigableSet<E> emptyNavigableSet() 
返回一個空導航集（immutable）。 

static <T> Set<T> emptySet() 
返回一個空集（immutable）。

static <K,V> SortedMap<K,V> emptySortedMap() 
返回空的排序對映（immutable）。

static <E> SortedSet<E> emptySortedSet() 
返回一個空的排序集（immutable）。 

static <T> Enumeration<T> enumeration(Collection<T> c) 
返回指定集合的列舉。  

static <T> void fill(List<? super T> list, T obj) 
用指定的元素代替指定列表的所有元素。

static int frequency(Collection<?> c, Object o) 
返回指定集合中與指定物件相等的元素數。 

static int indexOfSubList(List<?> source, List<?> target) 
返回指定源列表中指定目標列表的第一次出現的起始位置，如果沒有此類事件，則返回-1。 

static int lastIndexOfSubList(List<?> source, List<?> target) 
返回指定源列表中指定目標列表的最後一次出現的起始位置，如果沒有此類事件則返回-1。 

static <T> ArrayList<T> list(Enumeration<T> e) 
返回一個數組列表，其中包含由列舉返回的順序由指定的列舉返回的元素。 

static <T extends Object & Comparable<? super T>>
T max(Collection<? extends T> coll) 
根據其元素的 自然順序返回給定集合的最大元素。  

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 
根據指定的比較器引發的順序返回給定集合的最大元素。 

static <T extends Object & Comparable<? super T>>
T min(Collection<? extends T> coll) 
根據其元素的 自然順序返回給定集合的最小元素。  

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) 
根據指定的比較器引發的順序返回給定集合的最小元素。  

static <T> List<T> nCopies(int n, T o) 
返回由指定物件的 n副本組成的不可變列表。  

static <E> Set<E> newSetFromMap(Map<E,Boolean> map) 
返回由指定地圖支援的集合。  

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
將列表中一個指定值的所有出現替換為另一個。  

static void reverse(List<?> list) 
反轉指定列表中元素的順序。  

static <T> Comparator<T> reverseOrder() 
返回一個比較器，它對實現 Comparable介面的物件集合施加了 自然排序的相反。  

static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
返回一個比較器，它強制指定比較器的反向排序。  

static void rotate(List<?> list, int distance) 
將指定列表中的元素旋轉指定的距離。  

static void shuffle(List<?> list) 
使用預設的隨機源隨機排列指定的列表。

static void shuffle(List<?> list, Random rnd) 
使用指定的隨機源隨機排列指定的列表。  

static <T> Set<T> singleton(T o) 
返回一個只包含指定物件的不可變集。 

static <T> List<T> singletonList(T o) 
返回一個只包含指定物件的不可變列表。 

static <K,V> Map<K,V> singletonMap(K key, V value) 
返回一個不可變的地圖，只將指定的鍵對映到指定的值。 

static <T extends Comparable<? super T>>
void sort(List<T> list) 
根據其元素的natural ordering對指定的列表進行排序。  

static <T> void sort(List<T> list, Comparator<? super T> c) 
根據指定的比較器引起的順序對指定的列表進行排序。  

static void swap(List<?> list, int i, int j) 
交換指定列表中指定位置的元素。  

static <T> Collection<T> synchronizedCollection(Collection<T> c) 
返回由指定集合支援的同步（執行緒安全）集合。  

static <T> List<T> synchronizedList(List<T> list) 
返回由指定列表支援的同步（執行緒安全）列表。 

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 
返回由指定地圖支援的同步（執行緒安全）對映。 

static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) 
返回由指定的可導航地圖支援的同步（執行緒安全）可導航地圖。 

static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) 
返回由指定的可導航集支援的同步（執行緒安全）可導航集。 

static <T> Set<T> synchronizedSet(Set<T> s) 
返回由指定集合支援的同步（執行緒安全）集。  

static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) 
返回由指定的排序對映支援的同步（執行緒安全）排序對映。

static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) 
返回由指定的排序集支援的同步（執行緒安全）排序集。

static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) 
返回指定集合的不可修改檢視。  

static <T> List<T> unmodifiableList(List<? extends T> list) 
返回指定列表的不可修改檢視。

static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m) 
返回指定地圖的不可修改檢視。  

static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m) 
返回指定可導航地圖的不可修改檢視。

static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) 
返回指定的可導航集合的不可修改的檢視。

static <T> Set<T> unmodifiableSet(Set<? extends T> s) 
返回指定集合的不可修改檢視。  

static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m) 
返回指定排序對映的不可修改檢視。 

static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) 
返回指定排序集的不可修改檢視。 

Collections的常用方法

排序（Sort）

使用sort方法可以根據元素的自然順序 對指定列表按升序進行排序。列表中的所有元素都必須實現 Comparable 介面。此列表內的所有元素都必須是使用指定比較器可相互比較的

double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.sort(list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//結果：112,111,23,456,231

混排（Shuffling）

混排演算法所做的正好與 sort 相反： 它打亂在一個 List 中可能有的任何排列的蹤跡。也就是說，基於隨機源的輸入重排該 List，這樣的排列具有相同的可能性（假設隨機源是公正的）。這個演算法在實現一個碰運氣的遊戲中是非常有用的。例如，它可被用來混排代表一副牌的 Card 物件的一個 List .另外，在生成測試案例時，它也是十分有用的。

Collections.Shuffling(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.shuffle(list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//結果：112,111,23,456,231

反轉（Reverse）

使用Reverse方法可以根據元素的自然順序 對指定列表按降序進行排序。

Collections.reverse(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections. reverse (list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//結果：231,456,23,111,112

替換所有的元素（Fill）

使用指定元素替換指定列表中的所有元素。

String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new String(str[j]));
}
Collections.fill(li,"aaa");
for (int i = 0; i < li.size(); i++) {
System.out.println("list[" + i + "]=" + li.get(i));

}
//結果：aaa,aaa,aaa,aaa,aaa

拷貝（Copy）

用兩個引數，一個目標 List 和一個源 List， 將源的元素拷貝到目標，並覆蓋它的內容。目標 List 至少與源一樣長。如果它更長，則在目標 List 中的剩餘元素不受影響。

Collections.copy（list，li）： 後面一個引數是目標列表 ，前一個是源列表
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {1131,333};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new Double(arr[j]));
}
Collections.copy(list,li);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//結果：1131,333,23,456,231

返回Collections中最小元素（min）

根據指定比較器產生的順序，返回給定 collection 的最小元素。collection 中的所有元素都必須是通過指定比較器可相互比較的

Collections.min(list)
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.min(list);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//結果：23

返回Collections中最大元素（max）

根據指定比較器產生的順序，返回給定 collection 的最大元素。collection 中的所有元素都必須是通過指定比較器可相互比較的

Collections.max(list)
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.max(list);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//結果：456

lastIndexOfSubList

返回指定源列表中最後一次出現指定目標列表的起始位置，即按從後到前的順序返回子List在父List中的索引位置。

int count = Collections.lastIndexOfSubList(list,li);
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {111};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new Double(arr[j]));
}
Int locations = Collections. lastIndexOfSubList (list,li);
System.out.println(“===”+ locations);
//結果 3

IndexOfSubList

返回指定源列表中第一次出現指定目標列表的起始位置

int count = Collections.indexOfSubList(list,li);
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {111};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new Double(arr[j]));
}
Int locations = Collections.indexOfSubList(list,li);
System.out.println(“===”+ locations);
//結果 1

Rotate

根據指定的距離迴圈移動指定列表中的元素

Collections.rotate（list，-1）；

如果是負數，則正向移動，正數則方向移動
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.rotate(list,-1);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//結果：111,23,456,231,112