源码分析--AbstractCollection

概述：实现了一些Collection通用的方法,为其他集合类抽取了一些通用方法。

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

解释：用于判断集合中是否为空，通过size()方法，但在这个类中没有实现size()方法。（至于为啥也没清楚先记录下，等向后面再阅读具体实现list和set再做分析..）

   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;
    }

解释:判断集合中是否包含这个对象。从源码中可以看出这个集合是可以判断是否包含null的。

    public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // fewer elements than expected
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    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();
        }
        // trim if overallocated
        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;
    }

作用：将一个集合转换个数组。返回的数组是一个复制的数组。toArray()方法声明一个局部数组变量，通过判断size()和迭代器两个长度双重限制判断集合是否被完全copy到这个克隆该数组里面，如果拷贝的范围再size()范围之内，那么会调用Arrays.copyof(数组,长度)方法，通过它可以生成一个小于等于size()长度的数组，进而可以减少内存占用。如果迭代长度超过size()的长度，那么就会调用finishToArray（数组，迭代器）方法，通过这个方法可以对传进来的数组进行扩容，对于newcap新的扩容大小是cap的原长度的一半加一。（关于这点为什么加一，当长度为1，那么>>1时候就会为0，所以加1相当于扩容了。）然后会对扩容大小进行判断，如果大于MAX_ARRAY_SIZE长度，就会对数组进行大容量扩容，调用hugeCapacity（）方法，判断再初步扩容时候有没有超出具体计算机存储的最大内存容量，如果超出那么就会抛出内存溢出异常，如果没有，那么就会返回指定的扩容最大长度（此时解释下 MAX_ARRAY_SIZE =Integer.MAX_VALUE - 8，这个8中包含的是一些虚拟机在数组中保留一些头字）。数组扩容结束就会返回一些数据添加和数组中多申请的位置释放处理。

 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;
    }

作用：将一个集合中的数据生成给定类型的数组中。解释：先获取到集合的size（初始化长度，并非实际长度），判断给定的数组长度和size长度做对比，如果size大就通过反射生成集合类型的长度和size相同的数组，如果不是就把传入的数组给这个声明的局部变量泛型类型的数组（即r[]）。接下来通过迭代器判断迭代的实际集合长度，如果是a数组的长度，那么没有剩下多声明的内存区域就设置为null,如果是size长度的数组但是超出了a数组给定的长度那么就把多声明的部分进行截断节省内存吧。否则就把r中的数据拷贝到a中，如果a的长度大于实际长度多余的部分赋值为null。如果在拷贝完之后实际长度大于预计长度，那么就对其进行扩容扩容讲解如上。

疑惑！！！！！

两者区别：你一定会很困惑第二个感觉和第一个作用差不多干嘛还要第一个呢，其实第一个返回的是一个对象类型的数组,例如下面这段代码：

 Collection<String> cs=new ArrayList<String>();
        cs.add("asc");
        cs.add("ssss");
        cs.add("sssssss");
        String[] objects = (String[]) cs.toArray();
        System.out.println(Arrays.toString(objects));

运行之后其实是会报错：Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;at Main.main(Main.java:20)；不能转换的原因是:即使你在定义集合的时候已经明确了泛型的具体数据类型,但是在转换的时候你并没有告诉他使用什么类型的数据来接受,默认就是Object[]数组进行接受的.当我们获取一个Object[]的数组,这个数组可以存储任意引用类型的数据类型,数据类型变得就不再明确了.强转有可能会有问题,所以就直接抛出一个类型转换异常,阻止你进行转换. 

因此综上所述：定义生成指定类型数组时候：在定义String[]数组的时候,使用集合的长度来定义数组的长度,因为集合的长度已经定了,其元素的个数也已经定了.完美!!!

例如：

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

为什么这个不能是一个抽象方法呢？？？因为如果是抽象方法了就没有可修改和不可修改集合这么一说法了，例如调用Collections.unmodifiablexxxx()方法时候可以返回一个集合的不可修改的视图，如果进行增删改查就会抛出UnsupportedOperationException异常。个人觉得和设计模式中接口隔离原则也有关系，不会把没必要的方法暴露给客户。

 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;
    }

解释：删除集合中包含的对象（包括空值）。

   public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

解释：判断集合中是否包含这个子集合。这里的for循环非常的有趣。他的循环体包含的只有if中的语句。

   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;
    }

解释：删除集合中包含形式参数集合中的元素。

 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;
    }

解释：留下形参中共有的元素

 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(' ');
        }
    }

解释：重新实现了tostring方法，用于打印集合中的数据。可以直接对象.tostring()打印数据。如果集合里面存储的是自己那么就会打印出（this Collection）这样的数组样式;