接口Iterable、Collection、List 的常见方法及其含义

Iterable 的常见方法

Iterrable 是Collection(List、Set、Queue)的 顶级接口，api释义：实现这个接口允许对象成为 “foreach” 语句的目标。
Iterator iterator(); 返回一个在一组 T 类型的元素上进行迭代的迭代器。

public interface Iterable<T> {
    Iterator<T> iterator();  // 返回类型为T的元素的迭代器。
    
    /**
      *为Iterable的每个元素执行给定的操作，直到处理完所有元素或者操作抛出异常。
      */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

     /**
      *在Iterable描述的元素上创建一个Spliterator<T>
   	 */
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

1.** iterator()**返回类型为T的元素的迭代器。

2.**forEach(Consumer<? super T> action)**为Iterable的每个元素执行给定的操作，直到处理完所有元素或者操作抛出异常。

如下对集合使用foreach()遍历:

 list.forEach(num -> System.out.println(num)); // list是要遍历的集合，num是其中元素

3.**spliterator()**在Iterable描述的元素上创建一个Spliterator。Spliterator是一个可分割迭代器(splitable iterator)。可以通过 tryAdvance() 方法逐个遍历，也可以按照 forEachRemaining() 方法进行按 bulk 逐块的遍历（内部调用的还是tryAdvance，同时做了 hasNext() 以及 next() 的工作）。Spliterator中常用的方法有:tryAdvance()、forEachRemaining()、trySplit()等。

Collection 的常见方法

public interface Collection<E> extends Iterable<E> {

    int size(); // 返回集合中的元素个数。
    
    boolean isEmpty(); // 判断此集合是否为空

    boolean contains(Object o); // 判断此集合中是否包含o

    Iterator<E> iterator(); // 返回此集合中元素的迭代器

    Object[] toArray(); // 返回一个包含此集合中所有元素的数组

    <T> T[] toArray(T[] a); // 返回指定泛型的类型数组

    boolean add(E e); // 添加元素,并返回是否添加成功
    
    boolean remove(Object o); // 删除集合中指定元素，并返回是否删除成功
    
    boolean containsAll(Collection<?> c); // 判断此集合s是否包含指定集合的所有元素

    boolean addAll(Collection<? extends E> c); // 将指定集合中的所有元素添加到此集合，并返回是否添加成功

    boolean removeAll(Collection<?> c); // 将集合中的所有指定元素移出此集合，并返回成功与否

	  /**
	    * 删除此集合中满足给定Predicate的所有元素
	    */
    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); // 将指定的对象与此集合进行相等性比较
    
    int hashCode(); // 返回此集合的哈希码值

	/**
	  * 重写Iterator接口中的spliterator()
	  */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

   /**
    * 返回一个连续的Stream流，该集合作为它的源
    */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    /**
      * 返回一个可能并行的Stream流，该集合作为它的源
      */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

List 的常见方法方法

public interface List<E> extends Collection<E> {
    // 未说明的与Collection接口中的方法含义相同
    int size(); 

    boolean isEmpty();

    boolean contains(Object o); // 判断 o 是否在线性表中

    Iterator<E> iterator();

    Object[] toArray();

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

    boolean add(E e); // 添加e

    boolean remove(Object o); // 删除遇到的第一个 o

    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> c); // 尾插 c 中的元素

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

    boolean removeAll(Collection<?> c);

    boolean retainAll(Collection<?> c);

    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

    void clear();

    boolean equals(Object o);

    int hashCode();

    E get(int index); // 获取下标 index 位置元素

    E set(int index, E element); // 将下标 index 位置元素设置为 element

    void add(int index, E element); // 将 element 插入到 index 位置
 
    E remove(int index); // 删除 index 位置元素

    int indexOf(Object o); // 返回第一个 o 所在下标

    int lastIndexOf(Object o);
    
    ListIterator<E> listIterator();

    ListIterator<E> listIterator(int index);

    List<E> subList(int fromIndex, int toIndex); // 截取部分线性表（左闭右开）

    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }