Java 哪种方式声明变量最快？

对于一个经常被调用的函数中使用的变量，以及在J2ME中在blackberry上的实现（如果这改变了什么，您能解释一下吗）

X类{
int i；
公共void someFunc（int j）{
i=0；
而（i

或

X类{
静态int-i；
公共void someFunc（int j）{
i=0；
而（i

或

X类{
公共void someFunc（int j）{
int i=0；
而（i

我知道静态类变量和非静态类变量的访问方式不同，但我不知道这会影响速度。我还记得在某个地方读到，函数中的变量可以更快地访问，但我不知道为什么，也不知道我在哪里读到的

问题背景：游戏中的一些绘画功能调用过于频繁，当在较大的循环中使用变量时，即使访问时间上的微小差异也会影响整体性能

更新

我设置了一个小测试（下面的代码），并在真实的设备上运行它，以查看结果是什么样的。我对一个函数进行了10000次调用，该函数在访问变量时循环了10000次

• 如果变量处于运行状态，则运行约9250毫秒
• 如果该变量属于该类，则运行约21700毫秒
• 如果变量属于该类，但是静态的，则它将运行210000 ms

我不知道测试的结果有多重要，它们是否在现实世界的程序中有效，是否没有其他外部因素在起作用。但是，假设他们这样做了，因为它与这里最常见的视图相匹配，所以访问时间之间存在相当大的差异

这是否属于过早优化？也许吧，但它似乎也是尽可能多地在函数变量中使用的有用指南。即使将类变量复制到函数中，似乎也会影响执行时间

   final static int MAX = 10000;
   private void runTest()
   {
       long startTime = System.currentTimeMillis();
       for(int count = 0; count < MAX; count++)
           test1(MAX);
       test1.setText(""+(System.currentTimeMillis()-startTime));

       startTime = System.currentTimeMillis();
       for(int count = 0; count < MAX; count++)
           test2(MAX);
       test2.setText(""+(System.currentTimeMillis()-startTime));

       startTime = System.currentTimeMillis();
       for(int count = 0; count < MAX; count++)
           test3(MAX);
       test3.setText(""+(System.currentTimeMillis()-startTime));

   }

   void test1(int j)
   {
       int i = 0;
       while(i < j)
       {
           i++;
       }
   }
   int i2;
   void test2(int j)
   {
       i2 = 0;
       while(i2 < j)
       {
           i2++;
       }
   }
   static int i3;
   void test3(int j)
   {
       i3 = 0;
       while(i3 < j)
       {
           i3++;
       }
   }

final static int MAX=10000；
私有void runTest（）
{
long startTime=System.currentTimeMillis（）；
对于（int count=0；count

它们具有完全不同的语义-您希望值是类状态的一部分、类实例状态的一部分还是方法的局部

JIT有更多的机会优化上一个版本，因为它知道变量可能在哪里使用（并且不需要担心其他线程访问它）。我想这可能是最快的

---

不过，您应该真正进行测试——一般来说，在尝试这种微优化之前，首先编写可读性最高的代码，看看您是否真的遇到了瓶颈。

就个人而言，我认为您不会看到这三者之间有任何明显的区别。为什么不试试这三种方法并运行一些性能测试呢？这是您可以确定的唯一方法，因为JVM在幕后优化事物的方式可能不是直观的

---

我很难相信这是您的性能瓶颈。我的方法是以最合乎逻辑的方式编写代码，并在其他地方寻找优化。

在考虑这种微观优化之前，您应该彻底分析代码。然后，实施并衡量任何可能的微观优化的效果

---

很难预测这三个版本中的哪一个（如果有的话！）在您的特定平台上会更快。

或者您可以使用传统的for循环，在循环结束后立即回收此内存：

class X {
    public void someFunc(int j) {
        for(int i = 0; i < j; i++){
            [...]
        }
    }
}

X类{
公共void someFunc（int j）{
对于（int i=0；i

我还记得在某个地方读到 可以访问函数中的变量 更快，但我不知道为什么

局部变量可以保存在寄存器中，这是存在的最快的内存。除非您有非常智能的JIT，否则实例和类字段必须位于主内存（或缓存）中，因为它们可以对其他线程可见

---

因为从代码清洁度的角度来看，它也是最好的解决方案，所以您肯定应该使用局部变量。

除非您的目标平台有一些非常奇怪的JVM实现，否则性能顺序是：

• 局部变量
• 静态/对象成员

局部变量提供最佳性能的原因是：

• JVM特别支持较短的字节码
• 访问它们不需要其他信息（对象成员必须使用this引用寻址，而静态成员需要类引用）
• 只对本地线程可见，因此JIT可以对它们执行各种优化（如将它们放入寄存器）

---

同样值得注意的是，方法参数在字节码级别上与局部变量的处理方式相同。

我同意语义，但变量b

class X {
    public void someFunc(int j) {
        int i = 0;
        while( i < j ){
            [...]
            i++;
        }
    }
}

   final static int MAX = 10000;
   private void runTest()
   {
       long startTime = System.currentTimeMillis();
       for(int count = 0; count < MAX; count++)
           test1(MAX);
       test1.setText(""+(System.currentTimeMillis()-startTime));

       startTime = System.currentTimeMillis();
       for(int count = 0; count < MAX; count++)
           test2(MAX);
       test2.setText(""+(System.currentTimeMillis()-startTime));

       startTime = System.currentTimeMillis();
       for(int count = 0; count < MAX; count++)
           test3(MAX);
       test3.setText(""+(System.currentTimeMillis()-startTime));

   }

   void test1(int j)
   {
       int i = 0;
       while(i < j)
       {
           i++;
       }
   }
   int i2;
   void test2(int j)
   {
       i2 = 0;
       while(i2 < j)
       {
           i2++;
       }
   }
   static int i3;
   void test3(int j)
   {
       i3 = 0;
       while(i3 < j)
       {
           i3++;
       }
   }

class X {
    public void someFunc(int j) {
        for(int i = 0; i < j; i++){
            [...]
        }
    }
}