2、Collection架构

概要

collection是个接口，它有2个分支：List和Set。

list为有序的队列，set为不可重复的集合。
collection定义了集合的基本操作，AbstractCollection抽象类实现了collection的大部分功能。

Collection中有一个iterator()方法，它的作用是返回一个Iterator接口。通常，我们通过Iterator迭代器来遍历集合。不同的集合有不同的实现。

Collection定义

public interface Collection<E> extends Iterable<E> {

        boolean isEmpty();


        boolean contains(Object o);

        Iterator<E> iterator();

        Object[] toArray();

        <T> T[] toArray(T[] a);

        boolean add(E e);


        boolean remove(Object o);


        boolean containsAll(Collection<?> c);

        boolean addAll(Collection<? extends E> c);


        boolean removeAll(Collection<?> c);

       //根据条件删除
        default boolean removeIf(Predicate<? super E> filter) {
            Objects.requireNonNull(filter);
            boolean removed = false;
            final Iterator<E> each = iterator();
            while (each.hasNext()) {
                if (filter.test(each.next())) {
                    each.remove();
                    removed = true;
                }
            }
            return removed;
        }

       //获取2个集合的交集
        boolean retainAll(Collection<?> c);

        void clear();

        boolean equals(Object o);

        int hashCode();

        @Override
        //并行遍历迭代器
        default Spliterator<E> spliterator() {
            return Spliterators.spliterator(this, 0);
        }

        //java8的函数编程
        default Stream<E> stream() {
            return StreamSupport.stream(spliterator(), false);
        }

        default Stream<E> parallelStream() {
            return StreamSupport.stream(spliterator(), true);
        }
}

AbstractCollection源码分析

AbstractCollection是个抽象类，实现了collection的大部分功能。

public abstract class AbstractCollection<E> implements Collection<E> {

    protected AbstractCollection() {
    }

  //不同的集合的实现，遍历方式不同，因此迭代器的返回依赖具体的实现。
    public abstract Iterator<E> iterator();
//同理集合的大小，依赖集合的实现方式
    public abstract int size();

    public boolean isEmpty() {
        return size() == 0;
    }

      /**
    * 1、首先判断指定的元素是否为null，如果是null，判断集合中是否包含null
    * 2、如果参数不为null，则根据equals方法查找与参数相等的元素，如果存在，则返回true，否则返回false。
    */
    public boolean contains(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

     /**
    * 将集合元素转换为数组
    * 1、创建一个数组，大小为集合中元素的数量
    * 2、通过迭代器遍历集合
    * 3、如果集合中元素比预期的少，则调用Arrays.copyOf()方法将数组的元素复制到新数组中，并返回新数组
    * 4、如果集合中元素比预期的多，则调用finishToArray方法生成新数组，并返回新数组
    */
    public Object[] toArray() {
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        //在这之间容器可能发生变化，比如容器尺寸变大，那么你只会迭代原来//的尺寸，所以循环完要看看还有没有未迭代的内容
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) //如果在得到size和迭代器之间没有发生容器的变化，则直接调用arrays.copy方法。
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }


    public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();

        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) { // fewer elements than expected
                if (a == r) {
                    r[i] = null; // null-terminate
                } else if (a.length < i) {
                    return Arrays.copyOf(r, i);
                } else {
                    System.arraycopy(r, 0, a, 0, i);
                    if (a.length > i) {
                        a[i] = null;
                    }
                }
                return a;
            }
            r[i] = (T)it.next();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }


    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;


    }
        /**当迭代器的长度大于上面得到的size的时候，就用调用这个方法把迭代器没有叠带到的部分放到数组里面，
        *把迭代器的剩下，复制到数组里面
        * 1、扩容大小：cap + cap/2 +1
        * 2、对数组进行赋值
        * 3、如果没有进行扩容则返回原来的数组
        */
    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) {
                int newCap = cap + (cap >> 1) + 1;
                // overflow-conscious code
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }
 /**
    * 扩容的元素个数是否合理
    */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError
                ("Required array size too large");
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    /**
    * 对于未实现的方法抛出异常，多出现在对空集合进行操作的时候出现
*/

    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }


    /**
    * 判断移除的元素是否为null，
    * true，遍历集合，移除集合，移除所有为null的元素
    * false，遍历集合中，移除所有相等的元素
    */
    public boolean remove(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext()) {
                if (it.next()==null) {
                    it.remove();
                    return true;
                }
            }
        } else {
            while (it.hasNext()) {
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }

    /**
    * 循环调用contains方法
*/
    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }


    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }


    /**
    * 首先判断，列表中的元素在集合中是否存在，
    * true，删除
    * false，保留
    */
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }
    /**列表中移除未包含在指定collection中的所有元素（交集）
    * 首先判断，列表中的元素在集合中是否存在
    * true，保留
    * false，移除
     */
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }
    /**
    * 循环调用remove方法
    */

    public void clear() {
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }



    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

}

public Object[] toArray()方法详解

方法签名

    /**
    * 将集合元素转换为数组
    * 1、创建一个数组，大小为集合中元素的数量
    * 2、通过迭代器遍历集合
    * 3、如果集合中元素比预期的少，则调用Arrays.copyOf()方法将数组的元素复制到新数组中，并返回新数组
    * 4、如果集合中元素比预期的多，则调用finishToArray方法生成新数组，并返回新数组
    */
 public Object[] toArray() {

            Object[] r = new Object[size()];
            Iterator<E> it = iterator();
             //在这之间容器可能发生变化，比如容器尺寸变大，那么你只会迭代原来
             //的尺寸，所以循环完要看看还有没有未迭代的内容
            for (int i = 0; i < r.length; i++) {
                if (! it.hasNext()) //
                    return Arrays.copyOf(r, i);
                r[i] = it.next();
            }
            return it.hasNext() ? finishToArray(r, it) : r;
        }

得到了size之后还有判断两次it.hasNext()

这两次判断是用来防止，在得到size()和创建迭代器之间，容器的大小发生了改变，比如容器remove和add了。

一旦获得迭代器，迭代期间容器不会发生变化，否则直接报错

概述

AbstractCollection是一个抽象类，它实现了Collection中除iterator()，add()和size()之外的所有方法。

AbstractCollection的主要作用：它实现了Collection接口中的大部分函数。从而方便其它类实现Collection，比如ArrayList、LinkedList等，它们这些类想要实现Collection接口，通过继承AbstractCollection就已经实现了大部分的接口了。