Question

我运行了我的探查器程序1000次迭代，以计算插入Empty ArrayList所需的平均时间和插入Non-Empty ArrayList的平均时间。我为ArrayList<Item>运行了我的探查器程序，其中Item类是

class Item{
  int id;
  String name;
}

分析器程序类似于

main(){
  final int iterations = 1000;

  /**** Empty List Insert ****/
  int id = 0;
  long[] timerecords = new long[iterations];
  ArrayList<Item> list = new ArrayList<>();
  for (int i = 0; i < iterations; i++) {
      long stime = System.nanoTime(); //Start Time
      list.add(new Item(id, "A"));
      long elapsedTime = System.nanoTime() - stime; //Elapsed time
      timerecords[i] = elapsedTime; //Record Elapsed time

      //reset
      list.clear();
  }
  System.out.println("Empty List Insert Takes = " + getAverageTime(timerecords) + " nanoseconds");

  /**** Non-Empty List Insert ****/
  list = new ArrayList<>();
  timerecords = new long[iterations];
  //Insert some Items
  list.add(new Item(id++, "B")); list.add(new Item(id++, "R"));
  list.add(new Item(id++, "H")); list.add(new Item(id++, "C")); 

  for (int i = 0; i < iterations; i++) {    
        Item item = new Item(id, "A");
        long stime = System.nanoTime(); //Start Time
        list.add(item);
        long elapsedTime = System.nanoTime() - stime; //Elapsed time
        timerecords[i] = elapsedTime; //Record Elapsed time

        //reset
        list.remove(item);
  }
  System.out.println("Non-Empty List Insert Takes = " + getAverageTime(timerecords) + " nanoseconds");
}

其中getAverageTime(long [] timerecords)方法返回double的平均时间。在多次运行该程序之后，我观察到插入空ArrayList比插入非空ArrayList需要更多时间。一个这样的运行输出是

Empty List Insert Takes = 1027.781 nanoseconds
Non-Empty List Insert Takes = 578.825 nanoseconds

这背后的原因是什么？

Answer 1

差异来自于实例创建（new Item（））。

  long stime = System.nanoTime(); //Start Time
  list.add(new Item(id, "A")); // at this point two things are happening
  // creation of instance & addition into ArrayList
  // both takes their own time.

  long elapsedTime = System.nanoTime() - stime; //Elapsed time

u创建stime变量的点是计时器启动的点。您当然是在列表中添加新项目。但在第一种情况下，在你做System.nanoTime（）之前;你在添加项目时调用了新的运算符（在你指定stime变量之后），这需要额外的时间。而在第二种情况下，你在做System.nanoTime（）之前就是这么做的;

    Item item = new Item(id, "A");
    long stime = System.nanoTime(); //Start Time
    list.add(item);
    long elapsedTime = System.nanoTime() - stime; //Elapsed time

因此，仅捕获将项目对象添加到ArrayList时间。

Answer 2

如果你研究ArrayList的实现 - 一个空的ArrayList以一个空数组开头来存储数据 - 这很容易。

但是当你第一次调用add()方法时，需要复制这个数组 - 因此需要分配内存。 ensureCapacity()和grow()方法尝试最小化Arrays.copyOf()的创建，但只要内部数组大小仍然很小，就必须越来越多地增加此数组，这可能会增加导致持续时间增加。

这是来自1.7的ArrayList.grow(int)：

  private void grow(int minCapacity) {
    int oldCapacity = this.elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if(newCapacity - minCapacity < 0) {
      newCapacity = minCapacity;
    }

    if(newCapacity - 2147483639 > 0) {
      newCapacity = hugeCapacity(minCapacity);
    }

    this.elementData = Arrays.copyOf(this.elementData, newCapacity);
  }

您没有测量创建非空ArrayLIst的时间，是吗？

Answer 3

我很感兴趣，所以我做了一些调试。效果来自两个不同的来源：

正如@Alexander已经指出的那样，不断增加Arraylist大小的容量会影响你的测试。要“修复”此问题，您只需创建具有足够规定的ArrayLists，例如：

ArrayList<Item> list = new ArrayList<>(iterations * 2);

即使这样做之后，您可以发现第一个和第二个测试用例之间的性能差异为100-300％。其原因与Java内部有关，即ClassLoading和JIT。通过在第一次测试之前进行一次温暖回合，如下所示：

    int rounds = 10000;
    long[] t = new long[rounds];
    ArrayList<Item> warmUpList = new ArrayList<>(rounds);
    for (int i = 0; i < rounds; i++) {
        warmUpList.add(new Item(0, "A"));
        long stime = System.nanoTime(); // Start Time
        long elapsedTime = System.nanoTime() - stime; // Elapsed time
        t[i] = elapsedTime; // Record Elapsed time
    }

您可以使用优化程序。通过将“round”变量的值从100增加到10.000，您可以看到自己的测试如何获得更好和更好的性能，而不是以相同的速度稳定。

Answer 4

使用System.nanoTime()对每个插入进行测试可能会导致值不可靠。最好对System.currentTimeMillis()执行相同操作并测量整个循环。

此外，ArrayList中的插入时间可能会影响执行内部数组的增长量。因此，插入带有小内部数组的空ArrayList会导致许多增长。插入具有部分空的大内部数组的非空ArrayList可能导致不增长，但如果增长发生则比空数组慢，因为你必须复制更大的数组。

为什么插入空ArrayList比插入非空ArrayList花费更多时间？

4 个答案: