Warum ist die switch-Anweisung schneller, als wenn sonst für einen String in Java 7?

In Java 7 eine string Objekt kann in der Ausprägung eines switch - Anweisung. Kann jemand erklären, die unter Anweisung von offizielle Dokumentation?

Erzeugt der Java-compiler im Allgemeinen effizienter bytecode von switch-Anweisungen verwenden String-Objekte als von verketteten if-then-else-Anweisungen.

Sicher. Er übersetzt dies: Wenn Sie vergleichen von Zeichenfolgen in eine große Menge von if-than-else-Anweisungen, die Sie verwenden sollten, statt Schalter
Welchen Teil der Aussage verstehst du nicht?
Nicht string-spezifischen version: stackoverflow.com/questions/2086529/...

InformationsquelleAutor user1428716 | 2012-05-31

Java-Code

Dass zwei Versionen einer Klasse, z.B.

Mit if-then-else:

public class IfThenElseClass {
    public static void main(String[] args) {
        String str = "C";
        if ("A".equals(str)) {

        } else if ("B".equals(str)) {

        } else if ("C".equals(str)) {

        }
    }
}

Mit switch:

public class SwitchClass {
    public static void main(String[] args) {
        String str = "C";
        switch (str) {
            case "A":
                break;
            case "B":
                break;
            case "C":
                break;
        }
    }
}

Bytecode

Werfen wir einen Blick auf den bytecode. Immer den bytecode für if-then-else version:

Compiled from "CompileSwitch.java"
public class CompileSwitch {
  public CompileSwitch();
    Code:
       0: aload_0
       1: invokespecial #8  //Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #16 //String C
       2: astore_1
       3: ldc           #18 //String A
       5: aload_1
       6: invokevirtual #20 //Method java/lang/String.equals:(Ljava/lang/Object;)Z
       9: ifne          28
      12: ldc           #26 //String B
      14: aload_1
      15: invokevirtual #20 //Method java/lang/String.equals:(Ljava/lang/Object;)Z
      18: ifne          28
      21: ldc           #16 //String C
      23: aload_1
      24: invokevirtual #20 //Method java/lang/String.equals:(Ljava/lang/Object;)Z
      27: pop
      28: return
}

Immer den bytecode für switch version:

Compiled from "CompileSwitch.java"
public class CompileSwitch {
  public CompileSwitch();
    Code:
       0: aload_0
       1: invokespecial #8 //Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #16 //String C
       2: astore_1
       3: aload_1
       4: dup
       5: astore_2
       6: invokevirtual #18 //Method java/lang/String.hashCode:()I
       9: lookupswitch  { //3
                    65: 44
                    66: 56
                    67: 68
               default: 77
          }
      44: aload_2
      45: ldc           #24 //String A
      47: invokevirtual #26 //Method java/lang/String.equals:(Ljava/lang/Object;)Z
      50: ifne          77
      53: goto          77
      56: aload_2
      57: ldc           #30 //String B
      59: invokevirtual #26 //Method java/lang/String.equals:(Ljava/lang/Object;)Z
      62: ifne          77
      65: goto          77
      68: aload_2
      69: ldc           #16 //String C
      71: invokevirtual #26 //Method java/lang/String.equals:(Ljava/lang/Object;)Z
      74: ifne          77
      77: return
}

Fazit

In der ersten version vergleicht den string durch aufrufen der equals - Methode für jeden Zustand, bis es gefunden ist.
In der zweiten version ist die erste hashCode des Strings. Dann ist dies im Vergleich mit den Werten hashCode jeder case. Finden Sie die lookupswitch. Wenn diese Werte wiederholt passiert einfach, um den code auszuführen, der für die case. Ansonsten rufen Sie die equals Methode die Fälle gebunden. Dies ist viel schneller als je Anruf die equals Methode nur.

+1 große grundsätzliche Erklärung!
Dies ist die Antwort, die ich suchte . Dank Paul

InformationsquelleAutor Paul Vargas

3

switch auf Zeichenfolgen können schneller aus dem gleichen Grund, warum eine Suche in einer hash-set von strings kann schneller sein als eine Suche in einer Liste von strings: Sie können eine Suche in O(1) anstatt in O(N), wo N ist die Anzahl der Saiten.

Daran erinnern, dass switch ist effizienter als eine Kette von if-then-else Aussagen, weil es ist ein berechneter Sprung: ein offset im code berechnet wird basierend auf dem Wert, und dann der Sprung zu dieser offset ausgeführt wird. Java kann ziehen einen ähnlichen trick auf strings mit der Mechanismus ähnlich, dass beschäftigte in den hash-maps und hash-sets.

InformationsquelleAutor dasblinkenlight

Es ist effizienter, so etwas wie:

switch(yourString) {
    case "text1":
        //your code
        break;
    case "text2":
        //etc.
}

als der Korrespondent:

if (yourString.equals("text1")) {
     //your code
} else if (yourString.equals("text2")) {
     //etc.
}

InformationsquelleAutor javatutorial

-1

ich denke, was es bedeutet, oder was ich verstehe ist, dass der bytecode (wenn Sie kompilieren Sie Ihre java-Klasse), erstellt aus einer switch-Anweisung mit string ist schneller und effizienter als die bytecode, der erstellt wird, aus einer if-else-Anweisung mit string. beide können die gleiche Arbeit, bit-Schalter ist offensichtlich effizienter.

switch (str) {
            case "A":  
                     //do something
                     break;
            case "B":
                     //do something
                     break;
            default: 
                     //do something
                     break;
}

ist besser als

if(str.equals("A")) {
//do something
} else if(str-equals("B")) {
//do something
} else {
//do something
}

InformationsquelleAutor tagtraeumer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.