Collection

 /**
  * 返回此集合中的元素数。 如果此集合包含的元素个数多于Integer.MAX_VALUE，则返回Integer.MAX_VALUE
  */
int size();

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

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

/**
 *返回迭代器，不保证顺序
 */
Iterator<E> iterator();

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

/**
 * 删除一个元素
 */
boolean remove(Object o);

/**
 * 返回一个包含此集合中所有元素的数组。如果此集合保证其迭代器返回其元素的顺序，则此方法必须以相同的顺序返回元素。
 */
Object[] toArray();

/**
 * 返回一个包含集合中所有元素的数组，运行时根据集合元素的类型指定数组的类型
 */
<T> T[] toArray(T[] a);

/**
 * 是否包含指定集合 c 的全部元素
 */
boolean containsAll(Collection<?> c);

/**
 * 将指定集合 c 中的所有元素添加到此集合中，如果集合有改变返回true
 */
boolean addAll(Collection<? extends E> c);

/**
 * 删除本集合中和 c 集合中一致的元素，如果集合有改变就返回 true
 */
boolean removeAll(Collection<?> c);

/**
 * 保留本集合与 c 集合的交集，如果集合有改变就返回 true
 */
boolean retainAll(Collection<?> c);

/**
 * 删除所有元素
 */
void ();

/**
 * 作用是按照一定规则过滤集合中的元素
 * jdk 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;
}


//使用实例
Collection<Person> collection = new ArrayList();

//lambda表达式
collection.removeIf(
    person -> person.getAge() >= 15
);
//或者
collection.removeIf(new Predicate<Person>() {
    @Override
    public boolean test(Person person) {
        return person.getAge() >= 15;
    }
});

/**
 * 可分割迭代器，是Java为了并行遍历数据源中的元素而设计的迭代器，这个可以类比最早Java提供的顺序遍历迭代器  
 *Iterator，但一个是顺序遍历，一个是并行遍历。 
 * jdk 1.8
 */ 
@Override
default Spliterator<E> spliterator() {
    return Spliterators.spliterator(this, 0);
}

/**
 * 返回一个System流
 * jdk 1.8
 */
default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}

/**
 * 返回一个并发System流
 * jdk 1.8
 */
default Stream<E> parallelStream() {
    return StreamSupport.stream(spliterator(), true);
}