Ist das eine hilfreiche Optimierung für Loops in Java?

Question

ist folgendes zu beachten:

1.

for (final Bar a : bars) { 
     for (final Foo f : foos) { 
      doSomethingWith(f.foo(), a.bar()); 
     } 
    } 

und:

2.

for (final Bar a : bars) { 
     final Object bar = a.bar(); 
     for (final Foo f : foos) { 
      doSomethingWith(f.foo(), bar); 
     } 
    } 

Ist diese Art der Optimierung wirklich hilfreich oder wird der Compiler tun es trotzdem automatisch?

Ändert sich Ihre Antwort, wenn bar() ein Getter ist? (z. B. getBar())

Wird sich Ihre Antwort ändern, wenn ich Android-Entwicklung anstrebe?

Answer 1

Ich habe zwei Beispiele versucht, wie Sie für Ihre Frage tun. Auf dieser Grundlage muss ich sagen, dass der zweite Ansatz besser wäre. (Obwohl Ich erwäge nicht Multi-Threading)

Test.java

public class Test{ 

    public static void main(String... args){ 

     String[][] arr2 = new String[5][5]; 
     for (final String[] obj : arr2) 
     { 
      for (final String str : obj) 
      System.out.println(str.length() +" " + obj.length); 
     } 
    } 
} 

nach dem Kompilieren und dann wieder decompiling ich diese bekam.

* Decompiled with CFR 0_114. 
*/ 
import java.io.PrintStream; 

public class Test { 
    public static /* varargs */ void main(String ... arrstring) { 
     String[][] arrstring2; 
     String[][] arrstring3 = arrstring2 = new String[5][5]; 
     int n = arrstring3.length; 
     for (int i = 0; i < n; ++i) { 
      String[] arrstring4; 
      for (String string : arrstring4 = arrstring3[i]) { //assignment will take place m*n. 
       System.out.println("" + string.length() + " " + arrstring4.length); 
      //this arrstring4.length will execute m*n (in this case).So, this will less efficient than others. 
      } 
     } 
    } 
} 

Test1.java

public class Test1{ 

    public static void main(String... args){ 

     String[][] arr2 = new String[5][5]; 
     for (final String[] obj : arr2) 
     { 
      int value = obj.length; 
      for (final String str : obj) 
       System.out.println(str.length() +" " + value); 
     } 
    } 
} 

nach dem Kompilieren und dann wieder decompiling ich diese bekam.

/* 
* Decompiled with CFR 0_114. 
*/ 
import java.io.PrintStream; 

public class Test1 { 
    public static /* varargs */ void main(String ... arrstring) { 
     String[][] arrstring2; 
     for (String[] arrstring3 : arrstring2 = new String[5][5]) { 
      int n = arrstring3.length; //Assignment will take place M times only. 
      //this will calculate M times only. So, it will definitely faster than above. 
      for (String string : arrstring3) { 
       System.out.println("" + string.length() + " " + n); 
       //here n is calculate M times but can be printed M*N times. 
      } 
     } 
    } 
} 

Answer 2

Nach Kommentaren zu sehen und auf sie zu antworten haben, wurde mir klar, dass selbst wenn der Compiler in Verständnis tauchen würde a.bar() ‚s-Code, es wäre unmöglich, zu garantieren, dass a.bar() Ergebnis nicht in einem Multi-Threaded ändern würde Enviroment wie es ist in Java, auch in Verbindung mit Reflection wenn bar ist ein Mitglied Feld kann es durch Reflexionen ändern und der Compiler würde nicht wissen, dass im Voraus, die eine einfache return bar; unvorhersehbar sein kann.

So scheint es mir rational zu sein, diese Optimierung in meinem Code zu verwenden.

Answer 3

überraschend, da kann es scheint, versuchen:

for (final Bar a : bars) { 
    innerLoop(a, foos); 
} 

private final innerLoop(Bar a, Collection<Foo> foos) { 
    for (final Foo f : foos) { 
     doSomethingWith(f.foo(), a.bar()); 
} 

nur ein kleines zwicken, versuchen Sie es mal