ArrayList部分源码解析(JDK8)

最新推荐文章于 2025-01-06 09:25:28 发布

原创最新推荐文章于 2025-01-06 09:25:28 发布 · 335 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#集合 #JavaSEt #ArrayList #List #源码

JavaSE-集合框架专栏收录该内容

3 篇文章

订阅专栏

本文聚焦于Java中ArrayList类，它是List接口重要实现类。解析了其部分源码，包括底层是对象数组，add方法有普通添加和指定索引添加两种，contains方法依赖equals方法。还对比了Vector和LinkedList，Vector保证线程安全，LinkedList是双向链表结构。

List接口继承自Collction(单列集合)接口,而ArrayList是List接口的一个重要实现类,当学习了ArrayList后再看其他实现类，如Vector和LinkedList（前者可以看作ArrayList的线程安全版,后者是ArrayList的链表版）

本文选取ArrayList类部分源码进行解析

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
}

public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
}

add方法是两个互为重载方法

前者是普通的添加元素

 private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
}

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
}

方法体首先调用方法ensureCapacityInternal(size + 1),若elementData从未添加过元素,则获取size+1与private static final int DEFAULT_CAPACITY = 10; 比较,较大者则为初始长度,后再比较当前数组长度,若此时长度比数组长度大且不超过Integer最大值2147483647,则通过grow方法获取一个原数组长度1.5倍的新elementData数组

后者是指定索引位置添加元素,只是在前者的基础上多了索引是否在elementData数组长度范围内的检查若超出则抛出数组越界异常IndexOutOfBoundsException

private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

在数组长度范围内则调用System.arraycopy方法获得一个在指定索引处添加了新元素的新数组

检查包含方法---contains

public boolean contains(Object o) {
        return indexOf(o) >= 0;
}

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
}

通过查看源码我们可以知道,contains方法底层依赖于equals()方法,这意味着当我们的ArrayList对象存储的是对自定义对象时,需要重写equals方法,否则默认的equals方法比较的是地址,没什么意义

与Vector、LinkedList部分代码对比

学习了ArrayList的重点方法后,我们再来对比Vector与LinkedList方法,便能发现其实原理都差不多，以add方法为例

Vector

public synchronized boolean add(E e) {        // 线程安全
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
}

在方法处加了synchronized关键字保证了线程安全

LinkedList

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

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

Node<E>相当于双向链表的一个节点,节点保存着上一节点位置及下一节点位置,通过transient Node<E> first;指向双向链表头结点