Java 循环的性能考虑

这两个代码段之间是否存在重大性能问题

 User user 

 for(int i =0 ; i < 100 ; i++) {
        user = new User() ;

 }

用户
对于（int i=0；i<100；i++）{
user=新用户（）；
}

及

for（int i=0；i<100；i++）{
用户=新用户（）；
}

---

这只是声明。

否。如果

user

仅在循环中使用，但没有性能差异，则首选第二个。

否。如果

user

仅在循环中使用，但没有性能差异，则首选第二个。

应该没有显著差异。在这两个循环体中，您为新的

用户分配内存

应该没有显著差异。在这两个循环体中，您为新的

用户分配内存

同一个问题经常被发布。是什么让你认为在什么地方声明变量很重要。两个版本中都创建了100个用户对象。生成的代码完全相同

---

唯一的区别是这个变量的范围，在版本1中，您可以从循环外部访问变量用户，而在版本2中，您不能。根据需要，您更喜欢第一个或第二个版本。

同样的问题经常被发布。是什么让你认为在什么地方声明变量很重要。两个版本中都创建了100个用户对象。生成的代码完全相同

---

唯一的区别是这个变量的范围，在版本1中，您可以从循环外部访问变量用户，而在版本2中，您不能。根据需要，首选第一个或第二个版本。

创建新对象的时间将占此处花费时间的99%。在循环中做什么或在何处放置局部变量并不重要。

创建新对象的时间占在此花费的99%。在循环中做什么或在何处放置局部变量并不重要。

有一种说法认为这确实会产生影响，但Java编译器足够聪明，可以确保它不会产生影响。并显示两种类型声明之间生成的字节码。没有显著的性能差异

---

不同之处在于你发现它更具可读性。

有一种说法认为这确实会产生不同，但Java编译器足够聪明，可以确保它不会产生差异。并显示两种类型声明之间生成的字节码。没有显著的性能差异

---

区别在于你发现什么更具可读性。

回答：完全一样

我创建了两个类C1和C2：

class C1 {
    public void test() {
        String user;        
        for(int i =0 ; i < 100 ; i++) {
            user = new String("s" + i);
            System.out.println(user);        
        }

    }
}

C1类{
公开无效测试（）{
字符串用户；
对于（int i=0；i<100；i++）{
用户=新字符串（“s”+i）；
System.out.println（用户）；
}
}
}

及

C2类{
公开无效测试（）{
对于（int i=0；i<100；i++）{
字符串用户=新字符串（“s”+i）；
System.out.println（用户）；
}
}
}

在使用“javac-source 1.4-target 1.4”（或1.3）编译它们并反编译类之后，我得到了相同的代码：

import java.io.PrintStream;

class C1
{

    C1()
    {
    }

    public void test()
    {
        for(int i = 0; i < 100; i++)
        {
            String s = new String("s" + i);
            System.out.println(s);
        }

    }
}

导入java.io.PrintStream；
C1类
{
C1（）
{
}
公开无效测试（）
{
对于（int i=0；i<100；i++）
{
字符串s=新字符串（“s”+i）；
系统输出打印项次；
}
}
}

及

导入java.io.PrintStream；
C2类
{
C2（）
{
}
公开无效测试（）
{
对于（int i=0；i<100；i++）
{
字符串s=新字符串（“s”+i）；
系统输出打印项次；
}
}
}

使用“javac-source 1.5-target 1.5”（或1.6）编译它们并反编译类，我也得到了相同的代码：

import java.io.PrintStream;

class C1
{

    C1()
    {
    }

    public void test()
    {
        for(int i = 0; i < 100; i++)
        {
            String s = new String((new StringBuilder()).append("s").append(i).toString());
            System.out.println(s);
        }

    }
}

导入java.io.PrintStream；
C1类
{
C1（）
{
}
公开无效测试（）
{
对于（int i=0；i<100；i++）
{
字符串s=新字符串（（new StringBuilder（））.append（“s”）.append（i）.toString（））；
系统输出打印项次；
}
}
}

及

导入java.io.PrintStream；
C2类
{
C2（）
{
}
公开无效测试（）
{
对于（int i=0；i<100；i++）
{
字符串s=新字符串（（new StringBuilder（））.append（“s”）.append（i）.toString（））；
系统输出打印项次；
}
}
}
回答：完全一样

我创建了两个类C1和C2：

class C1 {
    public void test() {
        String user;        
        for(int i =0 ; i < 100 ; i++) {
            user = new String("s" + i);
            System.out.println(user);        
        }

    }
}

C1类{
公开无效测试（）{
字符串用户；
对于（int i=0；i<100；i++）{
用户=新字符串（“s”+i）；
System.out.println（用户）；
}
}
}

及

C2类{
公开无效测试（）{
对于（int i=0；i<100；i++）{
字符串用户=新字符串（“s”+i）；
System.out.println（用户）；
}
}
}

在使用“javac-source 1.4-target 1.4”（或1.3）编译它们并反编译类之后，我得到了相同的代码：

import java.io.PrintStream;

class C1
{

    C1()
    {
    }

    public void test()
    {
        for(int i = 0; i < 100; i++)
        {
            String s = new String("s" + i);
            System.out.println(s);
        }

    }
}

导入java.io.PrintStream；
C1类
{
C1（）
{
}
公开无效测试（）
{
对于（int i=0；i<100；i++）
{
字符串s=新字符串（“s”+i）；
系统输出打印项次；
}
}
}

及

导入java.io.PrintStream；
C2类
{
C2（）
{
}
公开无效测试（）
{
对于（int i=0；i<100；i++）
{
字符串s=新字符串（“s”+i）；
系统输出打印项次；
}
}
}

使用“javac-source 1.5-target 1.5”（或1.6）编译它们并反编译类，我也得到了相同的代码：

import java.io.PrintStream;

class C1
{

    C1()
    {
    }

    public void test()
    {
        for(int i = 0; i < 100; i++)
        {
            String s = new String((new StringBuilder()).append("s").append(i).toString());
            System.out.println(s);
        }

    }
}

导入java.io.PrintStream；
C1类
{
C1（）
{
}
公开无效测试（）
{
对于（int i=0；i<100；i++）
{
字符串s=新字符串（（new StringBuilder（））.append（“s”）.append（i）.toString（））；
系统输出打印项次；
}
}
}

import java.io.PrintStream;

class C2
{

    C2()
    {
    }

    public void test()
    {
        for(int i = 0; i < 100; i++)
        {
            String s = new String((new StringBuilder()).append("s").append(i).toString());
            System.out.println(s);
        }

    }
}