java.util.Collections

1、Collection使用比數組友善

例如：toString方法

String[] arr = new String[]{"A","B","C"};
		System.out.println(arr.toString());
		List<String> list = java.util.Arrays.asList(arr);
		System.out.println(list.toString());
輸出結果：
[Ljava.lang.String;@15db9742
[A, B, C]
           

2、Arrays.asList(T… t)

Arrays.asList(T… t)傳回的list是一個不可以編輯的集合對象。但是可以添加空對象，但是不可以添加“null”

Arrays.asList(T… t)方法會的list，為Arrays的内部類 ，此私有靜态内部類繼承了AbstractList，此抽象AbstractList類對于add，remove方法的時下為直接抛出"unSopportedOperationException".

String[] arr = new String[]{"A","B","C"};
		System.out.println(arr.toString());
		List<String> list = java.util.Arrays.asList(arr);
		System.out.println(list.toString());
		//抛出異常：java.lang.UnsupportedOperationException
		list.remove(1);
		//抛出異常：java.lang.UnsupportedOperationException
		list.add(null);
		//抛出異常：java.lang.NullPointerException
		list.addAll(null);
		List<String> list2 = new ArrayList<String>();
		list2.add("D");
		list.addAll(list2);
		//不抛出異常
		list.addAll(Collections.EMPTY_LIST);
           

Arrays的源碼如下：

@SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }
    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
           

AbstractList<E>源碼如下：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    public E remove(int index) {
        throw new UnsupportedOperationException();
    }
}
           

list.addAll的源碼如下，是以，在添加null元素是抛出異常“NullPointException”，添加“空的集合”時，不抛出異常，添加“有元素的集合”是，抛出“unSopportedException”

public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }
           

3、Collecionts集合操作

使用removeAll(Collection<?> c) 、containsAll(Collection<?> c) 、addAll(Collection<? extends E> c)、retainAll(Collection<?> c)  方法對集合進行操作，實作将一個集合（特别是由數組轉化而成的集合）的内容轉移到另一個集合，或者從一個較大對象集合中移除一個較小對象集合，或者判斷一個較大的集合中是否存在一個較小的集合，或者保留某一個集合中的内容。

    取代數組的循環周遊方法查找、删除、判斷有無。

    這些方法的效率遠高于自己程式寫的循環周遊方法。

4、周遊接口java.langIterator

實作了接口java.lang.Iterable中的iterator()方法傳回一個java.util.Iterator，此接口在是在[JDK1.5]版本添加，傳回一個實作了接口java.lang.Iterator [JDK1.2]的類。

我們可以随意使用 for 循環的變種，它可以在幕後處理上述所有工作，

例如：通過 Iterator 提供 Person 對象的孩子清單的一種方法。 這裡提供内部 List 的一個引用 （這使 Person 外的調用者可以為家庭增加孩子 — 而大多數父母并不希望如此），Person 類型實作 Iterable。這種方法還使得 for 循環可以周遊所有孩子。

此方法實作了對“對父母的孩子的周遊，并且無法對Person的執行個體進行添加“child Person”與删除“child Person”，并且實作了Person類的向下遞歸。

// Person.java
import java.util.*;
public class Person implements Iterable<Person>{
    public Person(String name, Person... kids){
        this.name = name;
        for (Person child : kids)
            children.add(child);
    }
    public String geName() { return this.name; }
    public Iterator<Person> iterator() { return children.iterator(); }
    public void setName(String value) { this.name = value; }
    public String toString() { 
        return "[Person: " +"name=" + name +  "]";
    }
     
    private String name;
    private List<Person> children = new ArrayList<Person>();
}
 
// App.java
public class App{
    public static void main(String[] args){
        Person ted = new Person("Ted", new Person("Michael"）， new Person("Matthew"));
        // Iterate over the kids
        for (Person kid : ted){
            System.out.println(kid.getFirstName());
        }
    }
}
           

 5、Collections的經典算法

1、反轉 reverse(List<?> list) 

翻轉指定清單中的元素的順序。

2、 排序sort(List<T> list) 

根據元素的自然順序 對指定清單按升序進行排序，數組可以使用Arrays.sort()進行排序。

3、 混排（Shuffling） 

shuffle(List<?> list)混排算法所做的正好與 sort 相反: 它打亂在一個 List 中可能有的任何排列的蹤迹。也就是說，基于随機源的輸入重排該 List, 這樣的排列具有相同的可能性（假設随機源是公正的）

4、 替換是以的元素(Fill)，

Collections.fill(li,"aaa"); 

5、 拷貝(Copy) 

copy(List<? super T> dest, List<? extends T> src) 用兩個參數，一個目标 List 和一個源 List, 将源的元素拷貝到目标，并覆寫它的内容。目标 List 至少與源一樣長。如果它更長，則在目标 List 中的剩餘元素不受影響。 

dest的長度必須大于等于src集合的長度，如果小于，則抛出IndexOfBoundsException異常。

6、min方法，

傳回Collections中最小元素(min) 

7、max方法，

傳回Collections中最小元素(max) 

8、lastIndexOfSubList方法,

傳回指定源清單中最後一次出現指定目标清單的起始位置lastIndexOfSubList(List<?> source, List<?> target)

9、indexOfSubList

indexOfSubList(List<?> source, List<?> target) 傳回指定源清單中第一次出現指定目标清單的起始位置

10、Rotate 

根據指定的距離循環移動指定清單中的元素 Collections.rotate(list,-1); 如果是負數，則正向移動，正數則方向移動 這個方法常常和List的subList方法結合使用，用于将一個list的某個或多個元素進行移動，而不破壞其餘元素的順序。例如為了将某個list的位置j的元素向前移動到k的位置。（設移動的距離為d（d >= 0），k = j + d + 1）。

Collections.rotate(list.subList(j, k+1), -1);

詳情參見：http://blog.csdn.net/u014532901/article/details/52891183  

11、nCopies(int n, T o)  

傳回由指定對象的 n 個副本組成的不可變清單。

12、reverseOrder() 

傳回一個比較器，它強行逆轉實作了 Comparable 接口的對象 collection 的自然順序

13、reverseOrder(Comparator<T> cmp) 

傳回一個比較器，它強行逆轉指定比較器的順序。

//Student類實作了Comparable接口，實作了compare方法，Collections.reverseOrder()傳回的比較器為Student比較器的反向比較器

Comparator<Student> com = Collections.reverseOrder();

        Collections.sort(list, com);

14、swap(list,i,j)

在指定清單的指定位置處交換元素。

15、 swap(List<?> list,int i, int j)

（如果指定位置相同，則調用此方法不會更改清單。）

16、binarySearch(List<? extends Comparable<? super T>> list, T key) 

使用二分搜尋法搜尋指定清單，以獲得指定對象。