http://todayhumor.com/?programmer_22747
    
지난 링크에서 for 문 사용할 때 List의 size 호출 관련 효율성이 어쩌구 언급 한 적이 있음.
그래서 어떤 것이 가장 좋을 까? 하고 무식하게 테스트 해 봤음.

약간 흥미롭게 결과가 나왔는데 JDK 버전마다 조금씩 결과가 다름.
그리고 동일한 JDK 버전으로 PC와 https://wandbox.org 에서 컴파일 했을 때 결론도 각기 다르게 나왔음.

일단은 테스트 코드

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


public class TestRepeat {
    
    private final static List<String> getList(){
        final List<String> result = new ArrayList<String>();
        
        for( int i=0 ; i<60000 ; i++ ){
            result.add( String.format("%08d", i) );
        }
        
        return result;
    }
    
    private final static String resultMessage(List<Long> lst){
        long max=Collections.max(lst), min=Collections.min(lst), aver, sum=0;
        
        int cnt = 0;
        for( long l : lst ){
            sum += l;
            if( l == 0 )
                cnt ++;
        }
        
        aver = sum / lst.size();
        
        return String.format("Max=%7d\t\tMin=%7d\t\tAver=%7d\t\tZero Count=%7d", max, min, aver, cnt);
    }

    public static void main(String[] args) {
        
        final int MaxCount = 5000;
        
        final List<Long> sizeList = new ArrayList<Long>();
        {
            
            final List<String> lst = getList();
            
            for( int i=0 ; i<MaxCount ; i++ ){
                
                final long start = System.nanoTime();
                for( int j=0 ; j<lst.size() ; j++ ){
                    lst.get(j);
                }
                
                sizeList.add( System.nanoTime() - start );
            }
        }
        
        final List<Long> constList = new ArrayList<Long>();
        {
            final List<String> lst = getList();
            
            for( int i=0 ; i<MaxCount ; i++ ){
                
                final int size = lst.size();
                final long start = System.nanoTime();
                for( int j=0 ; j<size ; j++ ){
                    lst.get(j);
                }
                
                constList.add( System.nanoTime() - start );
            }
        }
        
        final List<Long> forList = new ArrayList<Long>();
        {
            final List<String> lst = getList();
            
            for( int i=0 ; i<MaxCount ; i++ ){
                
                final long start = System.nanoTime();
                for( String s : lst ){
                    ;
                }
                
                forList.add( System.nanoTime() - start );
            }
        }

        final List<Long> iterList = new ArrayList<Long>();
        {
            final List<String> lst = getList();
            
            for( int i=0 ; i<MaxCount ; i++ ){
                
                final long start = System.nanoTime();
                for( Iterator<String> s = lst.iterator(); s.hasNext(); ){
                    s.next();
                }
                
                iterList.add( System.nanoTime() - start );
            }
        }
        
        System.out.println("size 매번 호출\t" + resultMessage(sizeList) );
        System.out.println("size 한번 호출\t" + resultMessage(constList) );
        System.out.println("foreach        \t" + resultMessage(forList) );
        System.out.println("Iterator 패턴\t" + resultMessage(iterList) );

    }

}


◈ JDK 1.7 PC Windows7
size 매번 호출    Max=3459601        Min=      0        Aver=   1441         Zero Count=   4693
size 한번 호출    Max=1818125        Min=      0        Aver=    976          Zero Count=   4786
foreach            Max=8044722        Min= 192511   Aver= 204727        Zero Count=      0
Iterator 패턴     Max=4768303        Min=  81171    Aver=  84916        Zero Count=      0


◈ JDK 1.8 PC Windows7
size 매번 호출    Max=3579648        Min=      0        Aver=  22607        Zero Count=   4390
size 한번 호출    Max=1686260        Min=      0        Aver=   1776         Zero Count=   4693
foreach            Max=3399266        Min= 121913    Aver= 142415       Zero Count=      0
Iterator 패턴     Max=2076569        Min=   4976      Aver=   9294        Zero Count=      0


◈ JDK 1.7 wandbox.org
size 매번 호출    Max=9959131        Min=   1145        Aver=   5156        Zero Count=      0
size 한번 호출    Max= 714845         Min= 271180      Aver= 296579        Zero Count=      0
foreach            Max=18782974       Min= 276058      Aver= 344822        Zero Count=      0
Iterator 패턴     Max=10282601      Min= 466734       Aver= 535358        Zero Count=      0


◈ JDK 1.8 wandbox.org
size 매번 호출    Max=8511093        Min=   1340        Aver=  48145        Zero Count=      0
size 한번 호출    Max=3233879        Min=      0           Aver=  34890        Zero Count=    360
foreach            Max=15693267      Min= 277988        Aver= 339264      Zero Count=      0
Iterator 패턴     Max=3507748        Min= 497543        Aver= 640804      Zero Count=      0


◈ JDK 1.9+181 wandbox.org
size 매번 호출    Max=7186845        Min=  73194        Aver= 201134        Zero Count=      0
size 한번 호출    Max=6043744        Min=  73189        Aver= 164352        Zero Count=      0
foreach            Max=7884471        Min= 333090        Aver= 412907        Zero Count=      0
Iterator 패턴     Max=1248011        Min= 519698        Aver= 566357        Zero Count=      0


◈ JDK 1.10+23 wandbox.org
size 매번 호출    Max=6827381        Min=  52742        Aver= 205384        Zero Count=      0
size 한번 호출    Max=3576097        Min=  73169        Aver= 130013        Zero Count=      0
foreach            Max=7937696        Min= 349524        Aver= 419772        Zero Count=      0
Iterator 패턴     Max=1812288        Min= 632961        Aver= 739575        Zero Count=      0


컴파일 버전마다 조금씩은 차이가 있지만 size 함수를 한번만 호출 하는 것이 대체적으로 좋은 결과를 보여줌.
foreach 방식은 속도가 안습임. 왜그러지? ㅡ,ㅡ;;; 내가 좋아하는 for문이였는데 쩝...