具有原始类型的Java代码的效率 [英] Efficiency of Java code with primitive types

问题描述

我想问问哪段代码在Java中更有效? 代码1:

I want to ask which piece of code is more efficient in Java? Code 1:

void f()
{
 for(int i = 0 ; i < 99999;i++)
 {
  for(int j = 0 ; j < 99999;j++)
  {
   //Some operations
  }
 }

}

代码2:

void f()
{
 int i,j;
 for(i = 0 ; i < 99999;i++)
 {
  for(j = 0 ; j < 99999;j++)
  {
   //Some operations
  }
 }

}

我的老师说第二个更好，但是我不同意这种观点.

My teacher said that second is better, but I can't agree that opinion.

推荐答案

我更喜欢第一个而不是第二个，因为它使循环变量不会影响方法中其余代码.由于它们在循环外部不可见，因此以后您不能无意间引用它们.

I would prefer the first over the second because it keeps the loop variables out of the way of the rest of the code in the method. Since they're not visible outside of the loop, you can't accidentally refer to them later on.

其他答案也是正确的:不要担心这种性能问题.但是要做考虑是出于代码可读性的原因，并且是为了与下一个出现的人交流程序员的意图.这比微观优化问题重要得多.

The other answers are right, too: don't worry about this sort of thing for performance. But do think about it for code readability reasons, and for communicating programmer intent to the next person who comes along. This is much more important than micro-optimization concerns.

现在，这是在Java语言(如Java语言规范)级别.在Java虚拟机级别上，使用这两个中的哪一个绝对没有区别.当地人的分配方式完全相同.

Now, that's at the Java language (as in Java Language Specification) level. At the Java Virtual Machine level, it makes absolutely no difference which of those two you use. The locals are allocated in exactly the same way.

如果不确定，可以随时对其进行编译，然后看看会发生什么.让我们为两个版本创建两个类f1和f2:

If you're not sure, you can always compile it and see what happens. Let's make two classes, f1 and f2, for the two versions:

$ cat f1.java
public class f1 {
  void f() {
    for(int i = 0 ; i < 99999;i++) {
      for(int j = 0 ; j < 99999;j++) {
      }
    }
  }
}

$ cat f2.java
public class f2 {
  void f() {
    int i, j;
    for(i = 0 ; i < 99999;i++) {
      for(j = 0 ; j < 99999;j++) {
      }
    }
  }
}

编译它们:

$ javac f1.java
$ javac f2.java

并反编译它们:

$ javap -c f1 > f1decomp
$ javap -c f2 > f2decomp

并比较它们:

$ diff f1decomp f2decomp
1,3c1,3
< Compiled from "f1.java"
< public class f1 extends java.lang.Object{
< public f1();
---
> Compiled from "f2.java"
> public class f2 extends java.lang.Object{
> public f2();

字节码绝对没有差别.

这篇关于具有原始类型的Java代码的效率的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！