拆行解码 Java 集合源码之 Collection 的三大体系

有个程序员
877 阅读3分钟

Java 集合源码解析系列：

image-20210128161807009

List

  • 元素有序、可重复；
  • 可以明确控制元素的插入位置
  • 可以根据索引访问元素。
  • 提供额外支持插入和双写遍历的 ListIterator，允许从指定位置开始遍历。
  • 提供静态工厂方法，用于创建视图List。来源于 ImmutableCollections。
    • 不可增删改。
    • 元素不能为 Null。
    • 顺序与原数组或集合一致。
  • equals 判断大小相等，顺序遍历上元素相等。基于 List 是有序的。

Queue

  • 在数据插入、删除与访问上，除了继承 Collection 外，还有自己的一套 API。
  • 继承的 API 失败抛出异常，比如 add、remove、element。
  • 自己的一套是返回特殊值 null 或 false，比如 offer、poll、peek。
    • 是为了容量有限的队列设计的。
  • 由于将 null 作为特殊值，一般是不允许为 null 的。LinkedList 可以。
  • 没有对 equals 特别说明。因为基于元素一样，顺序不一致的情况不能很好地定义。

Set

  • 元素不允许重复。
  • 是否有序看具体实现。
  • Set 判断元素重复是基于 Equals，可变对象的变化导致 Set 的行为不可确定。最为的特殊情况就是元素不能为集合自身。
  • 提供静态工厂方法，用于创建视图 Set。来源于 ImmutableCollections。
    • 不可增删改。
    • 元素不能为 Null。
    • 元素不可重复，否则报错。

AbstractCollection

三大体系之上，集合类的默认实现。衍生出 AbstractList、AbstractSet、AbstractQueue。

关键方法：size、iterator、add（默认不支持） 都依赖于具体的数据结果，因此要求子类具体实现的。

其他单个操作、批量操作，都可以依赖于迭代器实现。所以是模板方法模式。

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

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

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

    @SuppressWarnings("unchecked")
    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;
    }

    /**
     * 要分配的最大数组大小。 一些虚拟机在数组中保留一些标题字。 
     * 尝试分配更大的阵列可能会导致OutOfMemoryError：请求的阵列大小超出VM限制
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 当迭代器返回的元素比预期的多时，在toArray中重新分配（扩容）正在使用的数组，并完成从迭代器中填充它的操作。
     */
    @SuppressWarnings("unchecked")
    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;
    }

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

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

    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();
        }
    }
}
avatar
文章
阅读
粉丝