Java循环问题 Object[]objs=新对象[5]； 对于（int i=0；i

对于上述循环，我有两个问题：

是为每个循环迭代创建了

j

变量和

obj

引用，还是创建了一次，然后只重新分配了值

将

++i

而不是

i++

作为单个指令来增加值是否有任何性能优势

是为每次循环迭代创建j变量和obj引用，还是创建一次，然后只重新分配值

每次声明和创建

将++i而不是i++作为一条指令来增加值有什么性能优势吗

不是真的

是为每次循环迭代创建j变量和obj引用，还是创建一次，然后只重新分配值

每次循环时，都会创建一个新的int，但obj只是对现有对象的引用，因此不会触发对象创建。在任何情况下，JVM都很可能为您优化这一点

将++i而不是i++作为一条指令来增加值有什么性能优势吗

很可能没有什么值得注意的，而且JVM可能会改变您的代码

底线：使用可读性更强的变量，并将变量的范围限制在使用它们的地方

实际上，JVM可能会将您的代码更改为这样，因为您在循环中不使用局部变量：

Object[] objs = new Object[5];
for (int i = 0; i < 5; ++i) {
    int j = i + 1;
    Object obj = objs[i];
}

Object[]objs=新对象[5]；
//对于（int i=0；i<5；++i）{
//int j=i+1；
//Object obj=objs[i]；
//}

是的，他们是

这样做：

Object[] objs = new Object[5];
//for (int i = 0; i < 5; ++i) {
//    int j = i + 1;
//    Object obj = objs[i];
//}

Object[]objs=新对象[5]；
int j=0；
Object obj=新对象（）；
对于（int i=0；i<5；++i）{
j=i+1；
obj=objs[i]；
} 

是的，他们每次都会创建，前缀或后缀++其实并不重要

是为每次循环迭代创建j变量和obj引用，还是创建一次，然后只重新分配值

理论上是的。实际上，优化代码不会发生这种情况。但是，在您的情况下，5（或小于10000）的循环可能不会得到优化，因为它的性能可能并不重要

将++i而不是i++作为一条指令来增加值有什么性能优势吗

---

对于优化的代码，它们在这里是相同的。对于未经优化的代码，差异不太重要。

我比较了代码部分的两个字节码。我没发现什么特别的。唯一的区别是，在第一个示例代码部分中定义了4个局部变量，但在第二个示例代码部分中定义了5个局部变量。然而，执行类似的操作码。由于局部变量名称不同，因此执行不同的操作码。我的意思是在第一个例子中‘I被定义为局部变量-2’，在第二个例子中‘I被定义为局部变量-4’

但是通过JVM工具监控代码执行可以提供额外的信息。由于Java是一个平台，JVM可能会优化代码执行，我们可能无法通过查看Java源代码或Java字节码来确定

Object[] objs = new Object[5]; 
int j = 0;
Object obj = new Object();
for (int i = 0; i < 5; ++i) {   
   j = i + 1;   
   obj = objs[i]; 
} 

Object[]objs=新对象[5]；
对于（int i=0；i<5；++i）{
int j=i+1；
Object obj=objs[i]；
}  
局部变量-0=此
局部变量-1=objs
局部变量-2=i
局部变量-3=j
堆栈=2，局部变量=5，参数大小=1
0:aload_0
1:invokespecial#8//方法java/lang/Object。“：（）V
4:iconst_5
5:anewarray#3//类java/lang/Object
8:astore_1#存储对本地值-1（objs）的创建对象引用
9:iconst#u 0#将0推到堆栈上
10:istore_2#local-value-2（i）赋值为0
11:goto 26
14:iload_2#加载本地值2（i）
15:iconst#u 1#++i操作
16:iadd#i+1
17:istore_3#将i+1赋值到局部变量-3（j）
18:aload_1#将本地变量1（objs）中的对象推送到堆栈上
19:iload_2#将局部变量2（i）中的整数推送到堆栈上
20:aaload#检索条目
21:astore 4#将堆栈上的值推入局部变量-4（obj）
23:iinc 2，1#局部变量-2（i）++
26:iload_2
27:iconst_5
28:if_icmplt 14 for（if i==5）
31：返回
**************************************************************************
Object[]objs=新对象[5]；
int j；
对象对象对象；
对于（int i=0；i<5；++i）{
j=i+1；
obj=objs[i]；
}  
局部变量-0=此
局部变量-1=objs
局部变量-2=j
局部变量-3=obj
局部变量-4=i
堆栈=2，局部变量=5，参数大小=1
0:aload_0
1:invokespecial#8//方法java/lang/Object。“：（）V
4:iconst_5
5:anewarray#3//类java/lang/Object
8:astore_1#存储对本地值-1（objs）的创建对象引用
9:iconst#u 0#将零压入堆栈
10:istore 4#局部变量-4（i）赋值为零
12:goto 28
15:iload 4
17:iconst_1
18:iadd#i+1
19：设置了istore_2#j
20:aload_1#加载对象
21:i负载4#负载i
23:aaload
24:astore_3#obj=objs[i]
25:iinc 4，1#i++
28:iload 4
30:iconst_5
31:if_icmplt 15#if i==5
34：返回

我将尝试回答您的问题

是为每次循环迭代创建j变量和obj引用，还是创建一次，然后只重新分配值？

int j

每次都是创建的，

对象引用变量obj

也是每次在循环中创建的，但不是

对象

将++i而不是i++作为
    Object[] objs = new Object[5];  
    for (int i = 0; i < 5; ++i) {  
       int j = i + 1;  
       Object  obj = objs[i];  
    }  

 local-variable-0=this
 local-variable-1=objs
 local-variable-2=i
 local-variable-3=j

  stack=2, locals=5, args_size=1 
 0: aload_0 
 1: invokespecial #8                  // Method java/lang/Object."<init>":()V 
 4: iconst_5 
 5: anewarray     #3                  // class java/lang/Object 
 8: astore_1 #store created object referance to local value-1 (objs)
 9: iconst_0 #push 0 on stack
10: istore_2  # local-value-2(i) assigned 0
11: goto          26 
14: iload_2  #load localvalue 2(i)
15: iconst_1 # ++i operation
16: iadd  #i+1
17: istore_3 #assign i+1 into local-variable-3(j)
18: aload_1 # push object in local varable 1 (objs) onto the stack
19: iload_2 # push integer in local variable 2 (i) onto the stack
20: aaload  # retrieve entry
21: astore        4 # push value on stack into local-variable-4 (obj)
23: iinc          2, 1 # local-variable-2(i)++
26: iload_2 
27: iconst_5 
28: if_icmplt     14 for(if i==5)
31: return 

 **************************************************************************
  Object[] objs = new Object[5];  
    int j; 
    Object obj; 
    for (int i = 0; i < 5; ++i) {  
        j = i + 1;  
        obj = objs[i];  
    }  

  local-variable-0=this
 local-variable-1=objs
 local-variable-2=j
 local-variable-3=obj
 local-variable-4=i

  stack=2, locals=5, args_size=1 
     0: aload_0 
     1: invokespecial #8                  // Method java/lang/Object."<init>":()V 
     4: iconst_5 
     5: anewarray     #3                  // class java/lang/Object 
     8: astore_1 #store created object referance to local value-1 (objs)
     9: iconst_0 #push zero on to the stack
    10: istore        4 # local variable-4(i) is assigned zero
    12: goto          28 
    15: iload         4 
    17: iconst_1 
    18: iadd  #i+1
    19: istore_2  #j is set 
    20: aload_1  #load objs
    21: iload         4 #load i
    23: aaload 
    24: astore_3  #obj=objs[i]
    25: iinc          4, 1 # i++
    28: iload         4 
    30: iconst_5 
    31: if_icmplt     15 # if i==5
    34: return