Comment vérifier si la valeur de chaîne est de type booléen en Java?

return "true".equals(value) || "false".equals(value);

Apache commons-lang3 a BooleanUtils avec une méthode toBooleanObject:

BooleanUtils.toBooleanObject(String str)

// where: 

BooleanUtils.toBooleanObject(null)    = null
BooleanUtils.toBooleanObject("true")  = Boolean.TRUE
BooleanUtils.toBooleanObject("false") = Boolean.FALSE
BooleanUtils.toBooleanObject("on")    = Boolean.TRUE
BooleanUtils.toBooleanObject("ON")    = Boolean.TRUE
BooleanUtils.toBooleanObject("off")   = Boolean.FALSE
BooleanUtils.toBooleanObject("oFf")   = Boolean.FALSE
BooleanUtils.toBooleanObject("blue")  = null

if ("true".equals(value) || "false".equals(value)) {
  // do something
} else {
  // do something else
}

Les méthodes que vous appelez sur la classe Boolean ne vérifient pas si la chaîne contient une valeur booléenne VALIDE, mais elles renvoient la valeur booléenne qui représente le contenu de la chaîne: mettez "true" dans la chaîne, elles retournent true, Mettez "false" dans la chaîne, elles retournent false.

Vous pouvez sûrement utiliser ces méthodes, cependant, pour vérifier les valeurs booléennes valides, car je m'attendrais à ce qu'elles lancent une exception si la chaîne contient "hello" ou quelque chose qui n'est pas booléen.

Envelopper cela dans une méthode ContainsBoolString et vous allez.

Modifier
En passant, en C#, il existe des méthodes comme bool Int32.TryParse(string x, out int i) qui vérifient si le contenu peut être analysé, puis renvoient le résultat analysé.

int i;
if (Int32.TryParse("Hello", out i))
  // Hello is an int and its value is in i
else
  // Hello is not an int

Les repères indiquent qu'ils sont beaucoup plus rapides que les suivants:

int i;
try
{
   i = Int32.Parse("Hello");
   // Hello is an int and its value is in i
}
catch
{
   // Hello is not an int
}

Peut-être Existe-t-il des méthodes similaires en Java? Cela fait un moment que J'ai utilisé Java...

Peut aussi le faire par regex:

Pattern queryLangPattern = Pattern.compile("true|false", Pattern.CASE_INSENSITIVE);
Matcher matcher = queryLangPattern.matcher(booleanParam);
return matcher.matches();

En fait, la vérification D'un type booléen dans une chaîne (qui est un type) est impossible. Fondamentalement, vous demandez comment faire une "comparaison de chaîne".

Comme d'autres l'ont déclaré. Vous devez définir quand vous voulez retourner "true" ou "false" (dans quelles conditions). Voulez-vous qu'il soit sensible à la casse? Si la valeur est null?

Je pense booléen.valueOf() est votre ami, javadoc dit:

Renvoie un Booléen avec une valeur représentée par la Chaîne spécifiée. Le booléen retourné représente la valeur true si l'argument string n'est pas null et est égal, en ignorant la casse, à la chaîne "true".

Exemple: Booléen.valueOf ("True") renvoie true.
Exemple: Boolean.valueOf("oui") renvoie la valeur false.

String value = "True";
boolean result = value.equalsIgnoreCase("true") ? true : false;

Oui, mais, n'avez-vous pas analyser "faux"? Si vous analysez "true", ils retournent true.

Peut-être y a-t-il un malentendu: les méthodes ne testent pas, si le contenu de la chaîne représente une valeur booléenne, elles évaluent le contenu de la chaîne en booléen.

Eh bien pour cela, jetez également un oeil à org.Apache.commun.lang.BooleanUtils#toBoolean (java.lang.String), ainsi que de nombreuses autres fonctions utiles.

return value.equals("false") || value.equals("true");

Quelque chose que vous devriez également prendre en considération est le boîtier de caractères...

Au Lieu de:

return value.equals("false") || value.equals("true");

Faites ceci:

return value.equalsIgnoreCase("false") || value.equalsIgnoreCase("true");

Je vous suggère de jeter un oeil aux documents Java pour ces méthodes. Il semble que vous les utilisez correctement. Ces méthodes ne vous diront pas si la chaîne est une valeur booléenne VALIDE, mais elles renvoient plutôt un booléen, défini sur true ou false, basé sur la chaîne que vous transmettez, "true" ou "false".

Http://www.j2ee.me/javase/6/docs/api/java/lang/Boolean.html

Voici une méthode que vous pouvez utiliser pour vérifier si une valeur est un booléen:

boolean isBoolean(String value) {
    return value != null && Arrays.stream(new String[]{"true", "false", "1", "0"})
            .anyMatch(b -> b.equalsIgnoreCase(value));
}

Exemples de son utilisation:

System.out.println(isBoolean(null)); //false
System.out.println(isBoolean("")); //false
System.out.println(isBoolean("true")); //true
System.out.println(isBoolean("fALsE")); //true
System.out.println(isBoolean("asdf")); //false
System.out.println(isBoolean("01truefalse")); //false

Voir Oracle docs

public static boolean parseBoolean(String s) {
        return ((s != null) && s.equalsIgnoreCase("true"));
    }

  function isBooleanString(val) {
    if (val === "true" || val === "false"){
      return true
    } else {
      return false
    }
  }
isBooleanString("true") // true
isBooleanString("false") // true

isBooleanString("blabla") // false