/**
 * The root interface in the collection hierarchy（单列集合），Map是双列集合
 */
public interface Collection<E> extends Iterable<E> {
    /**
     * 查询集合元素总个数
     */
    int size();

    /**
     * 判断集合是否为空
     */
    boolean isEmpty();

    /**
     * 判断集合是否包含指定元素
     */
    boolean contains(Object o);

    /**
     * 返回迭代器，不保证迭代器中元素是有序的（添加和遍历顺序一致），除非是有序集合
     */
    Iterator<E> iterator();

    /**
	 * 转化为数组
     */
    Object[] toArray();

    /**
     * 转化为数组
     */
    <T> T[] toArray(T[] a);

    /**
     * 转化为数组
     */
    default <T> T[] toArray(IntFunction<T[]> generator) {
        return toArray(generator.apply(0));
    }

    /**
     * 添加元素
     */
    boolean add(E e);

    /**
     * 移除元素
     */
    boolean remove(Object o);

    /**
     * 判断是否包含指定集合中的所有元素
     */
    boolean containsAll(Collection<?> c);

    /**
     * 添加集合
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * 移除指定集合中的所有元素
     */
    boolean removeAll(Collection<?> c);

    /**
     * 移除特定元素
     */
    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();

    /**
     * 判断是否相等
     */
    boolean equals(Object o);

    /**
     * 返回hash值
     */
    int hashCode();

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

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

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