¿Hay alguna diferencia si declaro variables dentro o fuera de un bucle en Java? [cerrado]

Posible duplicado:
¿Dónde declaras las variables? ¿La parte superior de un método o cuando los necesita?

¿Hay alguna diferencia si declaro variables dentro o fuera de un bucle en Java?

Es esto

for(int i = 0; i < 1000; i++) {
   int temp = doSomething();
   someMethod(temp);
}

igual a esto (con respecto al uso de memoria)?

int temp = 0;
for(int i = 0; i < 1000; i++) {
   temp = doSomething();
   someMethod(temp);
}

¿Y si la variable temporal es, por ejemplo, una ArrayList?

for(int i = 0; i < 1000; i++) {
   ArrayList<Integer> array = new ArrayList<Integer>();
   fillArray(array);
   // do something with the array
}

EDITAR: javap -cobtuve el siguiente resultado

Variable fuera del ciclo:

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0      
       1: istore_1      
       2: iconst_0      
       3: istore_2      
       4: iload_2       
       5: sipush        1000
       8: if_icmpge     25
      11: invokestatic  #2                  // Method doSomething:()I
      14: istore_1      
      15: iload_1       
      16: invokestatic  #3                  // Method someMethod:(I)V
      19: iinc          2, 1
      22: goto          4
      25: return  

Variable dentro del bucle:

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0      
       1: istore_1      
       2: iload_1       
       3: sipush        1000
       6: if_icmpge     23
       9: invokestatic  #2                  // Method doSomething:()I
      12: istore_2      
      13: iload_2       
      14: invokestatic  #3                  // Method someMethod:(I)V
      17: iinc          1, 1
      20: goto          2
      23: return        

Y para los interesados, este código:

public class Test3 {
    public static void main(String[] args) {
        for(int i = 0; i< 1000; i++) {
            someMethod(doSomething());
        }   
    }
    private static int doSomething() {
        return 1;
    }
    private static void someMethod(int temp) {
        temp++;
    }
}

produce esto:

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0      
       1: istore_1      
       2: iload_1       
       3: sipush        1000
       6: if_icmpge     21
       9: invokestatic  #2                  // Method doSomething:()I
      12: invokestatic  #3                  // Method someMethod:(I)V
      15: iinc          1, 1
      18: goto          2
      21: return   

Pero la optimización ocurre en tiempo de ejecución entonces. ¿Hay alguna manera de ver el código optimizado? (Perdón por la larga edición)

La respuesta común a la mayoría de estas preguntas debería ser "¿por qué no lo prueba y lo descubre?". En Java, probablemente podría echar un vistazo al código de bytes generado (creo que la herramienta se llama javap), para ver cuál es la diferencia en el código de bytes entre esas dos formas de declarar la variable.

Hacerlo así es una mejor experiencia de aprendizaje para usted, porque la próxima vez que se encuentre con un problema de optimización puede usar la misma herramienta para verificar que el compilador está haciendo lo que espera: le ayudará a evitar cambiar innecesariamente su codificación estilo cuando el optimizador funciona bien por sí solo, o encuentra ajustes reales cuando realmente necesita ese último bit de rendimiento.

Respuesta corta: no. Ya había preguntas similares en algún lugar de este sitio. No hay una diferencia notable según el bytecode generado. Declararlos cuando sea necesario produce menos líneas de código

Aquí está la respuesta aceptada: /software//a/56590/43451

A nivel de la variable individual no hay una diferencia significativa en la eficiencia, pero si tuviera una función con 1000 bucles y 1000 variables (no importa el mal estilo implícito) podría haber diferencias sistémicas porque todas las vidas de todas las variables serían lo mismo en lugar de superponerse. Esto podría afectar cosas como el tamaño de la pila y la capacidad del recolector de basura para limpiar las variables que se mantuvieron con vida más tiempo del necesario.

Además, es mucho mejor estilo darles a las variables el alcance más pequeño posible. Previene accidentes.