❶ java中迭代列表中数据时几种循环写法的效率比较

Java中经常会用到迭代列表数据的情况，本文针对几种常用的写法进行效率比较。虽然网上已经有了类似的文章，但是对他们的结论并不认同。常见的实现方法：1.for循环：for(int i = 0; i < list.size(); i++) for(int i = 0, size = list.size(); i < size; i++) 一般人都会认为第二种写法效率高。 2.foreach：for(Object obj : list) 这是一种简洁的写法，只能对列表进行读取，无法修改。 3.while：int size = list.size(); while(size-- > 0) 4.迭代： Object iter = list.iterator(); while(iter.hasNext()) { iter.next(); }测试代码： 针对以上几种方法编写的测试代码。 public static void main(String[] args) { List list = new ArrayList(); int runTime = 1000;//执行次数 for (int i = 0; i < 1000 * 1000; i++) { list.add(i); } int size = list.size(); long currTime = System.currentTimeMillis();//开始分析前的系统时间 //基本的for for(int j = 0; j < runTime; j++) { for (int i = 0; i < size; i++) { list.get(i); } } long time1 = System.currentTimeMillis(); //foreach for(int j = 0; j < runTime; j++) { for (Integer integer : list) { } } long time2 = System.currentTimeMillis(); for(int j = 0; j < runTime; j++) { //while int i = 0 ; while(i < size){ list.get(i++); } } long time3 = System.currentTimeMillis(); for(int j = 0; j < runTime; j++) {//普通for循环 for (int i = 0; i < list.size(); i++) { list.get(i); } } long time4 = System.currentTimeMillis(); for(int j = 0; j < runTime; j++) {//迭代 Iterator iter = list.iterator(); while(iter.hasNext()) { iter.next(); } } long time5 = System.currentTimeMillis(); long time = time1 - currTime ; System.out.print("use for:" + time); time = time2 - time1; System.out.print("\tuse foreach:" + time); time = time3 - time2; System.out.print("\tuse while:" + time); time = time4 - time3; System.out.print("\tuse for2:" + time); time = time5 - time4; System.out.print("\tuse iterator:" + time); System.out.println(); }输出结果（JDK1.6）：1.use for:8695 use foreach:17091 use while:6867 use for2:7741 use iterator:14144 2.use for:8432 use foreach:18126 use while:6905 use for2:7893 use iterator:139763.use for:8584 use foreach:17177 use while:6875 use for2:7707 use iterator:14345 结论：1.针对列表的 foreach的效率是最低：耗时是普通for循环的2倍以上。个人理解它的实现应该和iterator相似。2. list.size()的开销很小：list.size()次数多少对效率基本没有影响。查看ArrayList的实现就会发现，size()方法的只是返回了对象内的长度属性，并没有其它计算，所以只存在函数调用的开销。对数组的测试：将代码中的列表list换做数组再进行测试（iterator不适用），发现耗时基本为0。说明： 3. 列表的get()方法开销不少应该主要是检测数据合法性时产生的。将执行次数增加100万倍，这时可以看出结果基本相等，并没有明显的差异。说明：4. 数组length也没有开销可见数组长度并不是每次执行的时候都要计算的。联想一下Java创建数组的时候要求必须指定数组的长度，编译处理的时候显然没有把这个值抛弃掉。网上有一篇类似的文章，它居然得出了一个foreach执行效率最高的结论。

❷ 在java中，foreach 和 iterator遍历集合时，那个效率更高一些

你好，前者效率更高

原因是for直接针对集合里的下一个对象

而iterator其实相当于专是一个指针，这样说不准确，但属是可以这样理解，每次执行它会先查找当前指向的对象，然后指针再指向下一个位置

所以说，如果有指针概念的话，for的“针对”直接是简单数据，而iterator的指针却是一个对象

❸ java中for循环和迭代器哪个效率高,紧急求答

摘抄至 cxxyjsj 的回答，我个人赞成此观点：

记录的存取方式有两种：一版种是顺序存储，另一种是链接权存储
对于顺序存储的记录可以根据其下标找到对应的记录，而链接存储(拿单链表为例)
则必须找到其前一个记录的位置才能够找到本记录。

所以for循环便于访问顺序存储的记录，比如数组等
而迭代则更适用于链接存储的记录，虽然Java中有些底层通过链接存储原理实现的集合
也可以通过下标获取指定的记录，但是其每次都必须从链表头开始查找记录，这样会影响查找的效率

❹ java 大量for循环如何优化

主要思想就是减少方法的压栈次数
最少的循环放到外面，最大的放到里面即可。
把循环次数少的放外面，多的放里面，因为越到外面,执行次数要越少，下面是具体代码，你看看
内大外小
for( int k=0;k <10;k++){
for(int j=0;j <100;j++){
for(int i=0;i <1000;i++){
function(i,j,k);
}
}
}
k <10;k++; 执行10次
j <100;j++ 执行10*100次
i <1000;i++ 执行10*100*1000次
function(i,j,k); 执行10*100*1000次
共执行语句数=(10+10*100+10*100*1000)*2+10*100*1000=3002020
内小外大
for( int k=0;k <1000;k++){
for(int j=0;j <100;j++){
for(int i=0;i <10;i++){
function(i,j,k);
}
}
}
k <1000;k++; 执行1000次
j <100;j++ 执行1000*100次
i <10;i++ 执行10*100*1000次
function(i,j,k); 执行10*100*1000次
共执行语句数=(1000+1000*100+10*100*1000)*2+10*100*1000=3202000

所以执行效率应该是内大外小更高一些
内小外大-内大外小=3202000条语句-3002020条语句=199980条语句

❺ java中for循环和迭代器哪个效率高

java中迭代器效率来高源

ArrayList实现了RandomAccess接口，RandomAccess接口为ArrayList带来了什么好处呢？

我们查看一下RandomAccess的源码文档，发现有这样一段描述：

As a rule of thumb, aListimplementation should implement this interface if, for typical instances of the class, this loop:

for (int i=0, n=list.size(); i < n; i++)
list.get(i);

runs faster than this loop:

for (Iterator i=list.iterator(); i.hasNext(); )
i.next();

从描述中，可以看出实现RandomAccess接口的集合类，使用for循环的效率会比Iterator高。

RandomAccess接口为ArrayList带来的好处：

  • 1、可以快速随机访问集合。

  • 2、使用快速随机访问（for循环）效率可以高于Iterator。

❻ java中一下两种方式遍历数组哪种效率高

第一个好像没遍历.其次,第一个如果输出的是List.get(0),那么其实这两种方法是一样的版.写法不权同而已.
第一,你的第一个for循环肯定是红线的,因为写的不对,如果写对了,他们两个其实是一个方法.上面也说了,写法不同而已

❼ JDK1.8的foreach循环效率不如for循环，它为什么还要出现

1.如果只是遍历集合或抄者数袭组，用foreach好些，快些。2.如果对集合中的值进行修改，就要用for循环了。其实foreach的内部原理其实也是Iterator,但它不能像Iterator一样可以人为的控制，而且也不能调用iterator.remove()；更不能使用下标来访问每个元素，所以不能用于增加，删除等复杂的操作。举个例子：for(Stringaid:list){if(aid.equals("aa")){list.remove(aid);//这行会报错，不能修改list的长度}}所以foreach语句是for语句的特殊简化版本，但是foreach语句并不能完全取代for语句。

❽ java 后执行的for循环比先执行的for循环速度快

程序是从main方法入口，然后从上到下去执行的。
执行过程如下：
先执行 第一专个for循环属，再到第一个for循环的外层第一个，到第一个for循环的内层0-99次。
当第一个for循环的执行完成之后。再执行第二个for循环。
------------------------------------------------------------------------
这里强调一点：程序是从上到下执行的，第一个for循环如果没有执行完成，第二个for循环就不能执行，这有点像上厕所一样，里面的人不完事，外面的就只能一直等。

不理解的可以追问

❾ java循环替换字符串循环次数太多效率差怎么办

这样就OK了，你试一下
class Test
{
public static void main(String[] args)
{
int max=1;
String[] strs={"a","b","f","a","d","c","e","d","a","d"};
for(int i=0;i<strs.length-1;i++)
{
int count=1;
for(int j=i+1;j<strs.length;j++)
{
if(strs[i].equals(strs[j]))
count++;
}
if(max<count)
max=count;
}
System.out.println("重复最多次数为："+max);
for(int i=0;i<strs.length-1;i++)
{
int count=1;
for(int j=i+1;j<strs.length;j++)
{
if(strs[i].equals(strs[j]))
count++;
}
if(count==max)
System.out.println("重复最多次("+max+")的字回符答串为："+strs[i]);
}
}
}

❿ [Java] For loop与if 两种写法的效率

第二个。

最多执行2次判断 10次循环；
第一个10次循环 10-20次if判断；