Java集合（二）

Collection接口

续 Java集合（一）中 2.1 章节的List接口的另几个实现类

继承关系

2.2 LinkedList

和ArrayList一样都是List接口的一个实现类，继承结构为：

class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

LinkedList和ArrayList的区别联系

• ArrayList通过类的结构可以看出是使用数组对元素进行存储的，并且还有一系列的方法进行扩容。
• LinkedList通过链表的存储结构实现，还是双向链表，可以用作队列，在后面的分析中会展开。
• 共同点就是两者的操作都是线程不安全的

相关变量和结构

Node<E> first;//链表头节点
Node<E> last;//链表尾节点
//节点定义
private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
		//链表节点定义，指向前一个和指向后一个的指针
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

• 对应的增删改查插入操作

添加元素

public boolean add(E e) {
        linkLast(e);//尾插
        return true;
    }
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);//在链表尾部新增一个节点
        last = newNode;
        if (l == null)
            first = newNode;//如果是首次插入，直接是头节点
        else
            l.next = newNode;//否则添加到链表的末尾
        size++;//链表长度加一
        modCount++;
    }

删除元素
空参函数默认删除头节点

public E remove() {
        return removeFirst();//删除链表的头节点
    }
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();//没有头节点就抛出异常
        return unlinkFirst(f);//删除头节点
    }
    private E unlinkFirst(Node<E> f) {
        //根据上面的判定条件 f == first && f !=null;
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; //方便GC搜寻
        first = next;//将第二个节点赋值成为首节点
        if (next == null)//如果删除之后没有节点了还要更改 last 节点
            last = null;
        else
            next.prev = null;//头节点指向为空
        size--;//长度-1
        modCount++;
        return element;
    }

删除指定位置的元素

public E remove(int index) {
        checkElementIndex(index);//检查 index 的合法性
        return unlink(node(index));//去掉该节点
    }
    Node<E> node(int index) {//确认位置处的节点是哪个，和 ArrayList 相比，随机访问速度确实慢
        //根据双向链表的性质，分成两半进行查找
        if (index < (size >> 1)) {//如果在序号在前一半，就从前向后搜索
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {//后半段的话就从后搜索
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }
    E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;//要删除节点的后一个
        final Node<E> prev = x.prev;//前一个

        if (prev == null) {
            first = next;//前面为空说明是头节点，直接连接后面就OK
        } else {
            prev.next = next;//找到前驱节点
            x.prev = null;//释放前指针，方便GC
        }

        if (next == null) {
            last = prev;//删除的是最后节点
        } else {
            next.prev = prev;
            x.next = null;//释放后指针
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

更改元素

public E set(int index, E element) {
        checkElementIndex(index);//index是否越界
        Node<E> x = node(index);//找到对应节点
        E oldVal = x.item;
        x.item = element;//更改节点值
        return oldVal;
    }

查询
和ArrayList的O(1)相比，链表存随机查找性能要更差为O(n)

public E get(int index) {//上面删除中用到的两个方法直接出结果
        checkElementIndex(index);
        return node(index).item;
    }

插入元素

public void add(int index, E element) {
        checkPositionIndex(index);//检查index合法性

        if (index == size)
            linkLast(element);//末尾的话就直接尾插
        else
            linkBefore(element, node(index));
    }
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;//插入点前的元素
        final Node<E> newNode = new Node<>(pred, e, succ);//根据传入值新建节点
        succ.prev = newNode;//向后连接
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;//向前连接
        size++;
        modCount++;
    }

2.3 Vector

List类的第三种常用实现，他的类集成结构为：

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

成员变量

protected Object[] elementData;//和ArrayList一样的数组保存

初始化

public Vector() {
        this(10);//和ArrayList不同的是默认是 10 个元素的初始长度
    }
    

添加元素时的扩容操作

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //下面的扩容中，初始化没有指定 capacityIncrement（增量扩容值）时，默认值就是0 ，扩容就是按照2倍进行扩容，初始化赋值的话，就是按照增量扩容
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

2.4 常用的一些结构

Queue队列结构

public interface Queue<E> extends Collection<E>

一般使用LinkedList实现，搭配offer(),poll()方法实现入队出队，利用了链表的特性，也能实现双头队列

Queue<E> queue = new LinkedList<>();

Stack堆栈结构

class Stack<E> extends Vector<E>

作为Vector的字类，搭配push(),pop(),peek()等方法也是蛮好用

2.5 List的遍历以及Iterator

继承关系如下：

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

所以List的实现类可以通过iterator()获得Iterator对象进行遍历，接口结构如下：

迭代器接口iterator中的方法：

具体使用，以ArrayList为例，其他List实现类遍历用法一致的

ArrayList arr = new ArrayList<>();
///.....省略一些插入操作，获得一个非空arr
Iterator ite = arr.iterator();
while(ite.hasNext()){
	System.out.println(ite.next);
}

2.6 List三种实现类的区别和联系

相同点

• 三个类都是实现了List接口，存储数据的特点相同：存储序的、可重复的数据

差异性

• ArrayList和LinkedList线程不安全，Vector线程安全；所以前两者操作效率高，后者效率低
• ArrayList和Vector使用的都是对象数组存储元素，LinkedList使用双向链表；前两者随机访问效率高，后者的插入效率高
• Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的使用 ArrayList而不是Vector,因为同步完全可以自己来控制。Vector每次扩容请求其大 小的2倍空间，而ArrayList是1.5倍。