Comment convertir un objet String en objet booléen?

Comment convertir un Stringobjet en Booleanobjet?

Essayez (selon le type de résultat souhaité):

Boolean boolean1 = Boolean.valueOf("true");
boolean boolean2 = Boolean.parseBoolean("true");

Avantage:

• Boolean: cela ne crée pas de nouvelles instances de Boolean, donc les performances sont meilleures (et moins de récupération de place). Il réutilise les deux instances de Boolean.TRUEou Boolean.FALSE.
• booléen: aucune instance n'est nécessaire, vous utilisez le type primitif.

La documentation officielle est dans le Javadoc .

ACTUALISÉ:

Autoboxing pourrait également être utilisé, mais il a un coût de performance.
Je suggère de ne l'utiliser que lorsque vous devez vous lancer, pas lorsque le plâtre est évitable.

Vous devez être prudent lorsque vous utilisez Boolean.valueOf (string) ou Boolean.parseBoolean (string) . La raison en est que les méthodes retourneront toujours false si la chaîne n'est pas égale à "true" (le cas est ignoré).

Par exemple:

Boolean.valueOf("YES") -> false

En raison de ce comportement, je recommanderais d'ajouter un mécanisme pour garantir que la chaîne qui doit être traduite en booléen suit un format spécifié.

Par exemple:

if (string.equalsIgnoreCase("true") || string.equalsIgnoreCase("false")) {
    Boolean.valueOf(string)
    // do something   
} else {
    // throw some exception
}

Boolean b = Boolean.valueOf(string);

La valeur de best vraie si la chaîne n'est pas nulle et égale à true(en ignorant la casse).

Outre l'excellente réponse de KLE, nous pouvons également rendre quelque chose de plus flexible:

boolean b = string.equalsIgnoreCase("true") || string.equalsIgnoreCase("t") || 
        string.equalsIgnoreCase("yes") || string.equalsIgnoreCase("y") || 
        string.equalsIgnoreCase("sure") || string.equalsIgnoreCase("aye") || 
        string.equalsIgnoreCase("oui") || string.equalsIgnoreCase("vrai");

(inspiré par la réponse de zlajo ... :-))

boolean b = string.equalsIgnoreCase("true");

Eh bien, comme maintenant en janvier 2018, le meilleur moyen est d'utiliser Apache's BooleanUtils.toBoolean .

Cela convertira n'importe quelle chaîne de type booléen en booléen, par exemple Y, oui, vrai, N, non, faux, etc.

Vraiment pratique!

public static boolean stringToBool(String s) {
        s = s.toLowerCase();
        Set<String> trueSet = new HashSet<String>(Arrays.asList("1", "true", "yes"));
        Set<String> falseSet = new HashSet<String>(Arrays.asList("0", "false", "no"));

        if (trueSet.contains(s))
            return true;
        if (falseSet.contains(s))
            return false;

        throw new IllegalArgumentException(s + " is not a boolean.");
    }

Ma façon de convertir une chaîne en booléen.

String[] values= new String[]{"y","Y","n","N","Yes","YES","yes","no","No","NO","true","false","True","False","TRUE","FALSE",null};
for(String booleanStr : values){
    System.out.println("Str ="+ booleanStr +": boolean =" +BooleanUtils.toBoolean(booleanStr));
}

Résultat:

Str =N: boolean =false
Str =Yes: boolean =true
Str =YES: boolean =true
Str =yes: boolean =true
Str =no: boolean =false
Str =No: boolean =false
Str =NO: boolean =false
Str =true: boolean =true
Str =false: boolean =false
Str =True: boolean =true
Str =False: boolean =false
Str =TRUE: boolean =true
Str =FALSE: boolean =false
Str =null: boolean =false

Voici comment je l'ai fait:

"1##true".contains( string )

Pour mon cas, c'est généralement 1 ou vrai. J'utilise des hachages comme séparateurs.

Pour obtenir la valeur booléenne d'une chaîne, essayez ceci:

public boolean toBoolean(String s) {
    try {
        return Boolean.parseBoolean(s); // Successfully converted String to boolean
    } catch(Exception e) {
        return null; // There was some error, so return null.
    }
}

S'il y a une erreur, elle renverra null. Exemple:

toBoolean("true"); // Returns true
toBoolean("tr.u;e"); // Returns null

Pourquoi ne pas utiliser une expression régulière?

public static boolean toBoolean( String target )
{
    if( target == null ) return false;
    return target.matches( "(?i:^(1|true|yes|oui|vrai|y)$)" );
}

Nous avons créé la bibliothèque soyuz-to pour simplifier ce problème (convertir X en Y). C'est juste un ensemble de réponses SO pour des questions similaires. Cela peut être étrange d'utiliser la bibliothèque pour un problème aussi simple, mais cela aide vraiment dans de nombreux cas similaires.

import io.thedocs.soyuz.to;

Boolean aBoolean = to.Boolean("true");

Veuillez le vérifier - c'est très simple et a beaucoup d'autres fonctionnalités utiles

Visite http://msdn.microsoft.com/en-us/library/system.boolean.parse.aspx

Cela vous donnera une idée de quoi faire.

Voici ce que j'obtiens de la documentation Java :

Détail de la méthode

parseBoolean

public static boolean parseBoolean(String s)

Analyse l'argument chaîne en tant que booléen. Le booléen renvoyé représente la valeur true si l'argument chaîne n'est pas nullet est égal, en ignorant la casse, à la chaîne "true ".

Paramètres:

s - la chaîne contenant la représentation booléenne à analyser

Retour: le booléen représenté par l'argument chaîne

Depuis: 1.5

vous pouvez directement définir une valeur booléenne équivalente à n'importe quelle chaîne par classe System et y accéder n'importe où.

System.setProperty("n","false");
System.setProperty("y","true");

System.setProperty("yes","true");     
System.setProperty("no","false");

System.out.println(Boolean.getBoolean("n"));   //false
System.out.println(Boolean.getBoolean("y"));   //true   
 System.out.println(Boolean.getBoolean("no"));  //false
System.out.println(Boolean.getBoolean("yes"));  //true