Bester Ansatz zum Konvertieren von Booleschen Objekten in Zeichenfolgen in Java

Ich versuche, Boolesche in String-Typ zu konvertieren ...

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

oder

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

Welches der oben genannten wäre effizienter?

Ich glaube nicht, dass es einen signifikanten Leistungsunterschied zwischen ihnen geben würde, aber ich würde den ersten Weg bevorzugen.

Wenn Sie eine BooleanReferenz haben, Boolean.toString(boolean)wird geworfen, NullPointerExceptionwenn Ihre Referenz ist null. Da die Referenz entpackt ist, booleanbevor sie an die Methode übergeben wird.

Während die String.valueOf()Methode, wie der Quellcode zeigt, die explizite nullPrüfung durchführt:

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

Testen Sie einfach diesen Code:

Boolean b = null;

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

Für primitive Boolesche Werte gibt es keinen Unterschied.

Wenn Sie sicher sind, dass Ihr Wert nicht ist null, können Sie die dritte Option verwenden

String str3 = b.toString();

und sein Code sieht aus wie

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

Wenn Sie null-sicher sein möchten, verwenden Sie, String.valueOf(b)welcher Code aussieht

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

Wie Sie sehen, wird zuerst nulldie toString()Methode für Ihr Objekt getestet und später aufgerufen .

Der Anruf Boolean.toString(b)wird aufgerufen

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

Das ist etwas langsamer als b.toString()da JVM muss zuerst unbox Boolean zu booleandem als Argument übergeben wird , um Boolean.toString(...), während b.toString()Umnutzungen private boolean valueFeld in BooleanObjekt , das seinen Zustand hält.

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

Wenn dies dazu dient, einen konstanten "wahren" Wert anstelle von "wahr" oder "WAHR" zu erhalten, können Sie Folgendes verwenden:

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

Wenn Sie nach einer schnellen Möglichkeit suchen, dies zu tun, beispielsweise das Debuggen, können Sie einfach eine leere Zeichenfolge mit dem Booleschen Wert verknüpfen:

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

Ich empfehle jedoch dringend, eine andere Methode für die Verwendung in der Produktion zu verwenden. Dies ist eine einfache schnelle Lösung, die zum Debuggen nützlich ist.

Kommt darauf an, was du mit "effizient" meinst. In Bezug auf die Leistung sind beide Versionen identisch mit dem gleichen 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

Wenn Sie die Implementierung beider Methoden sehen, sehen sie gleich aus.

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

Beide Methoden sind also gleich effizient.