java forEach实现原理

java.util.List实现了java.lang.Iterable接口.

jdk api文档中是这样描述Iterable接口的：实现这个接口允许对象成为 "foreach" 语句的目标。不过咋一看Iterable接口并没啥特别之处，只是定义了一个迭代器而已。
[java] view plaincopy

    public interface Iterable<T> {  
      
        /** 
         * Returns an iterator over a set of elements of type T. 
         *  
         * @return an Iterator. 
         */  
        Iterator<T> iterator();  
    }  


究竟是如何实现foreach的呢，想想可能是编译器做了优化，就看了下最终编译成的字节码
[java] view plaincopy

    public class Iterable_eros {  
          
        List<String> strings;  
      
        public void display(){  
            for(String s : strings){  
                System.out.println(s);  
            }  
        }  
          
    }  

相应的字节码为
[java] view plaincopy

    public void display (){  
    line0    : aload_0    
               getfield  java.util.List my.lang.Iterable_eros.strings  
               invokeinterface  java.util.Iterator java.util.List.iterator() 1  
               astore_2    
               goto  line30  
    line13   : aload_2    
               invokeinterface  java.lang.Object java.util.Iterator.next() 1  
               checkcast  java.lang.String  
               astore_1    
    line23   : getstatic  java.io.PrintStream java.lang.System.out  
               aload_1    
    line27   : invokevirtual  void java.io.PrintStream.println(java.lang.String)  
    line30   : aload_2    
               invokeinterface  boolean java.util.Iterator.hasNext() 1  
               ifne  line13  
    line39   : return    

果然没猜错哈！可以看到，foreach语法最终被编译器转为了对Iterator.next()的调用。而作为使用者的我们， jdk并没用向我们暴露这些细节，我们甚至不需要知道Iterator的存在，认识到jdk的强大之处了吧。

为了证实自己的想法，用Iterator写了个遍历List的方法查看了字节码，果然跟foreach的形式基本一样，当然这是后话~
[java] view plaincopy

    public void display(){  
            for(String s : strings){  
                System.out.println(s);  
            }  
              
            Iterator<String> iterator = strings.iterator();  
            while(iterator.hasNext()){  
                String s = iterator.next();  
                System.out.println(s);  
            }  
        }  

[java] view plaincopy

    public void display (){  
    line0    : aload_0    
               getfield  java.util.List my.lang.Iterable_eros.strings  
               invokeinterface  java.util.Iterator java.util.List.iterator() 1  
               astore_2    
               goto  line30  
    line13   : aload_2    
               invokeinterface  java.lang.Object java.util.Iterator.next() 1  
               checkcast  java.lang.String  
               astore_1    
    line23   : getstatic  java.io.PrintStream java.lang.System.out  
               aload_1    
    line27   : invokevirtual  void java.io.PrintStream.println(java.lang.String)  
    line30   : aload_2    
               invokeinterface  boolean java.util.Iterator.hasNext() 1  
               ifne  line13  
               aload_0    
               getfield  java.util.List my.lang.Iterable_eros.strings  
               invokeinterface  java.util.Iterator java.util.List.iterator() 1  
               astore_1    
    line49   : goto  line69  
    line52   : aload_1    
               invokeinterface  java.lang.Object java.util.Iterator.next() 1  
               checkcast  java.lang.String  
               astore_2    
    line62   : getstatic  java.io.PrintStream java.lang.System.out  
               aload_2    
    line66   : invokevirtual  void java.io.PrintStream.println(java.lang.String)  
    line69   : aload_1    
               invokeinterface  boolean java.util.Iterator.hasNext() 1  
               ifne  line52  
    line78   : return    

 

   为什么遍历arraylist的时候 for循环会比迭代器快呢
因为 arraylist 底层是由数组组成的，在java中为了通用迭代器，所以性能上有一定的损失
对于底层由数组组成的arraylist 这种对象，如果使用for循环，直接由索引获取对象，速度是很快的，使用迭代器要向下一个一个的遍历，速度是稍微一点点的慢过for

但是迭代器发光的地方并不在底层由数组构成的集合上，迭代器用在 底层由双向指针链表构成的linkedlist 上，效率大大高于for循环。
如 果使用for循环遍历 底层由双向指针链表构成的linkedlist的话，他会每次都从头遍历一次，知道获取你给定的下标，然后开始下一次遍历，。越往后速度越慢。下标越大， 速度越慢。但是对于迭代器，他不是根据下标完成的遍历，每取得一个对象后，他会根据这个对象的尾部指针取得下一个对象的内存位置，直接从内存位置取出内 容，这一点是for循环所不及的。