Java之Collections工具类方法使用以及源码分析(三)

返回指定 collection 的一个动态类型安全视图。试图插入一个错误类型的元素将导致立即抛出 ClassCastException。假设在生成动态类型安全视图之前，collection 不包含任何类型不正确的元素，并且所有对该 collection 的后续访问都通过该视图进行，则可以保证 该 collection 不包含类型不正确的元素。 

    public static <E> Collection<E> checkedCollection(Collection<E> c,Class<E> type)

调用该方法时候会进行类型检查，如果类型不匹配抛出ClassCastException异常。

package com.daxin.collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

/**
* 返回指定 collection 的一个动态类型安全视图。试图插入一个错误类型的元素将导致立即抛出
* ClassCastException。假设在生成动态类型安全视图之前，collection 不包含任何类型不正确的元素，并且所有对该 collection
* 的后续访问都通过该视图进行，则可以保证 该 collection 不包含类型不正确的元素。
*/
public class Main10 {

public static void main(String[] args) {

ArrayList<Integer> list = new ArrayList<>();

for (int i = 1; i <= 5; i++) {

list.add(i);
}

Collection<Integer> view = Collections.checkedCollection(list, Integer.class);

System.out.println(view);

view.add(11);
view.add(12);
view.add(13);

System.out.println(view);

System.out.println(list);

}

}

 java.util.Collections.checkedCollection(Collection<Integer>, Class<Integer>)的实现：

public static <E> Collection<E> checkedCollection(Collection<E> c,
Class<E> type) {
return new CheckedCollection<>(c, type);
}

 CheckedCollection的实现;

/**
* @serial include
*/
static class CheckedCollection<E> implements Collection<E>, Serializable {
private static final long serialVersionUID = 1578914078182001775L;

final Collection<E> c;
final Class<E> type;

void typeCheck(Object o) {
if (o != null && !type.isInstance(o))
throw new ClassCastException(badElementMsg(o));
}

private String badElementMsg(Object o) {
return "Attempt to insert " + o.getClass() +
" element into collection with element type " + type;
}

CheckedCollection(Collection<E> c, Class<E> type) {
if (c==null || type == null)
throw new NullPointerException();
this.c = c;
this.type = type;
}

public int size()                 { return c.size(); }
public boolean isEmpty()          { return c.isEmpty(); }
public boolean contains(Object o) { return c.contains(o); }
public Object[] toArray()         { return c.toArray(); }
public <T> T[] toArray(T[] a)     { return c.toArray(a); }
public String toString()          { return c.toString(); }
public boolean remove(Object o)   { return c.remove(o); }
public void clear()               {        c.clear(); }

public boolean containsAll(Collection<?> coll) {
return c.containsAll(coll);
}
public boolean removeAll(Collection<?> coll) {
return c.removeAll(coll);
}
public boolean retainAll(Collection<?> coll) {
return c.retainAll(coll);
}

public Iterator<E> iterator() {
final Iterator<E> it = c.iterator();
return new Iterator<E>() {
public boolean hasNext() { return it.hasNext(); }
public E next()          { return it.next(); }
public void remove()     {        it.remove(); }};
}

public boolean add(E e) {
typeCheck(e);
return c.add(e);
}

private E[] zeroLengthElementArray = null; // Lazily initialized

private E[] zeroLengthElementArray() {
return zeroLengthElementArray != null ? zeroLengthElementArray :
(zeroLengthElementArray = zeroLengthArray(type));
}

@SuppressWarnings("unchecked")
Collection<E> checkedCopyOf(Collection<? extends E> coll) {
Object[] a = null;
try {
E[] z = zeroLengthElementArray();
a = coll.toArray(z);
// Defend against coll violating the toArray contract
if (a.getClass() != z.getClass())
a = Arrays.copyOf(a, a.length, z.getClass());
} catch (ArrayStoreException ignore) {
// To get better and consistent diagnostics,
// we call typeCheck explicitly on each element.
// We call clone() to defend against coll retaining a
// reference to the returned array and storing a bad
// element into it after it has been type checked.
a = coll.toArray().clone();
for (Object o : a)
typeCheck(o);
}
// A slight abuse of the type system, but safe here.
return (Collection<E>) Arrays.asList(a);
}

public boolean addAll(Collection<? extends E> coll) {
// Doing things this way insulates us from concurrent changes
// in the contents of coll and provides all-or-nothing
// semantics (which we wouldn't get if we type-checked each
// element as we added it)
return c.addAll(checkedCopyOf(coll));
}
}

 注意查看add方法，进行了类型检查:

public boolean add(E e) {
typeCheck(e);
return c.add(e);
}

 查看typeCheck方法实现：

void typeCheck(Object o) {
if (o != null && !type.isInstance(o))
throw new ClassCastException(badElementMsg(o));
}

代码很简单，不做解释！！

 static <E> List<E>  checkedList(List<E> list, Class<E> type) 

          返回指定列表的一个动态类型安全视图。 

static <K,V> Map<K,V>  checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType) 

          返回指定映射的一个动态类型安全视图。 

static <E> Set<E>  checkedSet(Set<E> s, Class<E> type) 

          返回指定 set 的一个动态类型安全视图。 

static <K,V> SortedMap<K,V>  checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType) 

          返回指定有序映射的一个动态类型安全视图。 

static <E> SortedSet<E>  checkedSortedSet(SortedSet<E> s, Class<E> type) 

          返回指定有序 set 的一个动态类型安全视图。  

以上方法类似，也不解释了。