java.util.Collection.adoc

Collection

有一个问题，我们思考一下：如果让你设计 JDK 集合框架，你会怎么设计？说的更具体一些，现在需要一个可以包含重复对象的 Aggregation 集合，请问怎么设计？

可以先设想一下，有哪些操作？

1. 添加元素 add()

2. 删除元素 remove()

3. 是否包含元素 boolean contain(Element e)

4. 列表大小 int size()

5. 添加整个 Bag 元素 addAll(Aggregation aggregation)

6. 清空 clear()

7. 迭代器 Iterator<T> iterator()

8. 和数组互操作： toArray() 和 addAll(T[] array)

java.util.Collection

public interface Collection<E> extends Iterable<E> {
    // Query Operations

    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();

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

    // Modification Operations

    boolean add(E e);

    boolean remove(Object o);


    // Bulk Operations

    boolean containsAll(Collection<?> c);

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

    boolean removeAll(Collection<?> c);

    /**
     * @since 1.8
     */
    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;
    }

    boolean retainAll(Collection<?> c);

    void clear();


    // Comparison and hashing

    boolean equals(Object o);

    int hashCode();

    /**
     * @since 1.8
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    /**
     * @since 1.8
     */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    /**
     * @since 1.8
     */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}