一篇弄懂ArrayList

最新推荐文章于 2022-08-29 10:29:30 发布

liu1002880404

最新推荐文章于 2022-08-29 10:29:30 发布

阅读量141

点赞数 1

分类专栏：性能调优文章标签：链表 java 数据结构

本文链接：https://blog.csdn.net/liuerchong/article/details/123474720

版权

性能调优专栏收录该内容

14 篇文章 3 订阅

订阅专栏

文章目录

ArrayList 简介

ArrayList 的底层是数组，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList实例的容量。这可以减少递增式再分配的数量。
ArrayList 继承于 AbstractList ，实现了 List , RandomAccess , Cloneable , java.io.Serializable 这些接口。

public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable{ }

1.RandomAccess 是一个标志接口，表明实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。

2.ArrayList 实现了 Cloneable 接口，即覆盖了函数 clone() ，能被克隆。

3.ArrayList 实现了 java.io.Serializable 接口，这意味着 ArrayList 支持序列化，能通过序列化去传输。

Arraylist 和 Vector 的区别

ArrayList 是 List 的主要实现类，底层使用 Object[ ] 存储，适用于频繁的查找工作，线程不安全；

Vector 是 List 的古老实现类，底层使用 Object[ ] 存储，线程安全的。

Arraylist 与 LinkedList 区别

1.是否保证线程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
2.底层数据结构： Arraylist 底层使用的是 Object 数组； LinkedList 底层使用的是双向链表数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环）
3.插入和删除是否受元素位置的影响： ① ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。比如：执行 add(E e) 方法的时候，ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（ add(int index, E element) ）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② LinkedList 采用链表存储，所以对于 add(E e) 方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置 i 插入和删除元素的话（ (add(int index, E element) ）时间复杂度近似为 o(n)) 因为需要先移动到指定位置再插入。
4,是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而 ArrayList支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于 get(int index)方法)。
5.内存空间占用： ArrayList 的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而LinkedList 的空间花费则体现在它的每一个元素都需要消耗比ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据) 。

ArrayList 的构造函数

/**
* 默认初始容量大小 
*/
private static final int DEFAULT_CAPACITY = 10;

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
*默认构造函数，使用初始容量10构造一个空列表(无参数构造) 
*/ 
public ArrayList() { 
  this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; 
}
// 带初始容量参数的构造函数。（用户自己指定容量）
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            //初始容量等于0
            //创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            //创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            //初始容量小于0，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
// 构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回 如果指定的集合为null，throws NullPointerException。
 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。
补充：JDK7 new无参构造的ArrayList对象时，直接创建了长度是10的Object[]数组elementData 。jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式。JDK8的内存优化也值得我们在平时开发中学习。

ArrayList 扩容机制

这里以无参构造函数创建的 ArrayList 为例分析，先来看 add 方法

//将指定的元素追加到此列表的末尾。
public boolean add(E e) {
        //添加元素之前，先调用ensureCapacityInternal方法
        ensureCapacityInternal(size + 1); 
        // Increments modCount!! 
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
}

JDK11 移除了 ensureCapacityInternal() 和 ensureExplicitCapacity() 方法
再来看看 ensureCapacityInternal() 方法
（JDK7）可以看到 add 方法首先调用了 ensureCapacityInternal(size + 1)

//得到最小扩容量 
private void ensureCapacityInternal(int minCapacity) { 
   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
     // 获取默认的容量和传入参数的较大值 
     minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
   }
     ensureExplicitCapacity(minCapacity); 
   }

当要 add 进第 1 个元素时，minCapacity 为 1，在 Math.max()方法比较后，minCapacity 为 10。此处和后续 JDK8 代码格式化略有不同，核心代码基本一样。

ensureExplicitCapacity() 方法
如果调用 ensureCapacityInternal() 方法就一定会进入（执行）这个方法，下面我们来研究一下这个方法的源码！

//判断是否需要扩容 
private void ensureExplicitCapacity(int minCapacity) { 
    modCount++; 
    // overflow-conscious code 
    if (minCapacity - elementData.length > 0) 
    //调用grow方法进行扩容，调用此方法代表已经开始扩容了 
    grow(minCapacity); 
}

1.当我们要 add 进第 1 个元素到 ArrayList 时，elementData.length 为 0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal() 方法，所以 minCapacity此时为 10。此时， minCapacity - elementData.length > 0 成立，所以会进入grow(minCapacity) 方法。

2.当 add 第 2 个元素时，minCapacity 为 2，此时 e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时， minCapacity - elementData.length > 0 不成立，所以不会进入 grow(minCapacity) 方法。
添加第 3、4···到第 10 个元素时，依然不会执行 grow 方法，数组容量都为 10。直到添加第 11 个元素，minCapacity(为 11)比 elementData.length（为 10）要大。进入grow 方法进行扩容。

// ArrayList扩容的核心方法。
 private void grow(int minCapacity) {
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        //将oldCapacity 右移一位，其效果相当于oldCapacity /2， 
        //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
            // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCa 
            //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大
        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);
    }

int newCapacity = oldCapacity + (oldCapacity >> 1),">>"（移位运算符）：>>1 右移一位相当于除 2，右移 n 位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了 1 位所以相当于 oldCapacity /2。对于大数据的 2进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源
所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右（oldCapacity 为偶数就是 1.5 倍，否则是 1.5 倍左右）！奇偶不同，比如：10+10/2 = 15, 33+33/2=49。如果是奇数的话会丢掉小数.

当 add 第 1 个元素时，oldCapacity 为 0，经比较后第一个 if 判断成立，newCapacity = minCapacity(为 10)。但是第二个 if 判断不会成立，即 newCapacity不比 MAX_ARRAY_SIZE 大，则不会进入hugeCapacity 方法。数组容量为 10，add方法中 return true,size 增为 1。当 add 第 11 个元素进入 grow 方法时，newCapacity 为 15，比 minCapacity（为11）大，第一个 if 判断不成立。新容量没有大于数组最大 size，不会进入hugeCapacity 方法。数组容量扩为 15，add 方法中 return true,size 增为 11。以此类推······
这里补充一点比较重要，但是容易被忽视掉的知识点：
java 中的 length 属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性.java 中的 length() 方法是针对字符串说的,如果想看这个字符串的长度则用到length() 这个方法.
java 中的 size() 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!
hugeCapacity() 方法。
从上面 grow() 方法源码我们知道：如果新容量大于 MAX_ARRAY_SIZE,进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，如果 minCapacity 大于
最大容量，则新容量则为 Integer.MAX_VALUE ，否则，新容量大小则为
MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8 。

private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//对minCapacity和MAX_ARRAY_SIZE进行比较
//若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
//若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}

ensureCapacity()方法

先看代码

 import java.util.ArrayList;
 
public class ArrayListSpeed {
 
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        final int N = 100000000;  //多加了一个零
        Object obj = new Object();
 
        /*没用调用ensureCapacity()方法初始化ArrayList对象*/
        ArrayList list = new ArrayList();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i <= N; i++) {
            list.add(obj);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("没有调用ensureCapacity()方法所用时间："
                + (endTime - startTime) + "ms");
 
        /*调用ensureCapacity()方法初始化ArrayList对象*/
        list = new ArrayList();
        startTime = System.currentTimeMillis();
 
        // 预先设置list的大小
        list.ensureCapacity(N);
        for (int i = 0; i <= N; i++) {
            list.add(obj);
        }
        endTime = System.currentTimeMillis();
        System.out.println("调用ensureCapacity()方法所用时间：" + (endTime - startTime)
                + "ms");
    }
}

结果却大大不同：

没有调用ensureCapacity()方法所用时间：596ms
调用ensureCapacity()方法所用时间：2283ms

public void ensureCapacity(int miniCapacity) 确保容量至少等于指定的最小值。如果当前容量小于 minimumCapacity 参数，则可分配一个具有更大容量的新的内部数组。新容量的取以下两者中较大者：
miniCapacity参数
旧容量×2＋2
容量(capacity)会按照使用ensureCapacity()方法的规则变化，类似一种缓存机制，大小的设定要根据程序的需求，最终达到空间和时间的最佳比。

最好在 add 大量元素之前用 ensureCapacity 方法，以减少增量重新分配的次数