Czy jest to pomocne optymalizacji pętli w java?

Question

rozważyć następujące kwestie:

1.

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

i:

2.

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

Czy ten rodzaj optymalizacji naprawdę pomocny albo kompilator to zrobić automatycznie, tak?

Twoja odpowiedź zmieni się, jeśli bar() byłby geterem? (np. getBar())

Czy zmieni się odpowiedź, jeśli będę kierować reklamy na system Android?

Answer 1

Próbowałem dwóch przykładów, jak robisz dla swojego pytania. Na tej podstawie muszę powiedzieć, że drugie podejście byłoby lepsze. (Choć nie jestem rozważa wielowątkowości)

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); 
     } 
    } 
} 

po kompilacji, a następnie ponownie decompiling mam to.

* 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); 
     } 
    } 
} 

po kompilacji, a następnie ponownie decompiling mam to.

/* 
* 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

Po obejrzeniu komentarze i mające odpowiedzieć na nich, zdałem sobie sprawę, że nawet jeśli kompilator będzie nurkować w zrozumieniu a.bar() „s kodu, byłoby niemożliwe Gwarantujemy że a.bar() wynik nie ulegnie zmianie w wielowątkowy Środowisko takie jak to jest w Javie, także w połączeniu z Reflection jeśli bar jest polem członkowskim, które może zmienić poprzez odbicia i kompilator nie wiedziałby, że z góry, który może spowodować, że prosty return bar; jest nieprzewidywalny.

W tej chwili wydaje mi się racjonalne, aby nadal nurtować tę optymalizację w moim kodzie.

Answer 3

zaskakujące, gdyż może ona wydaje spróbować:

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()); 
} 

tylko mały uszczypnąć, dać mu spróbować