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 Boolean
referencia, Boolean.toString(boolean)
arrojará NullPointerException
si su referencia es null
. Como se desempaqueta la referencia boolean
antes de pasarla al método.
Mientras que, el String.valueOf()
método que muestra el código fuente, hace la null
verificació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 null
es, 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á null
y 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 boolean
que se pasará como argumento Boolean.toString(...)
, mientras que b.toString()
reutiliza el private boolean value
campo en el Boolean
objeto 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.
System.out.println
es para depurar de todos modos, ¿verdad?
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.
""+b
. Es más lento pero más eficiente para el desarrollador. Si desea un rendimiento superior, puede escribir los datos a / desde un ByteBuffer directo, es decir, cambiar lo que hace con el String para que no lo necesite.null
comofalse
, puede usarString.format("%b", b)