jdk1.8集合框架源码解析（二）Collection

深藏阁楼爱情的钟 2022-03-31 13:24 299阅读 0赞

Collection 是集合的顶层接口，相比于1.7有些许变化

下面看下Collection接口的继承关系

public interface Collection<E> extends Iterable<E>

public interface Collection<E> extends Iterable<E> {
        //集合大小
        int size();
    
        //判断集合是否为空
        boolean isEmpty();
    
        //判断是否包含指定的元素
        boolean contains(Object o);
    
        //返回集合的迭代器
        Iterator<E> iterator();
    
       //把集合转成Object[]
        Object[] toArray();
    
        //集合转数组加入泛型
        <T> T[] toArray(T[] a);
    
        // Modification Operations
    
       //增加元素
        boolean add(E e);
    
        //移除元素
        boolean remove(Object o);
    
    
        // Bulk Operations
    
       //判断一个集合是否包含另外一个集合的所有元素
        boolean containsAll(Collection<?> c);
    
      //把一个集合的所有元素添加到另外一个集合
        boolean addAll(Collection<? extends E> c);
    
        //移除所有元素
        boolean removeAll(Collection<?> c);
    
    
    
       //  仅保留此 collection 中那些也包含在指定 collection 的元素
        boolean retainAll(Collection<?> c);
    
        //清空所有元素
        void clear();
    
    
        // hashCode和equals方法
    
     
        boolean equals(Object o);
    
    
        int hashCode();
    
        /********默认方法*******/
       //移除符合条件的元素
        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;
        }
    
        /**
         * Creates a {@link Spliterator} over the elements in this collection.
         *
         * Implementations should document characteristic values reported by the
         * spliterator.  Such characteristic values are not required to be reported
         * if the spliterator reports {@link Spliterator#SIZED} and this collection
         * contains no elements.
         *
         * <p>The default implementation should be overridden by subclasses that
         * can return a more efficient spliterator.  In order to
         * preserve expected laziness behavior for the {@link #stream()} and
         * {@link #parallelStream()}} methods, spliterators should either have the
         * characteristic of {@code IMMUTABLE} or {@code CONCURRENT}, or be
         * <em><a href="Spliterator.html#binding">late-binding</a></em>.
         * If none of these is practical, the overriding class should describe the
         * spliterator's documented policy of binding and structural interference,
         * and should override the {@link #stream()} and {@link #parallelStream()}
         * methods to create streams using a {@code Supplier} of the spliterator,
         * as in:
         * <pre>{@code
         *     Stream<E> s = StreamSupport.stream(() -> spliterator(), spliteratorCharacteristics)
         * }</pre>
         * <p>These requirements ensure that streams produced by the
         * {@link #stream()} and {@link #parallelStream()} methods will reflect the
         * contents of the collection as of initiation of the terminal stream
         * operation.
         *
         * @implSpec
         * The default implementation creates a
         * <em><a href="Spliterator.html#binding">late-binding</a></em> spliterator
         * from the collections's {@code Iterator}.  The spliterator inherits the
         * <em>fail-fast</em> properties of the collection's iterator.
         * <p>
         * The created {@code Spliterator} reports {@link Spliterator#SIZED}.
         *
         * @implNote
         * The created {@code Spliterator} additionally reports
         * {@link Spliterator#SUBSIZED}.
         *
         * <p>If a spliterator covers no elements then the reporting of additional
         * characteristic values, beyond that of {@code SIZED} and {@code SUBSIZED},
         * does not aid clients to control, specialize or simplify computation.
         * However, this does enable shared use of an immutable and empty
         * spliterator instance (see {@link Spliterators#emptySpliterator()}) for
         * empty collections, and enables clients to determine if such a spliterator
         * covers no elements.
         *
         * @return a {@code Spliterator} over the elements in this collection
         * @since 1.8
         */
        //返回可分割的迭代器
        @Override
        default Spliterator<E> spliterator() {
            return Spliterators.spliterator(this, 0);
        }
    
        /**
         * Returns a sequential {@code Stream} with this collection as its source.
         *
         * <p>This method should be overridden when the {@link #spliterator()}
         * method cannot return a spliterator that is {@code IMMUTABLE},
         * {@code CONCURRENT}, or <em>late-binding</em>. (See {@link #spliterator()}
         * for details.)
         *
         * @implSpec
         * The default implementation creates a sequential {@code Stream} from the
         * collection's {@code Spliterator}.
         *
         * @return a sequential {@code Stream} over the elements in this collection
         * @since 1.8
         */
        //返回集合对应的流
        default Stream<E> stream() {
            return StreamSupport.stream(spliterator(), false);
        }
    
        /**
         * Returns a possibly parallel {@code Stream} with this collection as its
         * source.  It is allowable for this method to return a sequential stream.
         *
         * <p>This method should be overridden when the {@link #spliterator()}
         * method cannot return a spliterator that is {@code IMMUTABLE},
         * {@code CONCURRENT}, or <em>late-binding</em>. (See {@link #spliterator()}
         * for details.)
         *
         * @implSpec
         * The default implementation creates a parallel {@code Stream} from the
         * collection's {@code Spliterator}.
         *
         * @return a possibly parallel {@code Stream} over the elements in this
         * collection
         * @since 1.8
         */
        //获取并行执行的流
        default Stream<E> parallelStream() {
            return StreamSupport.stream(spliterator(), true);
        }
    }

Collection相比jdk1.7新增加了四个默认方法

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;
        }
    
        @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);
        }

<table> 
 <tbody> 
  <tr> 
   <td style="width:357px;">&nbsp;</td> 
   <td style="width:492px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:357px;">&nbsp;default boolean removeIf(Predicate&lt;? super E&gt; filter)</td> 
   <td style="width:492px;">移除符合过滤条件</td> 
  </tr> 
  <tr> 
   <td style="width:357px;">&nbsp;default Spliterator&lt;E&gt; spliterator()</td> 
   <td style="width:492px;">获取可分割的迭代器</td> 
  </tr> 
  <tr> 
   <td style="width:357px;">default Stream&lt;E&gt; stream()</td> 
   <td style="width:492px;">获取非并行流</td> 
  </tr> 
  <tr> 
   <td style="width:357px;">default Stream&lt;E&gt; parallelStream()</td> 
   <td style="width:492px;">获取并行流</td> 
  </tr> 
 </tbody> 
</table>