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

Posted 2022-12-15 javartisan

返回指定 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 的一个动态类型安全视图。  
以上方法类似，也不解释了。