Che è migliore in termini di prestazioni (bool01 == bool02) vs (bool01 && bool02) [duplicato]

Question

Che è migliore in termini di prestazioni (bool01 == bool02) vs (bool01 && bool02) [duplicato]

#1 da (11 voti)

0

Quale di questi due è il modo migliore di fare la stessa cosa -

public void someMethod(String s, boolean bool02){
 boolean bool01 = s!=null;
 if(bool01==bool02){
  doSomething();
 }
}

o

public void someMethod(String s, boolean bool02){
 List<String> list=new ArrayList<String>();
 if(s!=null && bool02){
  doSomething();
 }
}

Il modo in cui lo capisco, Opzione 1 -

Calcola s! = null
Impostalo su bool01
Confronta bool01 a bool02

e Opzione 2 -

Calcola s! = null
Confronta con vero
Confronta bool02 su true (a seconda che il passo 2 sia vero)

Questo non è un grosso problema, ma mi preoccupa sapere qual è il migliore. O l'ottimizzazione del compilatore (se esiste) li converte entrambi nella stessa cosa?

programming-practices java coding-standards performance

posta user3344591 15.07.2017 - 01:33

fonte

1 risposta

Leggi altre domande sui tag programming-practices java coding-standards performance

Come risolvere le attività completate dal backlog senza lavoro svolto? modo semplice per impedire a più utenti di lavorare sulla stessa attività

score 11 · Answer 1

Sono entrambi orribili.

Il migliore è quello che fa effettivamente quello che dovrebbe fare. Questi non fanno la stessa cosa.

s!=null is bool01  |  bool02  |  bool01==bool02  |  s!=null && bool02
        F          |    F     |        T         |          F
        F          |    T     |        F         |          F
        T          |    F     |        F         |          F
        T          |    T     |        T         |          T

Chi fa ciò che deve fare è impossibile da dire perché hai rimosso ogni accenno a ciò che sta succedendo con nomi privi di significato come someMethod() , doSomething() e, mio dio buono, bool01 . Questo è il problema più grande.

public void printLength(String s, boolean allowException) {
    if (s != null || allowException) {
        System.out.println( "String length : " + s.length() );
    }
}

Ecco, ora significa qualcosa. Posso guardarlo senza farmi male la testa.

Per riferimento futuro l'equivalente logico di == non è & & amp ;. NON è XOR

       ^  !^ == &&
F  F   F  T  T  F
F  T   T  F  F  F
T  F   T  F  F  F
T  T   F  T  T  T

Ora, potrei rendere printLength() occasionalmente leggermente più veloce mettendo prima allowException in sala operatoria e usare la valutazione di cortocircuito per evitare la sottrazione richiesta per confrontare il riferimento s a null. Non mi interessa Non perché questo è solo un piccolo risparmio, ma perché penso che sia più leggibile vedere il controllo null prima di pensare di consentire l'eccezione.

L'unica prestazione a cui tutti dovrebbero interessarti è come si comporta nella tua testa.