java vector 遍历 效率_58-转载：Java遍历List四种方法的效率对比

感觉这篇文章总结的很好，从底层原理讲的。懒得总结了，直接搬来了。建议直接看原文！！！

总结

(1)对于ArrayList和LinkedList，在size小于1000时，每种方式的差距都在几ms之间，差别不大，选择哪个方式都可以。

(2)对于ArrayList，无论size是多大，差距都不大，选择哪个方式都可以。

(3)对于LinkedList，当size较大时，建议使用迭代器或for-each的方式进行遍历，否则效率会有较明显的差距。

所以，综合来看，建议使用for-each，代码简洁，性能也不差。

另外，当效率不是重点时，应该在设计上花更多心思了。实际上，把大量对象放到List里面去，本身就应该是要考虑的问题。

Java遍历List四种方法的效率对比

遍历方法简介

Java遍历List的方法主要有：

(1)for each

for(bject o :list)

{

}

(2)Iterator

Iterator iter = list.iterator();

while(iter.hasNext()){

Object o = iter.next();

}

(3)loop without size

int size = list.size();

for(int i=0;i

Object o= list.get(i);

}

(4)loop with size

for(int i=0;i

Object o= list.get(i);

}

注：这里我们不比较while和for的形式，这对效率影响几乎是可以忽略的。

我们是否能简单的得出结论，哪个更快，哪个更慢呢？

严谨一点的方法是：基于实验与数据，才能作出判断。

ArrayList测试分析

经过编写测试代码，结果如下：(时间单位：纳秒)

可以看出，直接用循环的方法，get(index)来获取对象，是最快的方式。而且把i

For Each的效率最差，用迭代器的效率也没有很好。但只是相对而言，其实从时间上看最多也就差几毫秒。

然而，这并不是事实的全部真相！！！

上面的测试，我们只是用了ArrayList来做为List的实现类。所以才有上面的结论。

For each其实也是用了迭代器来实现，因此当数据量变大时，两者的效率基本一致。也因为用了迭代器，所以速度上受了影响。不如直接get(index)快。

那为何get(index)会比较快呢？

因为ArrayList是通过动态数组来实现的，支持随机访问，所以get(index)是很快的。迭代器，其实也是通过数组名+下标来获取，而且增加了逻辑，自然会比get(index)慢。

看ArrayList的迭代器的源代码就清楚了：

public boolean hasNext()

{

return cursor != size;

}

public Object next()

{

checkForComodification();

int i = cursor;

if(i >= size)

throw new NoSuchElementException();

Object aobj[] = elementData;

if(i >= aobj.length)

{

throw new ConcurrentModificationException();

} else

{

cursor = i + 1;

return aobj[lastRet = i];

}

}

LinkedList测试分析

结果确实不简单，跟ArrayList完全不一样了。

最突出的就是get(index)的方式，随着size的增加，急剧上升。到10万数据量时，光遍历时间都要三四秒，这是很可怕的。

那为何会有这样的结果呢？还是和LinkedList的实现方式有关。

LinkedList是通过双向链表实现的，无法支持随机访问。当你要向一个链表取第index个元素时，它需要二分后从某一端开始找，一个一个地数才能找到该元素。这样一想，就能明白为何get(index)如此费时了。

public Object get(int i)

{

checkElementIndex(i);

return node(i).item;

}

Node node(int i)

{

if(i < size >> 1)

{

Node node1 = first;

for(int j = 0; j < i; j++)

node1 = node1.next;

return node1;

}

Node node2 = last;

for(int k = size - 1; k > i; k--)

node2 = node2.prev;

return node2;

}

而迭代器提供的是获取下一个的方法，时间复杂度为O(1)，所以会比较快。

public boolean hasNext()

{

return nextIndex < size;

}

public Object next()

{

checkForComodification();

if(!hasNext())

{

throw new NoSuchElementException();

} else

{

lastReturned = next;

next = next.next;

nextIndex++;

return lastReturned.item;

}

}

看这迭代器的源代码还是很理解的。

总结

(1)对于ArrayList和LinkedList，在size小于1000时，每种方式的差距都在几ms之间，差别不大，选择哪个方式都可以。

(2)对于ArrayList，无论size是多大，差距都不大，选择哪个方式都可以。

(3)对于LinkedList，当size较大时，建议使用迭代器或for-each的方式进行遍历，否则效率会有较明显的差距。

所以，综合来看，建议使用for-each，代码简洁，性能也不差。

另外，当效率不是重点时，应该在设计上花更多心思了。实际上，把大量对象放到List里面去，本身就应该是要考虑的问题。

至于Vector或Map，就留给感兴趣的人去验证了。

系统信息

最后，附上系统信息：

-- listing properties --

java.vm.version=25.65-b01

java.vm.name=Java HotSpot(TM) 64-BitServer VM

java.runtime.version=1.8.0_65-b17

os.arch=amd64

os.name=Windows 10

java version"1.8.0_66"

Java(TM) SERuntime Environment (build 1.8.0_66-b18)

JavaHotSpot(TM) Client VM (build 25.66-b18, mixed mode)