Java ArrayList.ListIterator（int索引）与ArrayList.get（int索引）

我想知道使用ArrayList.ListIterator（int index-1）时会对性能产生什么影响，然后是it.next（），与使用ArrayList.get（int index）相比？

为什么要看实现

1:List.listIterator（int） 2:List.get（int）

---

应该很明显，哪一个更快。有关性能影响的详细信息，我必须同意Mike的意见。配置它。无论是什么原因，您都希望使用这样一种独特的访问方法来访问一个项目（？）

在我的机器上对其进行了分析，数组列表为10000个整数

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

/**
 *
 * @author Michael Drogalis
 */
public class Launcher {

    public static void main(final String[] args) {
        List<Integer> sut = new ArrayList<Integer>();

        Random generator = new Random();
        for (int k = 0; k < 100000; k++) {
            sut.add(generator.nextInt(64));
        }

        testGetMethod(sut, generator);
        testIteratorMethod(sut, generator);
    }

    private static void testGetMethod(List<Integer> aList, Random aGenerator) {
        for (int k = 0; k < 100000; k++) {
            aList.get(aGenerator.nextInt(1000));
        }
    }

    private static void testIteratorMethod(List<Integer> aList, Random aGenerator) {
        for (int k = 0; k < 100000; k++) {
            Iterator iterator = aList.listIterator(Math.abs(aGenerator.nextInt(100000) - 1));
            iterator.next();
        }
    }
}

import java.util.ArrayList；
导入java.util.Iterator；
导入java.util.List；
导入java.util.Random；
/**
*
*@作者迈克尔·德罗加利斯
*/
公共类启动器{
公共静态void main（最终字符串[]args）{
List sut=new ArrayList（）；
随机生成器=新随机（）；
对于（int k=0；k<100000；k++）{
sut.add（generator.nextInt（64））；
}
testGetMethod（sut，生成器）；
试验方法（sut，发电机）；
}
私有静态void testGetMethod（列表列表列表、随机代理程序）{
对于（int k=0；k<100000；k++）{
获得（aGenerator.nextInt（1000））；
}
}
私有静态无效测试方法（列表列表、随机代理）{
对于（int k=0；k<100000；k++）{
迭代器迭代器=aList.listIterator（Math.abs（aGenerator.nextInt（100000）-1））；
iterator.next（）；
}
}
}

get

方法用了6.47毫秒完成10000次抓取。 迭代器样式需要18.7毫秒才能完成10000次抓取

它们相差近3倍

编辑： 对每个方法进行1000次分析。以下是一些特别有趣的结果：

get

需要2403毫秒。 迭代器需要3661毫秒

现在是1.5倍。有趣的

合理的结果-为我的机器。测试风险自负。

两者都在O（1）中找到结果（根据法律-时间不取决于列表的大小）。所以，如果你只使用一次，你不会注意到小型或大型收藏的区别

---

但是“ListIterator”解决方案会创建额外的对象，这是对内存的浪费，因为我们有

get

方法，它只从备份数组中获取请求的对象。

对其进行分析并告诉我们。分析器是唯一可以消除机器间所有变化的东西。我想你会输的。注意-它实际上是

AbstractList.listIterator（int）

而不是

ArrayList.get（int）

Hm。。我认为最好在测试之前生成索引，然后将其用于两种方法的测试。因为这是一个随机访问的数据结构，这是否重要？nextInt的操作相当长。因此，它可以对“因素”（这是唯一的建议）产生影响。在这种情况下，你可以对你的系数做一些合理的修正。@Stas Kurilin你的观点很有趣。但是，在这两次检索中，我都使用了nextInt（），因此拖动因子对这两次检索应用相同。也就是说，假设数字a的生成时间永远不会超过数字b，这更多的是出于好奇。谢谢你。

private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
    cursor = index;
}

// [...]

public E next() {
        checkForComodification();
    try {
    E next = get(cursor);
    lastRet = cursor++;
    return next;
    } catch (IndexOutOfBoundsException e) {
    checkForComodification();
    throw new NoSuchElementException();
    }
}

public E get(int index) {
RangeCheck(index);

return (E) elementData[index];
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

/**
 *
 * @author Michael Drogalis
 */
public class Launcher {

    public static void main(final String[] args) {
        List<Integer> sut = new ArrayList<Integer>();

        Random generator = new Random();
        for (int k = 0; k < 100000; k++) {
            sut.add(generator.nextInt(64));
        }

        testGetMethod(sut, generator);
        testIteratorMethod(sut, generator);
    }

    private static void testGetMethod(List<Integer> aList, Random aGenerator) {
        for (int k = 0; k < 100000; k++) {
            aList.get(aGenerator.nextInt(1000));
        }
    }

    private static void testIteratorMethod(List<Integer> aList, Random aGenerator) {
        for (int k = 0; k < 100000; k++) {
            Iterator iterator = aList.listIterator(Math.abs(aGenerator.nextInt(100000) - 1));
            iterator.next();
        }
    }
}