Meilleure approche pour convertir un objet booléen en chaîne en Java

J'essaye de convertir le booléen en type de chaîne ...

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

ou

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

lequel des éléments ci-dessus serait le plus efficace?

Je ne pense pas qu'il y aurait une différence de performance significative entre eux, mais je préférerais la 1ère manière.

Si vous avez une Booleanréférence, Boolean.toString(boolean)jettera NullPointerExceptionsi votre référence est null. Comme la référence est déballée booleanavant d'être transmise à la méthode.

Alors que, String.valueOf()méthode comme le montre le code source, effectue la nullvérification explicite :

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

Testez simplement ce code:

Boolean b = null;

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

Pour le booléen primitif, il n'y a pas de différence.

Si vous êtes sûr que votre valeur n'est pas, nullvous pouvez utiliser la troisième option qui est

String str3 = b.toString();

et son code ressemble à

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

Si vous voulez être sûr de zéro, utilisez le String.valueOf(b)code qui ressemble

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

comme vous le voyez, il testera d'abord nullet invoquera plus tard la toString()méthode sur votre objet.

L'appel Boolean.toString(b)invoquera

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

ce qui est un peu plus lent que b.toString()puisque JVM doit d'abord déballer Boolean à booleanqui sera passé comme argument à Boolean.toString(...), tandis que b.toString()réutilise le private boolean valuechamp dans l' Booleanobjet qui conserve son état.

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 c'est dans le but d'obtenir une valeur constante "true", plutôt que "True" ou "TRUE", vous pouvez utiliser ceci:

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

Si vous recherchez un moyen rapide de le faire, par exemple le débogage, vous pouvez simplement concaténer une chaîne vide sur le booléen:

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

Cependant, je recommande fortement d'utiliser une autre méthode pour une utilisation en production. C'est une solution rapide simple qui est utile pour le débogage.

Cela dépend de ce que vous entendez par «efficace». En termes de performances, les deux versions sont les mêmes que le même 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

Si vous voyez l'implémentation des deux méthodes, elles se ressemblent.

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

Les deux méthodes sont donc également efficaces.