Il miglior approccio per convertire un oggetto booleano in una stringa in java

Sto cercando di convertire un booleano in un tipo di stringa ...

Boolean b = true;
String str = String.valueOf(b);

o

Boolean b = true;
String str = Boolean.toString(b);

quale dei precedenti sarebbe più efficiente?

Non penso ci sarebbe alcuna differenza significativa nelle prestazioni tra loro, ma preferirei il primo modo.

Se hai un Booleanriferimento, Boolean.toString(boolean)verrà lanciato NullPointerExceptionse il tuo riferimento è null. Poiché il riferimento viene decompresso booleanprima di essere passato al metodo.

Mentre, String.valueOf()come mostra il codice sorgente , il metodo esegue il nullcontrollo esplicito :

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

Prova questo codice:

Boolean b = null;

System.out.println(String.valueOf(b));    // Prints null
System.out.println(Boolean.toString(b));  // Throws NPE

Per booleano primitivo, non c'è differenza.

Se sei sicuro che il tuo valore non nullsia, puoi utilizzare la terza opzione che è

String str3 = b.toString();

e il suo codice sembra

public String toString() {
    return value ? "true" : "false";
}

Se vuoi essere null-safe usa il String.valueOf(b)codice che assomiglia

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

così come vedi prima testerà nulle successivamente invocerà il toString()metodo sul tuo oggetto.

La chiamata Boolean.toString(b)richiamerà

public static String toString(boolean b) {
    return b ? "true" : "false";
}

che è un po 'più lento di b.toString()quanto JVM deve prima unboxing Boolean a booleancui verrà passato come argomento Boolean.toString(...), mentre b.toString()riutilizza il private boolean valuecampo Booleannell'oggetto che mantiene il suo stato.

public class Sandbox {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Boolean b = true;
        boolean z = false;
        echo (b);
        echo (z);
        echo ("Value of b= " + b +"\nValue of z= " + z);
    }

    public static void echo(Object obj){
        System.out.println(obj);
    } 

}

Result
--------------
true
false
Value of b= true
Value of z= false
--------------

Se questo è allo scopo di ottenere un valore "vero" costante, anziché "Vero" o "VERO", puoi utilizzare questo:

Boolean.TRUE.toString();
Boolean.FALSE.toString();

Se stai cercando un modo rapido per farlo, ad esempio il debug, puoi semplicemente concatenare una stringa vuota sul booleano:

System.out.println(b+"");

Tuttavia, consiglio vivamente di utilizzare un altro metodo per l'utilizzo in produzione. Questa è una soluzione semplice e veloce utile per il debug.

Dipende da cosa intendi per "efficiente". Dal punto di vista delle prestazioni, entrambe le versioni sono le stesse del suo stesso bytecode.

$ ./javap.exe -c java.lang.String | grep -A 10 "valueOf(boolean)"
  public static java.lang.String valueOf(boolean);
    Code:
       0: iload_0
       1: ifeq          9
       4: ldc           #14                 // String true
       6: goto          11
       9: ldc           #10                 // String false
      11: areturn


$ ./javap.exe -c java.lang.Boolean | grep -A 10 "toString(boolean)"
  public static java.lang.String toString(boolean);
    Code:
       0: iload_0
       1: ifeq          9
       4: ldc           #3                  // String true
       6: goto          11
       9: ldc           #2                  // String false
      11: areturn

Se vedi l'implementazione di entrambi i metodi, hanno lo stesso aspetto.

String.valueOf (b)

public static String valueOf(boolean b) {
        return b ? "true" : "false";
    }

Boolean.toString (b)

public static String toString(boolean b) {
        return b ? "true" : "false";
    }

Quindi entrambi i metodi sono ugualmente efficienti.