java增强for循环的原理验证

最新推荐文章于 2024-09-13 20:14:54 发布
最新推荐文章于 2024-09-13 20:14:54 发布
阅读量468 收藏
点赞数 2
分类专栏： 学习笔记 文章标签： java 增强for循环 增强for循环原理 编译期优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hcd321/article/details/84882076
版权

     在java里，我们是怎么写for循环的代码呢。一般都是用这两种写法：

第一种：最传统的for循环写法，for(代码段a;代码段b;代码段c)，其中代码段a是初次进入for循环时执行的代码，代码段b是一个boolean的表达式，true则继续执行for循环内容，false则停止for循环，代码段c则是在for循环内部执行完后执行。

第二种：针对集合的遍历，for(类型 单个对象:集合对象)。第二种即是增强for循环。

     本文的目的就是讲解增强for循环的原理。先看我的测试用例：

jdk版本:1.7.0_51

 java 用例代码：

package com.onlyou.olyfinance.supply.web;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * 增强for循环编译测试
 * Created by cd_huang on 2017/4/14.
 */
public class ForeachTest {

	public static void superForeachTestArray(){
		String[] args =new String[]{"1","2"};
		for(String s:args) {
			System.out.println(s);
		}
	}

	public static void foreachTestArray(){
		String[] args =new String[]{"1","2"};
		String[] args2 = args;
		int len = args.length;
		for(int i = 0; i < len; ++i) {
			String s= args2[i];
			System.out.println(s);
		}
	}

	public static void superForeachTestIterator(){
		List<String> list = Arrays.asList(new String[]{"1","2"});
		for(String s:list) {
			System.out.println(s);
		}
	}

	public static void foreachTestIterator(){
		List<String> list = Arrays.asList(new String[]{"1","2"});
		Iterator it = list.iterator();
		while(it.hasNext()) {
			String s = (String)it.next();
			System.out.println(s);
		}
	}
}

 命令行输入：C:\Users\hcd>javac c:\ForeachTest.java

生成StringTest.class文件。

命令行输入：C:\Users\hcd>javap -v c:\ForeachTest.class

生成java编译后的字节码指令。

Classfile /c:/ForeachTest.class
  Last modified 2017-4-14; size 1307 bytes
  MD5 checksum 5296942b41a468b4fa1f88e3123db02f
  Compiled from "ForeachTest.java"
public class com.onlyou.olyfinance.supply.web.ForeachTest
  SourceFile: "ForeachTest.java"
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER

Constant pool:
   #1 = Methodref          #13.#28        //  java/lang/Object."<init>":()V
   #2 = Class              #29            //  java/lang/String
   #3 = String             #30            //  1
   #4 = String             #31            //  2
   #5 = Fieldref           #32.#33        //  java/lang/System.out:Ljava/io/PrintStream;
   #6 = Methodref          #34.#35        //  java/io/PrintStream.println:(Ljava/lang/String;)V
   #7 = Methodref          #36.#37        //  java/util/Arrays.asList:([Ljava/lang/Object;)Ljava/util/List;
   #8 = InterfaceMethodref #38.#39        //  java/util/List.iterator:()Ljava/util/Iterator;
   #9 = InterfaceMethodref #40.#41        //  java/util/Iterator.hasNext:()Z
  #10 = InterfaceMethodref #40.#42        //  java/util/Iterator.next:()Ljava/lang/Object;
  #11 = InterfaceMethodref #38.#39        //  java/util/List.iterator:()Ljava/util/Iterator;
  #12 = Class              #43            //  com/onlyou/olyfinance/supply/web/ForeachTest
  #13 = Class              #44            //  java/lang/Object
  #14 = Utf8               <init>
  #15 = Utf8               ()V
  #16 = Utf8               Code
  #17 = Utf8               LineNumberTable
  #18 = Utf8               superForeachTestArray
  #19 = Utf8               StackMapTable
  #20 = Class              #45            //  "[Ljava/lang/String;"
  #21 = Utf8               foreachTestArray
  #22 = Utf8               superForeachTestIterator
  #23 = Class              #46            //  java/util/List
  #24 = Class              #47            //  java/util/Iterator
  #25 = Utf8               foreachTestIterator
  #26 = Utf8               SourceFile
  #27 = Utf8               ForeachTest.java
  #28 = NameAndType        #14:#15        //  "<init>":()V
  #29 = Utf8               java/lang/String
  #30 = Utf8               1
  #31 = Utf8               2
  #32 = Class              #48            //  java/lang/System
  #33 = NameAndType        #49:#50        //  out:Ljava/io/PrintStream;
  #34 = Class              #51            //  java/io/PrintStream
  #35 = NameAndType        #52:#53        //  println:(Ljava/lang/String;)V
  #36 = Class              #54            //  java/util/Arrays
  #37 = NameAndType        #55:#56        //  asList:([Ljava/lang/Object;)Ljava/util/List;
  #38 = Class              #46            //  java/util/List
  #39 = NameAndType        #57:#58        //  iterator:()Ljava/util/Iterator;
  #40 = Class              #47            //  java/util/Iterator
  #41 = NameAndType        #59:#60        //  hasNext:()Z
  #42 = NameAndType        #61:#62        //  next:()Ljava/lang/Object;
  #43 = Utf8               com/onlyou/olyfinance/supply/web/ForeachTest
  #44 = Utf8               java/lang/Object
  #45 = Utf8               [Ljava/lang/String;
  #46 = Utf8               java/util/List
  #47 = Utf8               java/util/Iterator
  #48 = Utf8               java/lang/System
  #49 = Utf8               out
  #50 = Utf8               Ljava/io/PrintStream;
  #51 = Utf8               java/io/PrintStream
  #52 = Utf8               println
  #53 = Utf8               (Ljava/lang/String;)V
  #54 = Utf8               java/util/Arrays
  #55 = Utf8               asList
  #56 = Utf8               ([Ljava/lang/Object;)Ljava/util/List;
  #57 = Utf8               iterator
  #58 = Utf8               ()Ljava/util/Iterator;
  #59 = Utf8               hasNext
  #60 = Utf8               ()Z
  #61 = Utf8               next
  #62 = Utf8               ()Ljava/lang/Object;
{
  public com.onlyou.olyfinance.supply.web.ForeachTest();
    flags: ACC_PUBLIC

    Code:
      stack=1, locals=1, args_size=1
         0: aload_0       
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return        
      LineNumberTable:
        line 11: 0

  public static void superForeachTestArray();
    flags: ACC_PUBLIC, ACC_STATIC

    Code:
      stack=4, locals=5, args_size=0
         0: iconst_2      
         1: anewarray     #2                  // class java/lang/String
         4: dup           
         5: iconst_0      
         6: ldc           #3                  // String 1
         8: aastore       
         9: dup           
        10: iconst_1      
        11: ldc           #4                  // String 2
        13: aastore       
        14: astore_0      
        15: aload_0       
        16: astore_1      
        17: aload_1       
        18: arraylength   
        19: istore_2      
        20: iconst_0      
        21: istore_3      
        22: iload_3       
        23: iload_2       
        24: if_icmpge     46
        27: aload_1       
        28: iload_3       
        29: aaload        
        30: astore        4
        32: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
        35: aload         4
        37: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        40: iinc          3, 1
        43: goto          22
        46: return        
      LineNumberTable:
        line 14: 0
        line 15: 15
        line 16: 32
        line 15: 40
        line 18: 46
      StackMapTable: number_of_entries = 2
           frame_type = 255 /* full_frame */
          offset_delta = 22
          locals = [ class "[Ljava/lang/String;", class "[Ljava/lang/String;", int, int ]
          stack = []
           frame_type = 248 /* chop */
          offset_delta = 23


  public static void foreachTestArray();
    flags: ACC_PUBLIC, ACC_STATIC

    Code:
      stack=4, locals=5, args_size=0
         0: iconst_2      
         1: anewarray     #2                  // class java/lang/String
         4: dup           
         5: iconst_0      
         6: ldc           #3                  // String 1
         8: aastore       
         9: dup           
        10: iconst_1      
        11: ldc           #4                  // String 2
        13: aastore       
        14: astore_0      
        15: aload_0       
        16: astore_1      
        17: aload_0       
        18: arraylength   
        19: istore_2      
        20: iconst_0      
        21: istore_3      
        22: iload_3       
        23: iload_2       
        24: if_icmpge     46
        27: aload_1       
        28: iload_3       
        29: aaload        
        30: astore        4
        32: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
        35: aload         4
        37: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        40: iinc          3, 1
        43: goto          22
        46: return        
      LineNumberTable:
        line 21: 0
        line 22: 15
        line 23: 17
        line 24: 20
        line 25: 27
        line 26: 32
        line 24: 40
        line 28: 46
      StackMapTable: number_of_entries = 2
           frame_type = 255 /* full_frame */
          offset_delta = 22
          locals = [ class "[Ljava/lang/String;", class "[Ljava/lang/String;", int, int ]
          stack = []
           frame_type = 250 /* chop */
          offset_delta = 23


  public static void superForeachTestIterator();
    flags: ACC_PUBLIC, ACC_STATIC

    Code:
      stack=4, locals=3, args_size=0
         0: iconst_2      
         1: anewarray     #2                  // class java/lang/String
         4: dup           
         5: iconst_0      
         6: ldc           #3                  // String 1
         8: aastore       
         9: dup           
        10: iconst_1      
        11: ldc           #4                  // String 2
        13: aastore       
        14: invokestatic  #7                  // Method java/util/Arrays.asList:([Ljava/lang/Object;)Ljava/util/List;
        17: astore_0      
        18: aload_0       
        19: invokeinterface #8,  1            // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
        24: astore_1      
        25: aload_1       
        26: invokeinterface #9,  1            // InterfaceMethod java/util/Iterator.hasNext:()Z
        31: ifeq          54
        34: aload_1       
        35: invokeinterface #10,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
        40: checkcast     #2                  // class java/lang/String
        43: astore_2      
        44: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
        47: aload_2       
        48: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        51: goto          25
        54: return        
      LineNumberTable:
        line 31: 0
        line 32: 18
        line 33: 44
        line 34: 51
        line 35: 54
      StackMapTable: number_of_entries = 2
           frame_type = 253 /* append */
             offset_delta = 25
        locals = [ class java/util/List, class java/util/Iterator ]
           frame_type = 250 /* chop */
          offset_delta = 28


  public static void foreachTestIterator();
    flags: ACC_PUBLIC, ACC_STATIC

    Code:
      stack=4, locals=3, args_size=0
         0: iconst_2      
         1: anewarray     #2                  // class java/lang/String
         4: dup           
         5: iconst_0      
         6: ldc           #3                  // String 1
         8: aastore       
         9: dup           
        10: iconst_1      
        11: ldc           #4                  // String 2
        13: aastore       
        14: invokestatic  #7                  // Method java/util/Arrays.asList:([Ljava/lang/Object;)Ljava/util/List;
        17: astore_0      
        18: aload_0       
        19: invokeinterface #11,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
        24: astore_1      
        25: aload_1       
        26: invokeinterface #9,  1            // InterfaceMethod java/util/Iterator.hasNext:()Z
        31: ifeq          54
        34: aload_1       
        35: invokeinterface #10,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
        40: checkcast     #2                  // class java/lang/String
        43: astore_2      
        44: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
        47: aload_2       
        48: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        51: goto          25
        54: return        
      LineNumberTable:
        line 38: 0
        line 39: 18
        line 40: 25
        line 41: 34
        line 42: 44
        line 43: 51
        line 44: 54
      StackMapTable: number_of_entries = 2
           frame_type = 253 /* append */
             offset_delta = 25
        locals = [ class java/util/List, class java/util/Iterator ]
           frame_type = 28 /* same */

}

   上面的是java代码编译过后的二进制指令。如果对这些指令是什么意思有兴趣的可以看这篇博客：http://www.blogjava.net/DLevin/archive/2011/09/13/358497.html。不过单单看这个肯定是不够的。需要对java的运行时内存模型有一定的了解，明白栈帧，操作数栈，局部变量表，常量池这些东西的概念，才能理解在执行这些指令时，对应的东西里会产生什么变化。当然，要理解我说的增强for循环原理，并不需要看懂这些指令。认真观察上面的二进制指令，superForeachTestArray()方法编译后的指令，即第86行到121行，和foreachTestArray() 方法编译后的指令，即第137行到172行，两个方法编译后的指令是一样的。

superForeachTestIterator()方法编译后的指令，即第191行到222行，和foreachTestIterator() 方法编译后的指令，即第237行到268行，两个方法编译后的指令是一样的。

    这说明什么问题？说明了增强for循环是一个编译前的概念，在编译后编译器会对代码进行优化。有两种对象支持增强for循环：一种是数组，编译器对数组的优化只是写法上的优化，即superForeachTestArray()方法内的增强for循环在编译后会变成foreachTestArray() 方法里for循环的代码。一种是实现了Iterable接口的对象，对于这种，其实质是拿到对象的迭代器进行遍历，即superForeachTestIterator()方法内的增强for循环在编译后会变成foreachTestIterator() 方法内的迭代器遍历。迭代器遍历的好处是安全，且它是对遍历的一种抽象，有种解耦的意味在里面。

hcd321
关注
专栏目录
Java编程基础教程：Java虚拟机原理
AI天才研究院
10-30 206
Java是一种广泛使用的编程语言，特别适合开发Web应用和企业级应用程序。它的主要优势在于跨平台性，Java源代码在编译后会生成一个称为“字节码”的目标代码，可以在任何支持Java虚拟机的操作系统中运行。因此，编写一次，到处运行。然而，这种跨平台性也带来了一些问题。例如，由于各种不同版本的JVM实现方式可能不同，因此在实际运行时可能会遇到一些兼容性问题。此外，虽然Java在功能上可以满足大多数需求，但在某些方面仍然有一些局限性，例如内存管理、性能等。这些问题促使了Java虚拟机的出现。
Java中增强for循环的实现原理和坑详解
08-27
增强的for循环是在传统的for循环中增加的强大的迭代功能的循环，是在jdk1.5之后提出来的。下面这篇文章主要给大家介绍了关于Java中增强for循环的实现原理和坑的相关资料，需要的朋友可以参考下
增强for循环原理详解
qq_52360788的博客
08-01 879
所以我们与其说是副本，不如说又新建了一个变量，去引用迭代器遍历到的值，如果元素是基本数据类型则保存的仅仅是值，如果是引用数据类型，就是保存的是地址，我们可以使用这个地址对对应的对象进行操作的，比如修改这个对象的属性等。但是上面例子中，元素是字符串"",是不可变的，因此增强for循环的局部变量引用是指向了字符串常量池，对这个字符串的更新，会在字符串常量池新创造一个字符串的对象，并不会影响遍历到的元素的内容。
增强for循环 (for each循环)详解
最新发布
2301_79175212的博客
09-13 1980
增强for循环 (也称for each循环) 是迭代器遍历方法的一个“简化版”，是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合。其内部原理是一个Iteration迭代器，在遍历数组/集合的过程中，不能对集合中的元素进行增删操作。​ 增强 for 循环是一种简洁的语法糖，用于遍历数组和集合时特别方便。但需要注意，它不适合修改集合元素或在遍历过程中删除元素。如需更复杂的操作（例如需要索引、删除元素等），可以选择传统的 for 循环或者使用迭代器。
增强for循环的内部原理
m0_52213453的博客
07-20 450
增强for循环内部原理就是一个Iterator迭代器 import java.util.*;//导包 public class forDemo { public static void main(String[] args) { List<String> list = new ArrayList<String>();//建一个List,其中数据类型是String //调用add方法给List里面添加元素 li...
java中增强for循环的原理
scalad
01-23 1871
java中增强for循环的原理 增强for循环的语句如下: for(ElementType element:arrayName){}; 遍历数组 int[] arr = {1,2,3}; for(int i = 0; i   System.out.println(arr[i]);//1,2,3 } for(int e : arr) {   System.out.prin
java增强for循环原理
当我谈编程时我谈些什么
10-14 1182
通过反编译源码，我们看到，其实JAVA中的增强for循环底层是通过迭代器模式来实现的。 增强for循环实现原理 编译前 for (Integer i : list) { System.out.print(i + ","); } 编译后 Integer i; for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(i)){ i = (Integer)iterator.next(...
Java开发之增强for循环要注意陷阱
shayukaifa的博客
01-11 346
什么是增强for循环 增强for循环是一种简单模式的for循环，为了方便数组和集合的遍历而存在。 int[] arr = new int[]{1, 2, 3, 4, 5, 6}; for (int a : arr) { System.out.println(a); } ArrayList<Integer> list = new ArrayList(); list.add(1); list.a
JAVA 增强for循环
qq_43141232的博客
07-07 132
概述
java_for_QA:Java Course@software-testing.ru的回购
03-10
1. **基础语法**: 学习Java首先要掌握基础语法，包括数据类型（如整型、浮点型、字符型和布尔型）、变量、运算符、控制流程（if语句、switch、for循环、while循环）、数组等。 2. **类与对象**: Java是面向对象的...
循环神经网络RNN原理与代码实例讲解
AI天才研究院
06-28 888
循环神经网络RNN原理与代码实例讲解 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming / TextGenWebUILLM 循环神经网络RNN原理与代码实例讲解
Java中的增强for循环的实现原理与坑
qiang_zi_的专栏
07-17 1337
转载： https://mp.weixin.qq.com/s/GWelJIRYBEW3VT8JdQa4IA 在JAVA中，遍历集合和数组一般有以下三种形式： 第一种是普通的for循环遍历、第二种是使用迭代器进行遍历，第三种我们一般称之为增强for循环（for each）。 实现原理 可以看到，第三种形式是JAVA提供的语法糖，这里我们剖析一下，这种增强for循环底层是如何实现的。 ...
增强for循环
技术积累，技术分享
10-12 7377
什么是增强for循环？ 增强for循环（也称for each循环）是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。他的内部原理其实是一个Iterator迭代器，所以再遍历的过程中，不能对集合中的的元素进行正山操作 格式如下： for (元素的数据类型 变量: Collection集合or数组) { // 写操作代码 } 注意： 增强for循环必须有被遍历的目标，目标只能是Collection或者是数组，而且增强for循环只能用作遍历 举例说明： 1、使用增强for循环遍历集合 p
JAVA增强for循环
qq372599132的专栏
10-23 1555
<br />JDK1.5中增加了增强的for循环。<br />缺点：<br />  对于数组，不能方便的访问下标值；<br />  对于集合，与使用Interator相比，不能方便的删除集合中的内容（在内部也是调用Interator）.<br />除了简单遍历并读取其中的内容外，不建议使用增强的for循环。<br />一、遍历数组<br />语法为:<br />for (Type value : array) {<br />    expression value;<br />}<br />//以前我们这样
Iterator的使用和原理，增强for循环的原理
suitianshuang
08-25 459
Iterator iterator对象成为迭代器——设计模式的一种，主要用于遍历Collection集合中的元素。 迭代器被定义为提供一种访问一个容器（container）对象中各个元素，而不需要暴露该对象的内部细节。迭代器模式，就是为容器而生。 使用iterator遍历集合 //省略往集合中刚入元素 ... Iterator iterator = coll.iterator(); //不推荐使用 for(int i = 0;i<list.size;i++){ System.out.println
Java 增强for循环原理
Handsome_Coder的博客
05-04 3967
[Java]增强for循环原理在Java语言中循环遍历的方式有多种常见的有：for循环、增强for循环、while循环、do while循环、迭代器。最近在学习java Collection集合的原理，发现了集合中增强for循环的实现原理，突然对曾经不懂的和懵懂的问题有了新的理解，在此记录一下，对于java初学者和想对深层理解的朋友有一定的帮助。首先增强for循环是在JDK1.5中被加入使用。 增
Java | 增强for底层工作机制
很高兴你能看到这里
05-15 1491
在Java中，增强for循环是一种语法糖。本文简单探究一下它的底层工作机制。
java中普通for循环原理_java中增强for循环的原理
weixin_34552166的博客
02-26 462
java中增强for循环的原理 增强for循环的语句如下: for(ElementType element:arrayName){}; 遍历数组 int[] arr = {1,2,3}; for(int i = 0; i < arr.length; i++) { System.out.println(arr[i]);//1,2,3 } for(int e : arr) { Sys...
循环的力量：计算机高效解决问题的关键
在Java中，`foreach`循环（也称为增强for循环）主要用于遍历集合（如数组、列表、映射等），简化了循环过程，无需手动管理索引或计数器。 **6. 循环在实际应用中的价值** 循环在提高程序效率和自动化任务处理方面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值