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循環會執行多次