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) 

使用二分搜索法搜索指定列表，以获得指定对象。