JDK源码（一）Collection容器

本质上来说，数据结构，实际上是设计一种容器，而容器的特性大体包括如下：
容器中如何进行存储
容器中的数据如何获取
容器中的数据如何添加　　
容器中的数据如何遍历
器中的数据如何搜索
容器中的其他特性（判空，替换，排序，溢出，并发，同步，拆分，汇聚等等）
源码解读
package java.util;

import org.jetbrains.annotations.Contract;

import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public interface Collection<E> extends Iterable<E> {
    /**
     * 定义size方法，应返回size大小，最大值为Integer.MAX_VALUE
     * @return
     */
    int size();
    /**
     * 定义isEmpty方法,用于返回是否为空
     * 如果不包含元素，则返回true
     * @return
     */
    @Contract(pure = true)
    boolean isEmpty();

    /**
     * 定义contains方法,判断一个obj是否属于此集合
     * 如不是集合，则返回true
     * @param o
     * @return
     */
    @Contract(pure = true)
    boolean contains(Object o);

    /**
     * 定义迭代器方法,返回一个迭代器对象
     * @return
     */
    Iterator<E> iterator();

    /**
     * 定义转换为转换Obj数组的方法,返回一个obj数组
     * @return
     */
    Object[] toArray();

    /**
     * 定义转换为泛型T数组的方法,返回一个指定泛型的数组
     * @param a
     * @param <T>
     * @return
     */
    <T> T[] toArray(T[] a);

    /**
     * 定义add方法,添加一个元素e,并返回添加成功标志
     * @param e
     * @return
     */
    boolean add(E e);

    /**
     * 定义remove方法,移除一个元素obj,并返回移除元素成功标志
     * @param o
     * @return
     */
    boolean remove(Object o);

    /**
     * 定义containsAll方法,判断是否包含集合实例对象c
     * @param c
     * @return
     */
    boolean containsAll(Collection<?> c);

    /**
     * 定义addAll方法,添加集合实例对象c到本实例中
     * @param c
     * @return
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * 定义removeAll方法,从本实例中移除集合实力对象c
     * @param c
     * @return
     */
    boolean removeAll(Collection<?> c);

    /**
     * jdk8新增
     * 大意为:
     * 定义removeIf方法,该方传递参数为函数式,传递内容是一个接口类型,该接口类型
     * 定义为一个filter函数,该函数用于传递给Objects.requireNonNull判断,然后调用
     * 迭代器,将满足该定义的filter的本实例中的元素移除
     * @since 1.8
     * @param filter
     * @return
     */
    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;
    }

    /**
     * 定义retainAll方法,取本例与集合实例c的交集,判断交集元素数量是否大于0
     * @param c
     * @return
     */
    boolean retainAll(Collection<?> c);

    /**
     * 定义clear方法,清除本例集合中的所有元素
     */
    void clear();

    /**
     * 定义equals方法,判断对象是否相对
     * @param o
     * @return
     */
    boolean equals(Object o);

    /**
     * 定义hashCode方法,获取hashCode标记的方法
     * @return
     */
    int hashCode();

    /**
     * jdk8新增
     * 大意为:
     * 将迭代器拆分,重写自Iterable接口,从已知元素数量的本例中返回拆分后的迭代器
     * 此方法返回的为本类本身
     * 子类可能重写迭代器拆分,将一个集合的迭代拆分为多个集合的迭代交由多个线程
     * @since 1.8
     * 80
     * @return
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    /**
     * jdk8新增
     * 大意为:
     * 将默认的迭代器拆分后的结果,聚合为流,该流并非io中的流,
     * 是一种类似于数据排序操作流
     * @since 1.8
     */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    /**
     * jdk8新增
     * 同上,但是具体其他的实现中,因为可并行,所以可能是线程不安全的
     *
     * @since 1.8
     */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}
JDK源码（一）Collection容器

猜你喜欢
