java集合之Collection架构

Java集合之Collection架构

首先，我们对Collection进行说明。下面先看看Collection的一些框架类的关系图：

　　Collection是一个接口，它主要的两个分支是：List 和 Set。List和Set都是接口，它们继承于Collection。List是有序的队列，List中可以有重复的元素；而Set是数学概念中的集合，Set中没有重复元素！List和Set都有它们各自的实现类。 如ArrayList  LinkedList  Vector  Stack

　　为了方便，我们抽象出了AbstractCollection抽象类，它实现了Collection中的绝大部分函数；这样，在Collection的实现类中，我们就可以通过继承AbstractCollection省去重复编码。

　　AbstractList和AbstractSet都继承于AbstractCollection，具体的List实现类继承于AbstractList，而Set的实现类则继承于AbstractSet。

　　另外，Collection中有一个iterator()函数，它的作用是返回一个Iterator接口。通常，我们通过Iterator迭代器来遍历集合。ListIterator是List接口所特有的，在List接口中，通过ListIterator()返回一个ListIterator对象。 接下来，我们看看各个接口和抽象类的介绍；然后，再对实现类进行详细的了解。

　　接下来我们来看Collection接口：

　　

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

/**
*继承了Iterable接口,Iterable是一个迭代器接口，里面有返回迭代器的抽象方法
*/
public interface Collection<E> extends Iterable<E> {

    int size();//返回集合元素个数

    boolean isEmpty();//是否为空

    boolean contains(Object o);//集合中是否存在这个对象

    Iterator<E> iterator();//从Iterable中继承而来

    Object[] toArray();//将集合转换为object数组

    <T> T[] toArray(T[] a);//将集合转换特定类型的数组
 
    boolean add(E e);//添加

    boolean remove(Object o);//删除

    boolean containsAll(Collection<?> c);//本集合是否和参数集合相同

    boolean addAll(Collection<? extends E> c);//添加一个集合

    boolean removeAll(Collection<?> c);//删除本集合中所有参数集合中元素

    boolean retainAll(Collection<?> c);//retain保留

    void clear();//清空

    boolean equals(Object o);//Object中方法

    int hashCode();//hash函数

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

 　　我们可以看到Collection中定义了几个集合基本操作的抽象方法，然后这个接口继承于Iterable接口，Iterable接口中定义了返回迭代器的抽象函数，这个Iterator迭代器中定义迭代函数，集合的实现类一般是通过内部类的方式来实现这个Iterator接口，然后再通过iterator函数new一个实例返回，以后我们看到具体的实现类是再分析。

package java.lang;
import java.util.Iterator;
import java.util.Objects;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Consumer;

public interface Iterable<T> {
    //这个抽象方法会返回一个Iterator接口，
    //所以所有集合类只要支持迭代就必须实现这个函数并且实现Iterator接口中的函数（一般以内部类中实现）
    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {//
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }


    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

　　接下来我们看一下List接口：

　　List是一个继承于Collection的接口，即List是集合中的一种。List是有序的队列，List中的每一个元素都有一个索引；第一个元素的索引值是0，往后的元素的索引值依次+1。和Set不同，List中允许有重复的元素。关于API方面。既然List是继承于Collection接口，它自然就包含了Collection中的全部函数接口；由于List是有序队列，它也额外的有自己的API接口。主要有“添加、删除、获取、修改指定位置的元素”、“获取List中的子队列”等。

package java.util;
import java.util.function.UnaryOperator;
/**
*list接口继承了Colleciton接口。
*/
public interface List<E> extends Collection<E> {

    //List新增的抽象方法。我们可以发现List接口这些新增的抽象方法有个特点就是可以通过数组下标访问，
    //这就体现list集合的特性有序且可随机访问
    E remove(int index);

    E get(int index);//随机访问方法

    E set(int index, E element);//指定下标添加元素，并返回这个元素

    void add(int index, E element);

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

    int indexOf(Object o);//从前往后通过元素找下标

    int lastIndexOf(Object o);

    ListIterator<E> listIterator();//返回List特有的迭代器，可以向前向后迭代等

    ListIterator<E> listIterator(int index);//返回从某个下标开始的List特有的迭代器

    List<E> subList(int fromIndex, int toIndex);//截取部分List集合

    //Collection中的抽象方法
    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();

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

    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

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

    boolean removeAll(Collection<?> c);

    boolean retainAll(Collection<?> c);

    void clear();

    boolean equals(Object o);

    int hashCode();

    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) {//通过外部排序进行排序的方法，我们发现他是通过Arrays工具类实现的
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }


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

　　Set接口：

 　　Set接口也是继承于Collection接口，它里面的元素不允许重复，后面会解释为啥不允许重复。

　　接下来是AbstractCollection抽象类：