javafor循环的效率

㈠ java 比较几种常见循环方式的优劣

集合一共有三种遍历方法，以list循环举例：

importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.List;

publicclassMain{
publicstaticvoidmain(String[]args){
List<Integer>list=newArrayList<>();
for(inti=0;i<10;i++){
list.add(i);
}

//for循环遍历
for(inti=0,size=list.size();i<size;i++){
System.out.println(list.get(i));
}

//iterator迭代器遍历
Iterator<Integer>it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}

//foreach循环
for(Integeri:list){
System.out.println(i);
}
}
}

数据元素是怎样在内存中存放的？

主要有2种存储方式：

1、顺序存储，Random Access（Direct Access）：

这种方式，相邻的数据元素存放于相邻的内存地址中，整块内存地址是连续的。可以根据元素的位置直接计算出内存地址，直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说，只有基于数组实现的集合，才有这种特性。Java中以ArrayList为代表。

2、链式存储，Sequential Access：

这种方式，每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址，只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。

每个遍历方法的实现原理是什么？

1、传统的for循环遍历，基于计数器的：

遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后，停止。主要就是需要按元素的位置来读取元素。

2、迭代器遍历，Iterator：

每一个具体实现的数据集合，一般都需要提供相应的Iterator。相比于传统for循环，Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator，正常的实现，都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。

3、foreach循环遍历：

根据反编译的字节码可以发现，foreach内部也是采用了Iterator的方式实现，只不过Java编译器帮我们生成了这些代码。

各遍历方式的适用于什么场合？

1、传统的for循环遍历，基于计数器的：

顺序存储：读取性能比较高。适用于遍历顺序存储集合。

链式存储：时间复杂度太大，不适用于遍历链式存储的集合。

2、迭代器遍历，Iterator：

顺序存储：如果不是太在意时间，推荐选择此方式，毕竟代码更加简洁，也防止了Off-By-One的问题。

链式存储：意义就重大了，平均时间复杂度降为O(n)，还是挺诱人的，所以推荐此种遍历方式。

3、foreach循环遍历：

foreach只是让代码更加简洁了，但是他有一些缺点，就是遍历过程中不能操作数据集合（删除等），所以有些场合不使用。而且它本身就是基于Iterator实现的，但是由于类型转换的问题，所以会比直接使用Iterator慢一点，但是还好，时间复杂度都是一样的。所以怎么选择，参考上面两种方式，做一个折中的选择。

㈡ 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中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 大量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中for循环：
for(表达式1; 表达式2; 表达式3){
循环体;
}
其中表达式2必须是一个布尔表达式，也就是说它必须返回true或者false。

for循环执行多少次是根据表达式2的结果来决定的，每次循环时会先检查一次表达式2的结果，如果是true将会再次循环，如果是false则停止循环。
理论上来说，只要表达式2不为true，那么for循环是可以一直循环下去的，也就是无限循环。

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

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

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

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

㈦ java中for循环如何提高程序性能

在for循环里面如果有if语句判断，当业务中有一条符合要求并且取到合适的值的时候，这时候可以在if判断完后加一个break，这样for循环语句不会一直循环下去，节约了程序的性能

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

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

不理解的可以追问

㈨ mybatis子查询比java for循环查询效率高吗

是的，mybatis的子查询执行一次sql。而for循环会执行多次