类关系图

图片.png

功能介绍

包路径：java.util

功能描述： Collection 是最基本的集合接口，继承了Iterable**接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于子接口(如List和set)。

Collection 接口存储一组不唯一，无序的对象。

The root interface in the collection hierarchy. A collection represents a group of objects, known as its elements

源码解析

Iterable

Iterable接口只有三个方法,实现了这个接口的集合对象支持迭代，也就是可迭代的。

  1. /** 
  2.  * @since 1.5
  3.  * @jls 14.14.2 The enhanced for statement
  4.  */
  5. public interface Iterable<T> {
  6.     /**
  7.      * 返回对应类型的迭代器
  8.      * Iterator我们一般叫顺序遍历迭代器，它就是提供迭代机制的对象
  9.      * 具体如何迭代，都是Iterator接口规范的。
  10.      * @return an Iterator.
  11.      */
  12.     Iterator<T> iterator();
  14.     /**
  15.      * 对集合元素执行传入函数
  16.      * @since 1.8
  17.      */
  18.     default void forEach(Consumer<? super T> action) {
  19.         Objects.requireNonNull(action);
  20.         for (T t : this) {
  21.             action.accept(t);
  22.         }
  23.     }
  25.     /**
  26.      * 返回可以并行遍历元素的迭代器,以适应现在cpu多核时代并行遍历的需求。
  27.      * 简单说：分割，增加并行处理能力
  28.      * {@code Iterable}.
  29.      * @since 1.8
  30.      */
  31.     default Spliterator<T> spliterator() {
  32.         return Spliterators.spliteratorUnknownSize(iterator(), 0);
  33.     }
  34. }

Collection

  1. package java.util;
  3. import java.util.function.Predicate;
  4. import java.util.stream.Stream;
  5. import java.util.stream.StreamSupport;
  7. /**
  8.  *
  9.  * @param <E> the type of elements in this collection
  10.  *
  11.  * @author  Josh Bloch
  12.  * @author  Neal Gafter
  13.  * @see     Set
  14.  * @see     List
  15.  * @see     Map
  16.  * @see     SortedSet
  17.  * @see     SortedMap
  18.  * @see     HashSet
  19.  * @see     TreeSet
  20.  * @see     ArrayList
  21.  * @see     LinkedList
  22.  * @see     Vector
  23.  * @see     Collections
  24.  * @see     Arrays
  25.  * @see     AbstractCollection
  26.  * @since 1.2
  27.  */
  29. public interface Collection<E> extends Iterable<E> {
  30.     // Query Operations 查询操作
  32.     /**
  33.      * 返回该集合中元素的个数。如果超过了Integer.MAX_VALUE，那么返回Integer.MAX_VALUE
  34.      * @return the number of elements in this collection
  35.      */
  36.     int size();
  38.     /**
  39.      * 集合判空，如果集合中没有元素返回true。
  40.      * @return <tt>true</tt> if this collection contains no elements
  41.      */
  42.     boolean isEmpty();
  44.     /**
  45.      * 判断集合是否存在某元素
  46.      * 如果集合中包含指定元素那么返回true。特别的，如果集合中也包含NULL元素的时候并且要查找的元素也是NULL的时候也返回true。
  47.      * @param o element whose presence in this collection is to be tested
  48.      * @return <tt>true</tt> if this collection contains the specified
  49.      */
  50.     boolean contains(Object o);
  52.     /**
  53.      * 返回迭代器
  54.      * @return an <tt>Iterator</tt> over the elements in this collection
  55.      */
  56.     Iterator<E> iterator();
  58.     /**
  59.      * 将集合转化为数组，返回包含此集合中所有元素的数组。
  60.      * @return an array containing all of the elements in this collection
  61.      */
  62.     Object[] toArray();
  64.     /**
  65.      * 将集合转化为数组，返回集合中所有元素到传入的数组中
  66.      * 该方法可以对返回的数组类型进行精确控制，而非像toArray方法一样返回Object[]
  67.      *
  68.      * @param <T> the runtime type of the array to contain the collection
  69.      * @param a the array into which the elements of this collection are to be
  70.      *        stored, if it is big enough; otherwise, a new array of the same
  71.      *        runtime type is allocated for this purpose.
  72.      * @return an array containing all of the elements in this collection
  73.      */
  74.     <T> T[] toArray(T[] a);
  76.     // Modification Operations 更新操作
  78.     /**
  79.      * 向集合中添加一个元素。
  80.      * 集合添加成功返回true，如果该集合不允许重复并且已经包含指定的元素。返回false
  81.      * @param e element whose presence in this collection is to be ensured
  82.      * @return <tt>true</tt> if this collection changed as a result of the
  83.      *         call
  84.      */
  85.     boolean add(E e);
  87.     /**
  88.      * 删除集合中的指定的元素。如果存在NULL，也删除。
  89.      * @param o element to be removed from this collection, if present
  90.      * @return <tt>true</tt> if an element was removed as a result of this call
  91.      * 
  92.      */
  93.     boolean remove(Object o);
  96.     // Bulk Operations 大量数据操作
  98.     /**
  99.      * 如果该集合中包含指定集合中的所有元素的时候返回true。
  100.      * @param  c collection to be checked for containment in this collection
  101.      * @return <tt>true</tt> if this collection contains all of the elements
  102.      *         in the specified collection
  103.      * 
  104.      * @see    #contains(Object)
  105.      */
  106.     boolean containsAll(Collection<?> c);
  108.     /**
  109.      * 将指定集合中的所有元素添加到此集合中。
  110.      * 在添加过程中如果被添加的集合发生了更改，addAll方法不具有幂等性。
  111.      * @param c collection containing elements to be added to this collection
  112.      * @return <tt>true</tt> if this collection changed as a result of the call
  113.      * 
  114.      * @see #add(Object)
  115.      */
  116.     boolean addAll(Collection<? extends E> c);
  118.     /**
  119.      * 删除当前集合中所有等于指定集合中的元素。
  120.      * @param c collection containing elements to be removed from this collection
  121.      * @return <tt>true</tt> if this collection changed as a result of the
  122.      *         call
  123.      * @see #remove(Object)
  124.      * @see #contains(Object)
  125.      */
  126.     boolean removeAll(Collection<?> c);
  128.     /**
  129.      * 删除所有匹配过滤器Predicate条件的元素
  130.      * @param filter a predicate which returns {@code true} for elements to be
  131.      *        removed
  132.      * @return {@code true} if any elements were removed
  133.      * @since 1.8
  134.      */
  135.     default boolean removeIf(Predicate<? super E> filter) {
  136.         // 校验lambda是否为空
  137.         Objects.requireNonNull(filter);
  138.         boolean removed = false;
  140.         // 获取迭代器
  141.         final Iterator<E> each = iterator();
  142.         while (each.hasNext()) {
  144.             // 如果该方法执行返回true则移除该元素
  145.             if (filter.test(each.next())) {
  146.                 each.remove();
  147.                 removed = true;
  148.             }
  149.         }
  150.         return removed;
  151.     }
  153.     /**
  154.      * 仅保留该指定集合中存在的所有元素。其余删除
  155.      * @param c collection containing elements to be retained in this collection
  156.      * @return <tt>true</tt> if this collection changed as a result of the call
  157.      * 
  158.      * @see #remove(Object)
  159.      * @see #contains(Object)
  160.      */
  161.     boolean retainAll(Collection<?> c);
  163.     /**
  164.      * 清空掉集合中的所有元素
  165.      */
  166.     void clear();
  169.     // Comparison and hashing 
  171.     /**
  172.      * 比较是否相等
  173.      * @see Object#equals(Object)
  174.      * @see Set#equals(Object)
  175.      * @see List#equals(Object)
  176.      */
  177.     boolean equals(Object o);
  179.     /**
  180.      * 
  181.      * @return the hash code value for this collection
  182.      *
  183.      * @see Object#hashCode()
  184.      * @see Object#equals(Object)
  185.      */
  186.     int hashCode();
  188.     /**
  189.      * 返回Spliterator分割器，用于并发流式处理的时候调用
  190.      * @return a {@code Spliterator} over the elements in this collection
  191.      * @since 1.8
  192.      */
  193.     @Override
  194.     default Spliterator<E> spliterator() {
  195.         return Spliterators.spliterator(this, 0);
  196.     }
  198.     /**
  199.      * 返回流对象
  200.      * @return a sequential {@code Stream} over the elements in this collection
  201.      * @since 1.8
  202.      */
  203.     default Stream<E> stream() {
  204.         return StreamSupport.stream(spliterator(), false);
  205.     }
  207.     /**
  208.      * 返回并发流式对象
  209.      * @return a possibly parallel {@code Stream} over the elements in this
  210.      * collection
  211.      * @since 1.8
  212.      */
  213.     default Stream<E> parallelStream() {
  214.         return StreamSupport.stream(spliterator(), true);
  215.     }
  216. }

AbstractCollection

直接实现Collection接口的抽象类，实现基本方法，方便子类实现Collection功能

  1. public abstract class AbstractCollection<E> implements Collection<E> {
  2.     /**
  3.      * 
  4.      */
  5.     protected AbstractCollection() {
  6.     }
  8.     // Query Operations
  10.     /**
  11.      * 返回迭代器
  12.      * @return an iterator over the elements contained in this collection
  13.      */
  14.     public abstract Iterator<E> iterator();
  16.     // 获取集合元素总数
  17.     public abstract int size();
  19.     /**
  20.      * 判断集合是否为空
  21.      */
  22.     public boolean isEmpty() {
  23.         return size() == 0;
  24.     }
  26.     /**
  27.      * 判断元素是否存在于集合之中
  28.      */
  29.     public boolean contains(Object o) {
  30.         Iterator<E> it = iterator();
  31.         if (o==null) {
  32.             while (it.hasNext())
  33.                 if (it.next()==null)
  34.                     return true;
  35.         } else {
  36.             while (it.hasNext())
  37.                 if (o.equals(it.next()))
  38.                     return true;
  39.         }
  40.         return false;
  41.     }
  43.     /**
  44.      * 将集合转为数组
  45.      */
  46.     public Object[] toArray() {
  47.         // Estimate size of array; be prepared to see more or fewer elements
  49.         // 新建同等大小的Object数组
  50.         Object[] r = new Object[size()];
  51.         Iterator<E> it = iterator();
  53.         // 遍历并填充元素
  54.         for (int i = 0; i < r.length; i++) {
  55.             if (! it.hasNext()) // fewer elements than expected
  56.                 return Arrays.copyOf(r, i);
  57.             r[i] = it.next();
  58.         }
  60.         // it.hasNext方法为true表明数组长度不足【可能在转换过程中有别的线程往里面加了元素】
  61.         // 调用finishToArray对数组进行扩容并完成转换
  62.         return it.hasNext() ? finishToArray(r, it) : r;
  63.     }
  65.     /**
  66.      * 将集合转为数组
  67.      */
  68.     @SuppressWarnings("unchecked")
  69.     public <T> T[] toArray(T[] a) {
  70.         // Estimate size of array; be prepared to see more or fewer elements
  71.         int size = size();
  73.         // 构造足够大的数组
  74.         T[] r = a.length >= size ? a :
  75.                   (T[])java.lang.reflect.Array
  76.                   .newInstance(a.getClass().getComponentType(), size);
  78.         Iterator<E> it = iterator();
  80.         // 遍历并填充元素
  81.         for (int i = 0; i < r.length; i++) {
  82.             if (! it.hasNext()) { // fewer elements than expected
  83.                 if (a == r) {
  84.                     r[i] = null; // null-terminate
  85.                 } else if (a.length < i) {
  86.                     return Arrays.copyOf(r, i);
  87.                 } else {
  88.                     System.arraycopy(r, 0, a, 0, i);
  89.                     if (a.length > i) {
  90.                         a[i] = null;
  91.                     }
  92.                 }
  93.                 return a;
  94.             }
  95.             r[i] = (T)it.next();
  96.         }
  98.         // more elements than expected
  99.         // it.hasNext方法为true表明数组长度不足【可能在转换过程中有别的线程往里面加了元素】
  100.         // 调用finishToArray对数组进行扩容并完成转换
  101.         return it.hasNext() ? finishToArray(r, it) : r;
  102.     }
  104.     /**
  105.      * 最大数组容量限制
  106.      */
  107.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  109.     /**
  110.      * 数组扩容
  111.      * （1）当数组索引指向最后一个元素+1时，对数组进行扩容：即创建一个更长的数组，然后将原数组的内容复制到新数组中
  112.      * （2）扩容大小：cap + cap/2 +1
  113.      * （3）扩容前需要先判断数组长度是否溢出
  114.      *  注意：这里的迭代器是从上层的方法（toArray）传过来的，并且这个迭代器已执行了一部分，而不是从头开始迭代的
  115.      * @param r the array, replete with previously stored elements
  116.      * @param it the in-progress iterator over this collection
  117.      * @return array containing the elements in the given array, plus any
  118.      *         further elements returned by the iterator, trimmed to size
  119.      */
  120.     @SuppressWarnings("unchecked")
  121.     private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
  122.         int i = r.length;
  123.         while (it.hasNext()) {
  124.             int cap = r.length;
  125.             if (i == cap) {
  126.                 int newCap = cap + (cap >> 1) + 1;
  127.                 // overflow-conscious code
  128.                 if (newCap - MAX_ARRAY_SIZE > 0)
  129.                     newCap = hugeCapacity(cap + 1);
  130.                 r = Arrays.copyOf(r, newCap);
  131.             }
  132.             r[i++] = (T)it.next();
  133.         }
  134.         // trim if overallocated
  135.         return (i == r.length) ? r : Arrays.copyOf(r, i);
  136.     }
  138.     /**
  139.      * 判断数组容量是否溢出，最大为整型数据的最大值
  140.      */
  141.     private static int hugeCapacity(int minCapacity) {
  142.         if (minCapacity < 0) // overflow
  143.             throw new OutOfMemoryError
  144.                 ("Required array size too large");
  145.         return (minCapacity > MAX_ARRAY_SIZE) ?
  146.             Integer.MAX_VALUE :
  147.             MAX_ARRAY_SIZE;
  148.     }
  150.     // Modification Operations
  152.     /**
  153.      * 未移除指定元素实现
  154.      */
  155.     public boolean add(E e) {
  156.         throw new UnsupportedOperationException();
  157.     }
  159.     /**
  160.      * 移除指定元素
  161.      */
  162.     public boolean remove(Object o) {
  163.         Iterator<E> it = iterator();
  164.         if (o==null) {
  165.             while (it.hasNext()) {
  166.                 if (it.next()==null) {
  167.                     it.remove();
  168.                     return true;
  169.                 }
  170.             }
  171.         } else {
  172.             while (it.hasNext()) {
  173.                 if (o.equals(it.next())) {
  174.                     it.remove();
  175.                     return true;
  176.                 }
  177.             }
  178.         }
  179.         return false;
  180.     }
  183.     // Bulk Operations
  185.     /**
  186.      * 如果该集合中包含指定集合中的所有元素的时候返回true。
  187.      * @see #contains(Object)
  188.      */
  189.     public boolean containsAll(Collection<?> c) {
  190.         for (Object e : c)
  191.             if (!contains(e))
  192.                 return false;
  193.         return true;
  194.     }
  196.     /**
  197.      * 遍历参数集合，依次将参数集合中的元素添加当前集合中
  198.      * @see #add(Object)
  199.      */
  200.     public boolean addAll(Collection<? extends E> c) {
  201.         boolean modified = false;
  202.         for (E e : c)
  203.             if (add(e))
  204.                 modified = true;
  205.         return modified;
  206.     }
  208.     /**
  209.      * 移除参数集合的元素
  210.      * @see #remove(Object)
  211.      * @see #contains(Object)
  212.      */
  213.     public boolean removeAll(Collection<?> c) {
  214.         Objects.requireNonNull(c);
  215.         boolean modified = false;
  216.         Iterator<?> it = iterator();
  217.         while (it.hasNext()) {
  218.             if (c.contains(it.next())) {
  219.                 it.remove();
  220.                 modified = true;
  221.             }
  222.         }
  223.         return modified;
  224.     }
  226.     /**
  227.      * 仅保留该指定集合中存在的所有元素。其余删除
  228.      * @see #remove(Object)
  229.      * @see #contains(Object)
  230.      */
  231.     public boolean retainAll(Collection<?> c) {
  232.         Objects.requireNonNull(c);
  233.         boolean modified = false;
  234.         Iterator<E> it = iterator();
  235.         while (it.hasNext()) {
  236.             if (!c.contains(it.next())) {
  237.                 it.remove();
  238.                 modified = true;
  239.             }
  240.         }
  241.         return modified;
  242.     }
  244.     /**
  245.      * 删除所有元素
  246.      */
  247.     public void clear() {
  248.         Iterator<E> it = iterator();
  249.         while (it.hasNext()) {
  250.             it.next();
  251.             it.remove();
  252.         }
  253.     }
  256.     //  String conversion
  258.     /**
  259.      * 重载toString方法
  260.      * @return a string representation of this collection
  261.      */
  262.     public String toString() {
  263.         Iterator<E> it = iterator();
  264.         if (! it.hasNext())
  265.             return "[]";
  267.         StringBuilder sb = new StringBuilder();
  268.         sb.append('[');
  269.         for (;;) {
  270.             E e = it.next();
  271.             sb.append(e == this ? "(this Collection)" : e);
  272.             if (! it.hasNext())
  273.                 return sb.append(']').toString();
  274.             sb.append(',').append(' ');
  275.         }
  276.     }
  278. }

简单使用

package com.java.list;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * @description Collection接口演示
 * @auther: lai.guanfu
 * @date: 2021-01-04 22:51
 */
public class CollectionCode {
    public static void main(String[] args) {
        Collection<Integer> collection = new ArrayList<>();
        for(int i=0;i<20;i++){
            collection.add(i);
        }
        System.out.println(collection);
        System.out.println();

        // ============= 移除大于10的元素

        // 传统写法：
//        Iterator<Integer> iterator = collection.iterator();
//        while (iterator.hasNext()) {
//            Integer item = iterator.next();
//            if (item > 10)
//                iterator.remove();
//        }

        // removeIf调用
        collection.removeIf(item -> item>10);
        System.out.println(collection);
    }
}

输出如下：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

总结

  • Collection 是最基本的集合接口，继承了Iterable接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于子接口(如List和set)
  • Collection 接口存储一组不唯一，无序的对象。
  • 在Collection中定义了一些常用的接口，供子类去实现
  • 在JDK1.8中新增了一些方法，例如获取获取流式函数的方法在这个接口中引入了default方法