浅析Java中的Collection接口

Forlogen
101 阅读2分钟

文章目录

1. 引入

集合和数组的区别：

  • 数组的长度都是固定的，集合长度是可变的

  • 数组中存储的是同一类型的而元素，可以存储基本数组类型值。集合存储的都是对象，而且对象的类型可以不一致，在开发中一般当对象多时，使用集合进行存储。


    img

java.util.Collection接口时所有单列集合的最顶层接口，定义了所有单列集合共性的方法。任意的单列集合（Set、List、Queue）都可以使用Collection接口中的方法。Collection接口只是定义了单列接口实现时应遵循的规范，并没有提供直接的实现类，而是提供更具体的子接口的实现类。

2. 常用方法

Collection接口中定义的常用的方法有：

  • boolean add(E e):把给定的对象添加到当前集合中
  • boolean addAll(Collection coll)：将给定集合的元素添加到当前的集合中
  • void clear():清空集合中所有的元素
  • boolean remove(E e):把给定的对象在当前集合中删除
  • boolean removeAll(Collection coll):取当前集合的差集
  • boolean contains(E e):判断当前集合中是否包含给定的对象
  • boolean isEmpty():判断当前集合是否为空
  • boolean containsAll(Collection c):判断两个集合是否相同
  • int size():返回集合中元素的个数
  • Object[] toArray():把集合中的元素，存储到数组中
  • boolean retainAll(Collection c)：取两个集合的交集
  • boolean equals(Object obj)：判断集合是否相等
  • iterator()：返回迭代器对象，用于集合遍历

测试代码

public class CollectionMain {

    @Test
    public void test1() {
        Collection<String> array = new ArrayList<>();

        array.add("Forlogen");
        array.add("James");
        System.out.println(array);
        System.out.println("-----------------");

        System.out.println(array.contains("Forlogen"));
        System.out.println(array.contains("kobe"));
        System.out.println("-----------------");

        System.out.println(array.isEmpty());
        System.out.println("-----------------");

        System.out.println(array.size());
        System.out.println("-----------------");

        Object[] arr = array.toArray();
        System.out.println(Arrays.toString(arr));
        System.out.println("-----------------");


        boolean b = array.remove("Forlogen");
        System.out.println(array);
        System.out.println("-----------------");

        array.clear();
        System.out.println(array);
    }

测试代码对应的输出为：

[Forlogen, James]
-----------------
true
false
-----------------
false
-----------------
2
-----------------
[Forlogen, James]
-----------------
[James]
-----------------
[]

更多方法的测试：

public class CollectionMain {

    @Test
    public void test2(){
        Collection<String> col = new ArrayList<>();

        List<String> list = new ArrayList<>();
        Collections.addAll(list, "Forlogen", "Kobe", "James");
        list.forEach((k)-> System.out.println(k));
        System.out.println("-----------------");

        boolean b = col.addAll(list);
        System.out.println(Arrays.toString(col.toArray()));
        System.out.println("-----------------");


        System.out.println(col.contains("Kobe"));
        System.out.println("-----------------");

        System.out.println(col.contains("Amy"));
        System.out.println("-----------------");
		
		// 判断两个集合是否相等
        System.out.println(col.containsAll(list));
        System.out.println("-----------------");

        list.add("Hart");
        System.out.println(Arrays.toString(col.toArray()));
        System.out.println(Arrays.toString(list.toArray()));
		
		// 取两个集合的交集
        boolean b1 = col.retainAll(list);
        System.out.println(Arrays.toString(col.toArray()));
        System.out.println("-----------------");

        System.out.println(col.equals(list));
        System.out.println("-----------------");
		
		// 迭代遍历
        Iterator<String> iterator = col.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("-----------------");
		
		// 取两个集合的差集
        list.removeAll(col);
        System.out.println(Arrays.toString(list.toArray()));
        System.out.println("-----------------");


    }
}

输出如下所示：

Forlogen
Kobe
James
-----------------
[Forlogen, Kobe, James]
-----------------
true
-----------------
false
-----------------
true
-----------------
[Forlogen, Kobe, James]
[Forlogen, Kobe, James, Hart]
[Forlogen, Kobe, James]
-----------------
false
-----------------
Forlogen
Kobe
James
-----------------
[Hart]
-----------------

3. Collection源码

package java.util;

import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public interface Collection<E> extends Iterable<E> {
    // Query Operations
    int size();
    
    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();
    <T> T[] toArray(T[] a);
	
    // Modification Operations
    boolean add(E e);
	
    // Bulk Operations
    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

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

    boolean removeAll(Collection<?> c);

    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();
	
    // Comparison and hashing
    boolean equals(Object o);

    int hashCode();

    @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);
    }
}
avatar
文章
阅读
粉丝