Java核心技术笔记——数据结构（1）

java设计了一套集合（也叫容器）类库，来支持最常用的数据结构，Java集合类库采用接口与实现分离的原则。下面主要梳理集合接口，集合类（包括集合抽象类和具体实现类）。

1 Java集合接口

Java的集合接口关系图如下：

集合有两个基本接口Collection和Map
（1） Collection接口的源码如下：

public interface Collection<E> extends Iterable<E> {
    // Query Operations
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    //返回迭代器对象，用来访问集合中的元素
    Iterator<E> iterator();
    //返回集合的对象数组
    Object[] toArray();
    //添加元素
    boolean add(E e);
    //移除元素
    boolean remove(Object o);
    //判断传入集合是否被包含
    boolean containsAll(Collection<?> c);
    //与传入集合求交集
    boolean retainAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
}

（2）Map用来存放键值对，Map接口源码如下：

public interface Map<K,V> {
    // Query Operations
    int size();
    boolean isEmpty();
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    //获取对应k的值，如果没有这个值，则返回null,K可以为null
    V get(Object key);
    // Modification Operations
    //插入k和v,此处可以插入k为null的键值对，但是v不能为null
    V put(K key, V value);
    V remove(Object key);

    // Bulk Operations

    void putAll(Map<? extends K, ? extends V> m);

    void clear();

    // Views
    /*--注意从下面三个返回的集中，可以删除元素，与此同时也删除了Map中的元素，但是不能添加元素---***/

    //返回Map中所有K的Set集
    Set<K> keySet();
    //返回Map中所有V的Collection集合
    Collection<V> values();
    //整个键值对作为一个Set集返回
    Set<Map.Entry<K, V>> entrySet();

        interface Entry<K,V> {
            K getKey();
            V getValue();
            V setValue(V value);
            boolean equals(Object o);
            int hashCode();
        }
    // Comparison and hashing

    boolean equals(Object o);
    int hashCode();
}

注意，在Java中访问集合中某个位置元素，要使用迭代器（Iterator）。
（3）Iterator接口的源码如下：

public interface Iterator<E> {
//返回将要访问的下一个对象，如果已经是集合的最后一个元素，将抛出NoSuchElementException错误
E next();
//由于上面方法抛出错误，因此在访问集合元素之前，先判断是否有下一个元素
boolean hasNext();
//移除元素之前，要先使用next方法定位到改元素；
void remove();
}

List是一个顺序排列集合接口，List在特定位置添加元素的方法有两种，一种是整数索引，一种是列表迭代器。
（4）List接口的源码如下：

public interface List<E> extends Collection<E> {
    // Query Operations
    //继承Collection方法，参考Collection源码分析
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    ........

    // Positional Access Operations
    //获取给定位置的元素
    E get(int index);
    //用新元素取代给定位置元素，返回原来的元素
    E set(int index, E element);
    //通过整数索引，在给定位置添加元素
    void add(int index, E element);
    //移除给定位置的元素
    E remove(int index);
    // Search Operations
    //返回与给定元素相等的元素在列表中第一次出现的位置，如果没有返回-1
    int indexOf(Object o);
    //返回与给定元素相等的元素在列表中最后一次出现的位置，如果没有放回-1
    int lastIndexOf(Object o);

    // List Iterators
    //返回一个列表迭代器
    ListIterator<E> listIterator();
    //返回一个列表迭代器，第一次调用next后，返回的给定索引的元素
    ListIterator<E> listIterator(int index);

    // View
    //返回List的某个范围内的子集合
    List<E> subList(int fromIndex, int toIndex);
}

由于Collection有的子集合（如Set）是无序的，所以Iterator接口中无add方法，但是对于List子集合需要使用迭代器添加指定位置的元素，因此ListIterator继承Iterator，提供了add方法。
（5）ListIterator接口源码如下：

public interface ListIterator<E> extends Iterator<E> {
    // Query Operations
    //继承Iterator方法，参考Iterator源码分析
    boolean hasNext();
    E next();
    //反向迭代列表时，判断是否有元素
    boolean hasPrevious();
    //返回前一个对象，如果已经是集合的第一个元素，将抛出NoSuchElementException错误
    E previous();
    //返回下一次调用next方法后，元素的索引
    int nextIndex();
     //返回下一次调用previous方法后，元素的索引
    int previousIndex();
    // Modification Operations
    void remove();
    void set(E e);
    void add(E e);
}

Set接口和Collection接口的方法一样，这里Java为什么要定义一个新的接口？是为了从概念上区分集合与集，方面扩展。
SortedSet和SortedMap接口，顾名思义给开发者暴露了排序的方法，并可以返回某个范围内的子集
（6）SortedSet的源码如下：

public interface SortedSet<E> extends Set<E> {
    //用于排序的方法，参考后续章节具体实现类
    Comparator<? super E> comparator();
    //下面三个方法，返回给定范围内的子SortedSet集
    SortedSet<E> subSet(E fromElement, E toElement);
    SortedSet<E> headSet(E toElement);
    SortedSet<E> tailSet(E fromElement);

    E first();
    E last();
}

（7）SortedMap的源码如下：

public interface SortedMap<K,V> extends Map<K,V> {
    //用于排序的方法，参考后续章节具体实现类
    Comparator<? super K> comparator();
    //下面三个方法，返回给定范围内的子SortedMap
    SortedMap<K,V> subMap(K fromKey, K toKey);
    SortedMap<K,V> headMap(K toKey);
    SortedMap<K,V> tailMap(K fromKey);

    //下面三个方法和Map接口中方法一样，参考Map接口源码
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();
}

Java SE6引入了NavigableSet和NavigableMap接口，用来在有序集和Map中查找遍历方法
（8）NavigableSet源码如下：

public interface NavigableSet<E> extends SortedSet<E> {

    E lower(E e);
    E floor(E e);
    .......

    //下面三个方法主要返回给定范围内的子NavigableSet,boolean 标志是否包括边界值
    NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                           E toElement,   boolean toInclusive);

    NavigableSet<E> headSet(E toElement, boolean inclusive);
    NavigableSet<E> tailSet(E fromElement, boolean inclusive);
    //下面三个方法和SortedSet接口中方法一样，参考SortedSet接口源码
    SortedSet<E> subSet(E fromElement, E toElement);
    SortedSet<E> headSet(E toElement);
    SortedSet<E> tailSet(E fromElement);
}

（9）NavigableMap源码如下：

public interface NavigableMap<K,V> extends SortedMap<K,V> {

    Map.Entry<K,V> lowerEntry(K key);
    K lowerKey(K key);
    Map.Entry<K,V> floorEntry(K key);
    K floorKey(K key)
    Map.Entry<K,V> ceilingEntry(K key);
    ........

    //下面三个方法，返回给定范围内的键的NavigableMap，boolean 表示是否包括边界
    NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                             K toKey,   boolean toInclusive);
    NavigableMap<K,V> headMap(K toKey, boolean inclusive);
    NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);

    //下面三个方法，与SortedMap方法一样，参考SortedMap源码
    SortedMap<K,V> subMap(K fromKey, K toKey);
    SortedMap<K,V> headMap(K toKey);
    SortedMap<K,V> tailMap(K fromKey);
}

队列是在尾部添加一个元素，在头部删除一个元素。双端队列是在头部和尾部都可以删除元素
（10）Queue的源码如下：

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

    //当执行add往队列中添加元素时，如果队列没有满，则往队列尾部添加元素并返回true，否则add方法抛出异常，offer方法返回false
    boolean add(E e);
    boolean offer(E e);

    //当执行remove移除队列中头部元素时，如果队列不空，则移除头部元素并返回true，否则remove方法抛出异常，poll方法返回false
    E remove();
    E poll();

    //当执行element查看队列中头部元素时，如果队列不空，则返回队列中的头部元素，否则element方法抛出异常，peek方法返回null
    E element();
    E peek();
}

（11）Deque（双端队列接口）源码如下：

public interface Deque<E> extends Queue<E> {
    //当给定的对象添加到双端队列的头部和尾部时，如果队列满了，则前两个方法抛出异常，后两个方法返回false
    void addFirst(E e);
    void addLast(E e);
    boolean offerFirst(E e);
    boolean offerLast(E e);

    //当删除双端队列头部和尾部元素时，如果队列为空，则前两个方法抛出异常，后两个方法返回null
    E removeFirst();
    E removeLast();
    E pollFirst();
    E pollLast();

    //当查询双端队列头部和尾部元素时，如果队列为空，则前两个方法抛出异常，后两个方法返回null
    E getFirst();
    E getLast();
    E peekFirst();
    E peekLast();

    boolean removeFirstOccurrence(Object o);
    boolean removeLastOccurrence(Object o);

    // *** Queue methods ***

    //参考Queue 中的add、offer方法说明
    boolean add(E e);
    boolean offer(E e);
    //参考Queue 中的remove、poll方法说明
    E remove();
    E poll();
    //参考Queue 中的element、peek方法说明
    E element();
    E peek();

    // *** Stack methods ***
    void push(E e);
    E pop();

    // *** Collection methods ***
    //参考Collection 中的方法说明
    boolean remove(Object o);
    boolean contains(Object o);
    public int size();
    Iterator<E> iterator();
    Iterator<E> descendingIterator();
}

RandomAccess接口用于监测List随机访问的效率，该接口没有方法，ArrayList继承了该接口。
（12）RandomAccess源码：

public interface RandomAccess {

}

2. Java集合类

前面的Java集合接口中有大量的方法，这些方法主要通过抽象类和具体类实现。其中抽象类主要实现接口中一部分通用的方法，具体类针对具体的类型实现具体的方法。
下面是Java集合类图：

2.1 Java集合抽象类

对于公用的方法可在集合抽象类实现，一些具体的方法可抽象化在继承的有具体特征的子类中实现。集合抽象类主要有AbstractCollection、AbstractMap
AbstractList、AbstractSet、AbstractQueue、AbstractSequentialList
这里以AbstractCollection源码为例分析一下：
AbstractCollection的源码如下：

public abstract class AbstractCollection<E> implements Collection<E> {

    protected AbstractCollection() {
    }

    // Query Operations
    //Collection接口中方法，可根据不同的集合，具体实现。
    //迭代器方法和集合大小方法抽象。
    public abstract Iterator<E> iterator();
    public abstract int size();

    //下面所有的方法都在抽象类中实现
    public boolean isEmpty() {
        return size() == 0;
    }

    //用迭代器，访问逐次访问集合中的元素，判断是否包含给定的对象
    public boolean contains(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

    //逐次访问集合中的元素，转换集合中对象为数组
    public Object[] toArray() {
       //根据集合大小定义数组
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) 
               // fewer elements than expected
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();

        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) { // fewer elements than expected
                if (a != r)
                    return Arrays.copyOf(r, i);
                r[i] = null; // null-terminate
                return r;
            }
            r[i] = (T)it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    //Integer.MAX_VALUE是int整形的最大取值2的31次方-1，这个常量用来控制集合的最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) {
                int newCap = cap + (cap >> 1) + 1;
                // overflow-conscious code
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        // trim if overallocated
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }

    //返回集合的最大容量值
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError
                ("Required array size too large");
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    // 添加对象方法实现
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }
    //移除对象方法实现
    public boolean remove(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext()) {
                if (it.next()==null) {
                    it.remove();
                    return true;
                }
            }
        } else {
            while (it.hasNext()) {
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }

    //批量操作方法实现
    //判断传入集合是否被包含方法实现
    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }
    //添加传入集合方法实现
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }
    //移除传入集合方法实现
    public boolean removeAll(Collection<?> c) {
        boolean modified = false;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }
    //实现与传入集合求交集方法
    public boolean retainAll(Collection<?> c) {
        boolean modified = false;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

    //对象转换为字符串
    public String toString() {
        Iterator<E> it = iterator();
        //如果集合中对象为null，返回"[]"
        if (! it.hasNext())
            return "[]";
        //拼接字符串
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }
}

2.2 Java集合具体实现类

我们项目中经常使用的具体类（Java集合类图中具体类）主要有LinkedList、ArrayList、HashSet、TreeSet、PriorityQueue、Array、Deque、HashMap、TreeMap，这些类的源码解析，见后续章节的分析；
下面是Java集合具体类的主要特征，如下表：