Java: prestazioni di Enums vs. if-then-else

Question

Non ho avuto la vera fortuna di ottenere una risposta concisa per questo confronto utilizzando Google e piuttosto che fare le mie valutazioni di tempo, ho pensato di chiedere prima.

Sono abbastanza sicuro che un'istruzione switch che utilizza Enums eseguirà più rapidamente di un'istruzione if-then-else, anche se è o meno una differenza notevole un'altra domanda.

Qualcuno potrebbe far luce su questo per me?

---

Grazie per le risposte rapide ragazzi, lo terrò a mente per progetti futuri.

Answer 1

Yeap, sì, perché in termini generali un'istruzione switch funziona più rapidamente di if/else chain.

Sebbene il codice byte generato non sia sempre la fonte definitiva per i confronti delle prestazioni, è possibile esaminarlo per avere un'idea migliore.

Per esempio questo codice:

class A { 
    enum N { ONE, TWO, THREE } 
    void testSwitch(N e) { 
     switch(e) { 
      case ONE : x(); break; 
      case TWO : x(); break; 
      case THREE : x(); break; 
     } 
    } 
    void testIf(Enum e) { 
     if(e == N.ONE) { x(); } 
     else if(e == N.TWO) { x(); } 
     else if(e == N.THREE) { x(); } 
    } 
    void x(){} 
} 

genera i seguenti:

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

void testSwitch(A$N); 
    Code: 
    0: getstatic #2; //Field A$1.$SwitchMap$A$N:[I 
    3: aload_1 
    4: invokevirtual #3; //Method A$N.ordinal:()I 
    7: iaload 
    8: tableswitch{ //1 to 3 
     1: 36; 
     2: 43; 
     3: 50; 
     default: 54 } 
    36: aload_0 
    37: invokevirtual #4; //Method x:()V 
    40: goto 54 
    43: aload_0 
    44: invokevirtual #4; //Method x:()V 
    47: goto 54 
    50: aload_0 
    51: invokevirtual #4; //Method x:()V 
    54: return 

void testIf(java.lang.Enum); 
    Code: 
    0: aload_1 
    1: getstatic #5; //Field A$N.ONE:LA$N; 
    4: if_acmpne 14 
    7: aload_0 
    8: invokevirtual #4; //Method x:()V 
    11: goto 39 
    14: aload_1 
    15: getstatic #6; //Field A$N.TWO:LA$N; 
    18: if_acmpne 28 
    21: aload_0 
    22: invokevirtual #4; //Method x:()V 
    25: goto 39 
    28: aload_1 
    29: getstatic #7; //Field A$N.THREE:LA$N; 
    32: if_acmpne 39 
    35: aload_0 
    36: invokevirtual #4; //Method x:()V 
    39: return 

void x(); 
    Code: 
    0: return 

} 

che sembra essere abbastanza veloce in entrambi i casi.

Quindi, scegli quello che è più facile da mantenere.

Answer 2

Non so più veloce, immagino che siano entrambi incredibilmente veloci.

La mia considerazione è che l'interruttore con enumerazioni è molto più leggibile di un multi-if/else bloccare

Ma attenzione di perdere istruzioni break !!

Answer 3

In teoria, un'istruzione switch può essere ottimizzata come un singolo salto calcolato, mentre le catene if-then-else devono rimanere come confronti individuali. Non so se Java in realtà esegue questa ottimizzazione.

In ogni caso, gli switch sono migliori delle catene if-then-else in termini di leggibilità e manutenibilità, quindi usali comunque se possibile.

Answer 4

Sì, un'istruzione switch eseguirà quasi sempre più rapidamente del blocco equivalente di istruzioni if ​​/ else perché il compilatore può eseguire più ottimizzazioni (in genere un blocco di interruzioni viene compilato in una tabella di diramazione che è praticamente impossibile da eseguire con un blocco dei condizionali.)

direi che sono anche sia più leggibile e più gestibile (con l'eccezione dei casi usando caduta-through, che vorrei consigliare contro!)

quanto alla questione se è notevolmente più veloce, dipende da ciò che definite come notevole. Le probabilità sono a meno che non cerchi qualcosa di veramente specifico che non te ne accorgi affatto, ma farei comunque le cose in questo modo a causa del vantaggio di leggibilità più che altro (considera il vantaggio di velocità come bonus!)

Answer 5

Basta aderire al codice più leggibile e comprensibile che riesci a trovare, sono sicuro che hai perso tutto il tempo guadagnato nell'ottimizzazione delle prestazioni mentre cercavi già questa risposta.Le micro-ottimizzazioni come questa raramente valgono la pena e possono facilmente portare a un codice più complesso del necessario.

Answer 6

La mia risposta a questo è la stessa di sempre per la domanda è la costruzione del linguaggio X generalmente più veloce della costruzione del linguaggio Y: Non c'è una risposta generale!

Potrebbe esserci solo una risposta specifica per alcune implementazioni di una lingua, ad es. La JVM di Oralce (formalmente Sun) basata su compilatore Hotspot o IBM JDK su piattaforma Z o OpenJDK su Linux, o ...

Quindi, l'unico modo per dare una risposta significativa alla tua domanda è di fare un punto di riferimento adeguato. Fai attenzione ai micro benchmark, sono più spesso sbagliati che a destra, vedi per es. How not to write a micro benchmark. Se si vuole ancora trovare su utilizzare questa domanda framework descritto here.

Pertanto, vorrei consigliare di selezionare la caratteristica linguistica in base alla loro applicabilità e leggibilità nel proprio contesto.