Java集合类学习--Collection

Collection

Java 集合框架（Java Collections Framework, JCF）包含很多平时开发中的常用类，例如 List、Set、ArrayList、HashMap、HashSet 等，因此打算先从这里下手。

而 Collection 接口又是集合层次中的根接口，最常用的 List 和 Set 接口都继承自它。它们的继承结构如下（常用部分）：

Collection 接口有很多方法，如下：

简单分析：

size(): 集合中包含的元素个数；
isEmpty(): 集合是否为空；
contains(Object): 集合中是否包含某个对象；
iterator(): 返回该集合的迭代器，用于（顺序）遍历该集合；
Object[] toArray(): 将集合中的元素“拷贝”到一个 Object 数组中；
T[] toArray(T[] a): 作用同 5.1，区别在于该方法可以指定数组的类型（这两个方法用于集合与数组之间的转换）；
add(E): 添加元素；
remove(Object): 移除元素；
containsAll(Collection<?>): 判断该集合是否包含另一个集合；
addAll(Collection<? extends E>): 将另一个集合的所有元素都添加到该集合中；
removeAll(Collection<?>): 从该集合中移除指定集合的所有元素；
removeIf(Predicate<? super E>): 从该集合中移除满足指定条件的元素，其中 Predicate 是 JDK 1.8 引入的函数式操作，即传入的参数是一个方法；
retainAll(Collection<?>): 保留指定集合中的元素，即移除所有未包含在指定集合中的元素；
clear(): 清空集合；
equals(Object): 比较该集合与指定的对象是否相等；
hashCode(): 返回该集合的哈希值，注意重写 equals 方法时必须要重写该方法，以满足 Object.hashCode 方法的规定。
spliterator(): 可分割迭代器，用于并行遍历集合中的元素（iterator() 方法是顺序遍历）；
stream() & parallelStream(): JDK 1.8 引入的流（Stream）式数据处理，分别表示串行流和并行流，该部分以后单独分析。

源码分析

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

     //返回此集合中的元素数。 
     //如果此收藏包含超过Integer.MAX_VALUE个元素，则返回Integer.MAX_VALUE 。
    int size();

   
     //如果此集合不包含元素，则返回 true 。
    boolean isEmpty();

   
     //如果此集合包含指定的元素，则返回true 。
     //返回true如果且仅当该集合至少包含一个元素e使得(o==null ? e==null : o.equals(e)) 。 
     //ClassCastException - 如果指定元素的类型与此集合不兼容（ optional ） 
     //NullPointerException - 如果指定的元素为空，并且此集合不允许空元素（ optional ） 
    boolean contains(Object o);

   
     //返回此集合中的元素的迭代器。
     //没有关于元素返回顺序的保证（除非这个集合是提供保证的某个类的实例）。 
    Iterator<E> iterator();

    //返回一个包含此集合中所有元素的数组。 如果此集合对其迭代器返回的元素的顺序做出任何保证，则此方法必须以相同的顺序返回元素。 
	//返回的数组将是“安全的”，因为该集合不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组，即使这个集合是由数组支持的）。 
	//因此，调用者可以自由地修改返回的数组。 
	//此方法充当基于阵列和基于集合的API之间的桥梁。
    Object[] toArray();


    //返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。 如果集合适合指定的数组，则返回其中。 
    //否则，将为指定数组的运行时类型和此集合的大小分配一个新数组。 
    //T - 包含集合的数组的运行时类型 
    //a - 要存储此集合的元素的数组，如果它足够大; 否则，为此目的分配相同运行时类型的新数组。 
    //可能出现异常：
    //ArrayStoreException - 如果指定数组的运行时类型不是此集合中每个元素的运行时类型的超类型 
	//NullPointerException - 如果指定的数组为空 
    <T> T[] toArray(T[] a);

	//保此集合包含指定的元素（可选操作）。 如果此集合由于调用而更改，则返回true 。 （如果此集合不允许重复，并且已包含指定的元素，则返回false。 ） 
	//支持此操作的集合可能会限制可能添加到此集合的元素。 特别是一些集合拒绝添加null种元素，和其他人将强加可添加元素的类型限制。 收集类应在其文档中明确说明可能添加哪些元素的限制。 
	//如果一个集合拒绝添加一个特定的元素，除了它已经包含该元素之外，它必须抛出异常（而不是返回false ）。 这保留了一个集合在此调用返回后始终包含指定元素的不变量。 
	// e - 要确保在此集合中的存在的元素 
	//会出现的异常：
	//UnsupportedOperationException - 如果此 集合不支持add操作 
	//ClassCastException - 如果指定元素的类阻止将其添加到此集合 
	//NullPointerException - 如果指定的元素为空，并且该集合不允许空元素 
	//IllegalArgumentException - 如果元素的某些属性阻止其添加到此集合 
	//IllegalStateException - 如果由于插入限制，此时无法添加该元素 
    boolean add(E e);

    //从该集合中删除指定元素的单个实例（如果存在）（可选操作）。 更正式地，删除元素e ，使得(o==null ? e==null : o.equals(e)) ，如果该集合包含一个或多个这样的元素。 如果此集合包含指定的元素（或等效地，如果此集合由于调用而更改），则返回true 。 
	//o - 要从此集合中删除的元素（如果存在）
	//可能会出现的异常：
	//ClassCastException - 如果指定元素的类型与此集合不兼容（ optional ） 
	//NullPointerException - 如果指定的元素为空，并且此集合不允许空元素（ optional ） 
	//UnsupportedOperationException - 如果此 集合不支持remove操作 
    boolean remove(Object o);


    //如果此集合包含指定 集合中的所有元素，则返回true。 
    boolean containsAll(Collection<?> c);

  	//c - 包含要添加到此集合的元素的集合
  	//将指定集合中的所有元素添加到此集合
    boolean addAll(Collection<? extends E> c);

    //删除指定集合中包含的所有此集合的元素
    boolean removeAll(Collection<?> c);

    //java8新增，所以有default 
    //filter - 对要删除的元素返回 true
    //默认实现使用其iterator()遍历集合的所有元素。 使用Iterator.remove()删除每个匹配元素。
    //如果集合的迭代器不支持删除，那么UnsupportedOperationException将被抛出第一个匹配元素。
    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;
    }

    //c - 包含要保留在此集合中的元素的集合
    //仅保留此集合中包含在指定集合中的元素（可选操作）。 换句话说，从该集合中删除所有不包含在指定集合中的元素。 
    boolean retainAll(Collection<?> c);

    //从此集合中删除所有元素
    void clear();


    //重写Object
    boolean equals(Object o);
    int hashCode();

    //下面内容均为1.8新增，后续学习补充
    @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);
    }
}

简单示例

@Test
public void test_size(){
    Collection<String> collection = new ArrayList<>();
    collection.add("a");
    collection.add("b");
    collection.add("c");
    collection.add("d");
    int size = collection.size();
    System.out.println("集合中元素的个数：" + size);
}

4

@Test
public void test_isEmpty(){
    Collection<String> collection = new ArrayList<>();
    collection.add("a");
    collection.add("b");
    collection.add("c");
    boolean isEmpty = collection.isEmpty();
    System.out.println("集合是否为空：" + isEmpty);
}

集合是否为空：false

@Test
public void test_isEmpty(){
    Collection<String> collection = new ArrayList<>();
    collection.add("a");
    collection.add("b");
    collection.add("c");
    boolean isContains = collection.contains("a");
    System.out.println("集合是否包含元素a：" + isContains);
}

集合是否包含元素a：true

@Test
public void test_iterator() {
    Collection<String> collection = new ArrayList<>();
    collection.add("a");
    collection.add("b");
    collection.add("c");
 
    Iterator<String> iterator = collection.iterator();
    while (iterator.hasNext()) {
        String next = iterator.next();
        System.out.println("迭代器遍历出来的集合元素：" + next);
    }
}

迭代器遍历出来的集合元素：a
迭代器遍历出来的集合元素：b
迭代器遍历出来的集合元素：c