Collection接口詳解

Collection接口

Collection接口做爲集合類的父類接口，Collectio位於java.util包下，Collectio定義了不少集合操做的方法。今天我但願經過對源碼的查閱來對Collection接口有所認識，下面咱們直接進入源碼分析：

Collection接口源碼

能夠看出，Collection接口繼承Iterable接口。

Collection接口方法彙總以及詳解

package java.util;

import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public interface Collection<E> extends Iterable<E> {
    /**
     * @return 用於返回集合中元素的個數（最大個數）
     */
    int size();

    /**
     * @return 用於判斷集合中是否存在某個元素，不存在返回true
     */
    boolean isEmpty();

    /**
     * 判斷集合中是否存在指定元素，存在返回true
     *
     * @param o是用於判斷的元素
     */
    boolean contains(Object o);

    /**
     * @return 返回可用於遍歷的迭代器
     */
    Iterator<E> iterator();

    /**
     * @return 將集合轉變成數組
     */
    Object[] toArray();

    /**
     * @return 將指定集合轉變成對應的數組
     */
    <T> T[] toArray(T[] a);


    /**
     * @return 往集合中添加元素，添加成功返回true
     */
    boolean add(E e);

    /**
     * @return 在集合中刪除指定的元素，成功返回true
     */
    boolean remove(Object o);

    /**
     * @return 判斷集合中是否包含集合C，若是包含返回true
     */
    boolean containsAll(Collection<?> c);

    /**
     * @return 將集合C添加到集合中，添加成功返回true
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * @return 從集合中刪除集合C，刪除成功返回true
     */
    boolean removeAll(Collection<?> c);

    /**
     * @return 刪除集合中複合條件的元素，刪除成功返回true
     * @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;
    }

    /**
     * @return 保留集合中集合C中的元素
     */
    boolean retainAll(Collection<?> c);

    /**
     * 清空集合中的全部元素
     */
    void clear();

    /**
     * @return 比較O與集合中的元素
     */
    boolean equals(Object o);

    /**
     * @return 返回此集合的哈希碼值。
     */
    int hashCode();

    /**
     *
     * @return a {@code Spliterator} over the elements in this collection
     * @since 1.8
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    /**
     * @return a sequential {@code Stream} over the elements in this collection
     * @since 1.8
     */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    /**
     * @return a possibly parallel {@code Stream} over the elements in this
     * collection
     * @since 1.8
     */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}