Melhor abordagem para converter objeto booleano em string em java

Estou tentando converter booleano em tipo de string ...

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

ou

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

qual das opções acima seria mais eficiente?

Eu não acho que haveria qualquer diferença significativa de desempenho entre eles, mas eu preferiria a 1ª forma.

Se tiver uma Booleanreferência, Boolean.toString(boolean)jogará NullPointerExceptionse for sua referência null. Como a referência é desempacotada booleanantes de ser passada para o método.

Enquanto o String.valueOf()método , como mostra o código-fonte, faz a nullverificação explícita :

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

Basta testar 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, não há diferença.

Se tiver certeza de que seu valor não é, nullvocê pode usar a terceira opção, que é

String str3 = b.toString();

e seu código parece

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

Se você quiser ser null-safe, use o String.valueOf(b)código que se parece com

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

então, como você vê, ele primeiro testará nulle depois chamará o toString()método em seu objeto.

Chamar Boolean.toString(b)irá invocar

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

que é um pouco mais lento do que b.toString()uma vez que a JVM precisa primeiro desencaixotar Boolean para o booleanqual será passado como argumento Boolean.toString(...), enquanto b.toString()reutiliza o private boolean valuecampo no Booleanobjeto que mantém seu 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
--------------

Se isso for com o propósito de obter um valor "verdadeiro" constante, em vez de "Verdadeiro" ou "VERDADEIRO", você pode usar isto:

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

Se você está procurando uma maneira rápida de fazer isso, por exemplo, depurando, você pode simplesmente concatenar uma string vazia no booleano:

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

No entanto, eu recomendo fortemente o uso de outro método para uso em produção. Esta é uma solução simples e rápida, útil para depuração.

Depende do que você entende por "eficiente". Em termos de desempenho, ambas as versões são iguais, pois são o mesmo 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 você observar a implementação de ambos os métodos, eles terão a mesma aparência.

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

Portanto, os dois métodos são igualmente eficientes.