El mejor enfoque para convertir un objeto booleano en una cadena en java

Estoy tratando de convertir booleano a tipo de cadena ...

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

o

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

¿Cuál de los anteriores sería más eficiente?

No creo que haya una diferencia de rendimiento significativa entre ellos, pero preferiría la primera forma.

Si tiene una Booleanreferencia, Boolean.toString(boolean)arrojará NullPointerExceptionsi su referencia es null. Como se desempaqueta la referencia booleanantes de pasarla al método.

Mientras que, el String.valueOf()método que muestra el código fuente, hace la nullverificación explícita :

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

Solo prueba este código:

Boolean b = null;

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

Para booleano primitivo, no hay diferencia.

Si está seguro de que su valor no nulles, puede utilizar la tercera opción, que es

String str3 = b.toString();

y su código se parece a

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

Si desea ser seguro para nulos, use String.valueOf(b)el código que se parece

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

como puede ver, primero probará nully luego invocará el toString()método en su objeto.

Llamar Boolean.toString(b)invocará

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

que es un poco más lento que b.toString()porque JVM necesita primero desempaquetar Boolean a lo booleanque se pasará como argumento Boolean.toString(...), mientras que b.toString()reutiliza el private boolean valuecampo en el Booleanobjeto que mantiene su estado.

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

Si esto es con el propósito de obtener un valor "verdadero" constante, en lugar de "Verdadero" o "VERDADERO", puede usar esto:

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

Si está buscando una forma rápida de hacer esto, por ejemplo, depurando, simplemente puede concatenar una cadena vacía en el booleano:

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

Sin embargo, recomiendo encarecidamente utilizar otro método para el uso de producción. Esta es una solución rápida y sencilla que resulta útil para depurar.

Depende de lo que quieras decir con "eficiente". En cuanto al rendimiento, ambas versiones son iguales ya que tienen el mismo código de bytes.

$ ./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

Si ve la implementación de ambos métodos, se ven iguales.

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

Entonces, ambos métodos son igualmente eficientes.