ArrayList的容量大小增加了奇怪的行为

Question

当ArrayList想要存储比实际容量更多的元素时，它将增加容量。 因为我们实际上将所有数据从以前的ArrayList复制到更大容量的新ArrayList，所以这是非常节省成本的操作。 但是我想知道当ArrayList只需要更多空间时，也许没有进行某些具有容量的操作-但是要早得多。 我不知道我的唯一想法就是花这么长时间才能从输出中获得“慢索引”并增加容量。 这是我的代码：

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class MainArr {
    ArrayList<Integer> normalList = new ArrayList<Integer>();

    public static void main(String[] args) throws Exception {
        MainArr m = new MainArr();
        m.addElements();
    }

    public void addElements() throws Exception {
        long startTime = System.currentTimeMillis();
        for (int j = 0; j < 20000000; j++) {
            if (j % 500000 == 0) {
            System.out.println("j:" + j + " capacity:" + getCapacity(this.normalList));
        }
        long addTime = System.currentTimeMillis();
        this.normalList.add(j);
        if (System.currentTimeMillis() - addTime > 50) {
            System.out.println("slow index-" + j + " - time:" + (System.currentTimeMillis() - addTime));
        }
    }
    System.out.println("End after:" + (System.currentTimeMillis() - startTime));
}

int getCapacity(List al) throws Exception {
    Field field = ArrayList.class.getDeclaredField("elementData");
    field.setAccessible(true);
    return ((Object[]) field.get(al)).length;
    }
}

输出：

j:0 capacity:0
j:500000 capacity:540217
j:1000000 capacity:1215487
j:1500000 capacity:1823230
j:2000000 capacity:2734845
j:2500000 capacity:2734845
j:3000000 capacity:4102267
j:3500000 capacity:4102267
j:4000000 capacity:4102267
slow index-4102267 - time:1203 //We need more space in ArrayList.That's why it takes some time.
j:4500000 capacity:6153400
j:5000000 capacity:6153400
j:5500000 capacity:6153400
j:6000000 capacity:6153400
j:6500000 capacity:9230100
slow index-6758010 - time:1477 //We dont need to increase capacity. But we stop for a moment...
j:7000000 capacity:9230100 //... and we have the same capacity
j:7500000 capacity:9230100
j:8000000 capacity:9230100
j:8500000 capacity:9230100
j:9000000 capacity:9230100
j:9500000 capacity:13845150 // Somehow capacity is increased insanely fast
j:10000000 capacity:13845150
j:10500000 capacity:13845150
j:11000000 capacity:13845150
j:11500000 capacity:13845150
j:12000000 capacity:13845150
slow index-12426474 - time:3168 //We dont need to increase capacity. But we stop for a moment...
j:12500000 capacity:13845150 //... and we have the same capacity
j:13000000 capacity:13845150
j:13500000 capacity:13845150
j:14000000 capacity:20767725  // Somehow capacity is increased insanely fast
j:14500000 capacity:20767725
slow index-14639924 - time:144  
j:15000000 capacity:20767725
j:15500000 capacity:20767725
j:16000000 capacity:20767725
j:16500000 capacity:20767725
j:17000000 capacity:20767725
j:17500000 capacity:20767725
j:18000000 capacity:20767725
j:18500000 capacity:20767725
j:19000000 capacity:20767725
j:19500000 capacity:20767725
slow index-19980735 - time:218
End after:6990

Answer 1

ArrayList代码经过优化，以从10开始容量，并在需要更多空间时每次增加1.5倍。

您可以使用程序的修改版本来检测精确的增长点：

public void addElements() throws Exception {
    int lastCap = -1;
    for (int j = 0; j < 1000000; j++) {
        this.normalList.add(j);
        int cap = getCapacity(this.normalList);
        if (cap != lastCap) {
            System.out.println("size:" + normalList.size() + " capacity:" + cap);
            lastCap = cap;
        }
    }
}

int getCapacity(List al) throws Exception {
    Field field = ArrayList.class.getDeclaredField("elementData");
    field.setAccessible(true);
    return ((Object[]) field.get(al)).length;
}

这将打印以下数字：

size:1 capacity:10
size:11 capacity:15
size:16 capacity:22
size:23 capacity:33
size:34 capacity:49
size:50 capacity:73
size:74 capacity:109
... // And so on

负责增加列表的源代码在ensureCapacity方法中，如下所示：

int newCapacity = (oldCapacity * 3)/2 + 1;

这等效于整数乘以1.5。

Answer 2

每次调用add函数时，它将调用带有size+1作为minCapacity参数（列表的大小，而不是列表后面的数组）的ensureCapacity函数。

你可以看到的代码ensureCapacity如下：

 public void ensureCapacity(int minCapacity) {
         modCount++;
         int oldCapacity = elementData.length;
         if (minCapacity > oldCapacity) {
             Object oldData[] = elementData;
             int newCapacity = (oldCapacity * 3)/2 + 1;
             if (newCapacity < minCapacity)
                 newCapacity = minCapacity;
             // minCapacity is usually close to size, so this is a win:
             elementData = Arrays.copyOf(elementData, newCapacity);
         }
     }

请注意，仅当minCapacity参数大于数组的当前大小时，它才会创建一个新数组。

编辑（感谢@Jyotsana Nandwani）：

在JDK 1.7中，计算调整大小的新方法是：

int newCapacity = oldCapacity + (oldCapacity >> 1)

右移操作员确保将容量增加到旧容量的50％，即1.5倍

Answer 3

为了提高性能，请尝试在ArrayList实例上定义大容量。 例如：

List<Users> users = new ArrayList<>(100000);
users.add(new User("John", "Doe"));

仅在事先知道所需容量的情况下，这才有帮助。 如果您不知道会有多少个实例，请考虑使用其他数据结构。

例如，看一下Queue接口的实现，特别是LinkedList 。 此数据结构具有添加新元素的恒定时间，但是当它们位于列表的中间时，不利于按索引获取元素。 请注意， LinkedList还实现了List接口以及ArrayList因此以下语法有效：

List<Users> users = new LinkedList<>();
users.add(new User("John", "Doe"));