Java 集合深入理解 ：AbstractCollection类

Posted 2021-07-16 踩踩踩从踩

Java 集合深入理解 （六） ：理解公共List接口的抽象类（AbstractList ）
前言
AbstractCollection 简单实现了Collection接口 （集合）方法，里面利用了很多抽象方法，简单的实现了基本操作。

源码注释

/**
*此类提供<tt>集合的框架实现接口，以最小化实现此接口所需的工作<p>要实现一个不可修改的集合，程序员只需要
*扩展这个类并提供<tt>迭代器的实现<tt>大小</tt>方法(由<tt>迭代器返回的迭代器
*方法必须实现<tt>hasNext</tt>和<tt>next</tt>）<p>
*要实现可修改的集合，程序员还必须重写此类的<tt>add</tt>方法（否则会抛出
*<tt>UnsupportedOperationException</tt>），以及<tt>迭代器</tt>方法还必须实现其<tt>移除</tt>方法。<p>
*程序员通常应该提供一个void（无参数）和<tt>集合</tt>构造函数，根据
*<tt>集合</tt>接口规范。<p>
*此类中每个非抽象方法的文档都描述了其具体实施。这些方法中的每一个都可以被重写，如果正在实现的集合允许更高效的实现。<p>
*这个类是
*<a href=“{@docRoot}/./technotes/guides/collections/index.html”>
*Java集合框架</a>。
* @author  Josh Bloch
* @author  Neal Gafter
* @see Collection
* @since 1.2
*/

描述AbstractCollection 是个 集合的框架实现接口
1.以最小化实现此接口所需的工作，要实现一个不可修改的集合，程序员只需要 实现iterator size 方法等
2.要实现可修改的集合 就得实现 add等方法，这些方法中的每一个都可以被重写，如果正在实现的集合允许更高效的实现
方便继承进行扩展自己的实现
该注释描述这个抽象类的基本实现，以及继承类应该做的事情
在实践中，我们自己去扩展

查询 操作

默认基本操作
1.iterator 迭代器是由继承者实现
2.size则是需要 真正的实现者实现了
3.contains操作是依次往后遍历进行查找
4.toArray 方法 是返回一个新的object数组
等效于
* List list = new ArrayList(size());
* for (E e : this)
* list.add(e);
* return list.toArray();

 /**
     * 返回此集合中包含的元素的迭代器。
     *
     * @return 此集合中包含的元素的迭代器
     */
    public abstract Iterator<E> iterator();

    public abstract int size();
 /**
     * {@inheritDoc}
     *
     * <p>This implementation returns <tt>size() == 0</tt>.
     */
    public boolean isEmpty() {
        return size() == 0;
    }

/**
     * {@inheritDoc}
     *
     * <p>这个实现迭代集合中的元素，
     * 依次检查每个元素是否与指定的元素相等。
     *
     * @throws ClassCastException   {@inheritDoc}
     * @throws NullPointerException {@inheritDoc}
     */
    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;
    }

    /**
     * {@inheritDoc}
     *
     * <p>这个实现返回一个包含所有元素的数组
     * 此集合的迭代器以相同的顺序返回，存储在
     * 数组的连续元素，从索引{@code 0}开始。返回数组的长度等于元素数
     * 由迭代器返回，即使此集合的大小发生更改
     * 在迭代过程中，如果集合允许，可能会发生这种情况
     * 迭代期间的并发修改。{@code size}方法是
     * 仅作为优化提示调用；返回正确的结果即使迭代器返回不同数量的元素。
     *
     * <p>此方法等效于:
     *
     *  <pre> {@code
     * List<E> list = new ArrayList<E>(size());
     * for (E e : this)
     *     list.add(e);
     * return list.toArray();
     * }</pre>
     */
    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;
    }

MAX_ARRAY_SIZE参数
这个参数在 arraylist等实现类中动态扩容的时候会用作判断，MAX_ARRAY_SIZE 一些vm在数组中保留一些头字。尝试分配较大的数组可能会导致，因此为 Integer.MAX_VALUE - 8

  /**
   *要分配的最大数组大小。一些vm在数组中保留一些头字。尝试分配较大的数组可能会导致
    *OutOfMemoryError:请求的数组大小超出VM限制
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

修改操作

 public boolean add(E e) {
        throw new 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;
    }

add方法
需要继承者实现，否则抛UnsupportedOperationException异常
remove object方法
获取迭代器中的hasNext 和next 方法迭代 ，判断对象并调用remove 方法

批量操作

/**
     * {@inheritDoc}
     *
    	*<p>此实现迭代指定的集合，
	 *依次检查迭代器返回的每个元素
	 *如果它包含在这个集合中。如果所有元素都是这样
	 *返回包含的<tt>true</tt>，否则<tt>false</tt>。
	 *
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     * @see #contains(Object)
     */
    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

    /**
     * {@inheritDoc}
     *
   	*<p>此实现迭代指定的集合，并添加
	*迭代器依次返回到此集合的每个对象。
	*<p>请注意，此实现将引发
	*<tt>不支持操作异常</tt>除非<tt>添加</tt>是
	*重写（假定指定的集合为非空）。
	*
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     * @throws IllegalArgumentException      {@inheritDoc}
     * @throws IllegalStateException         {@inheritDoc}
     *
     * @see #add(Object)
     */
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }

    /**
     * {@inheritDoc}
     *
 	 *<p>此实现对该集合进行迭代，检查每个集合
	 *元素，以查看是否包含该元素
	 *在指定集合中。如果是这样的话，它就会从
	 *此集合使用迭代器的<tt>remove</tt>方法。
	 *
     * <p>Note that this implementation will throw an
     * <tt>UnsupportedOperationException</tt> if the iterator returned by the
     * <tt>iterator</tt> method does not implement the <tt>remove</tt> method
     * and this collection contains one or more elements in common with the
     * specified collection.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     *
     * @see #remove(Object)
     * @see #contains(Object)
     */
    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;
    }

    /**
     * {@inheritDoc}
   	*<p>此实现对该集合进行迭代，检查每个集合
	*元素，以查看是否包含该元素
	*在指定集合中。如果它没有被控制住，它就会被移除
	*使用迭代器的<tt>remove</tt>方法从该集合中删除。
	*
     * <p>Note that this implementation will throw an
     * <tt>UnsupportedOperationException</tt> if the iterator returned by the
     * <tt>iterator</tt> method does not implement the <tt>remove</tt> method
     * and this collection contains one or more elements not present in the
     * specified collection.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     *
     * @see #remove(Object)
     * @see #contains(Object)
     */
    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;
    }

几个方法都是依赖迭代器实现不同的逻辑
containsAll方法
containsAll 调用contains 方法 通过迭代器遍历判断是否包含对象，返回true或者false.
addAll 方法
调用 add方法进行循环插入，作者说最好继承者自己重写提升效率
removeAll 方法
判断传入集合是否为 null,抛出NullPointerException 异常
获得迭代器，根据传入集合中的 contains方法判断相等，调用迭代器的it.remove()方法进行删除
retainAll方法
判断传入集合是否为 null,抛出NullPointerException 异常
获得迭代器，根据传入集合中的 contains方法判断不相等，调用迭代器的it.remove()方法进行删除
clear 方法
获得迭代器，进行遍历 调用 it.remove()方法进行删除

iterator()方法
是抽象方法，需要继承者实现，AbstractList实现

字符串转换

遍历并返回此集合的字符串表示形式

  /**
     *返回此集合的字符串表示形式。绳子表示由集合中集合元素的列表组成
     *它们由其迭代器返回的顺序，用方括号括起来（<tt>“[]”“</tt>）。相邻元素由字符分隔
     *<tt>“，”</tt>（逗号和空格）。元素转换为字符串
     * by {@link String#valueOf(Object)}.
     *
     * @return a string representation of this collection
     */
    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(' ');
        }
    }

总结

整个AbstractCollection，是最基础的实现，利用大量的抽象方法，实现一些基础的集合操作