¿Cómo convertir un objeto String en un objeto booleano?

¿Cómo convertir Stringobjeto a Booleanobjeto?

Pruebe (dependiendo del tipo de resultado que desee):

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

Ventaja:

• Booleano: esto no crea nuevas instancias de booleano, por lo que el rendimiento es mejor (y menos recolección de basura). Reutiliza las dos instancias de uno Boolean.TRUEo Boolean.FALSE.
• booleano: no se necesita ninguna instancia, utiliza el tipo primitivo.

La documentación oficial está en el Javadoc .

ACTUALIZADO:

El autoboxing también podría usarse, pero tiene un costo de rendimiento.
Sugiero usarlo solo cuando tenga que lanzarlo usted mismo, no cuando el lanzamiento sea evitable.

Debe tener cuidado al usar Boolean.valueOf (string) o Boolean.parseBoolean (string) . La razón de esto es que los métodos siempre devolverán falso si la Cadena no es igual a "verdadero" (el caso se ignora).

Por ejemplo:

Boolean.valueOf("YES") -> false

Debido a ese comportamiento, recomendaría agregar algún mecanismo para garantizar que la cadena que debe traducirse a un booleano siga un formato específico.

Por ejemplo:

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

Boolean b = Boolean.valueOf(string);

El valor de bes verdadero si la cadena no es nula e igual a true(ignorando mayúsculas y minúsculas).

Además de la excelente respuesta de KLE, también podemos hacer algo más 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");

(inspirado por la respuesta de zlajo ... :-))

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

Bueno, como ahora en enero de 2018, la mejor manera de hacerlo es usar apache BooleanUtils.toBoolean.

Esto convertirá cualquier cadena booleana como booleana, por ejemplo, Y, sí, verdadero, N, no, falso, etc.

Muy práctico!

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

Mi forma de convertir cadenas a booleanas.

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

Resultado:

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

Así es como lo hice:

"1##true".contains( string )

Para mi caso es mayormente 1 o verdadero. Yo uso hashes como divisores.

Para obtener el valor booleano de una cadena, intente esto:

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.
    }
}

Si hay un error, devolverá nulo. Ejemplo:

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

¿Por qué no usar una expresión regular?

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

Creamos la biblioteca soyuz-to para simplificar este problema (convertir X a Y). Es solo un conjunto de respuestas SO para preguntas similares. Puede ser extraño usar la biblioteca para un problema tan simple, pero realmente ayuda en muchos casos similares.

import io.thedocs.soyuz.to;

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

Compruébalo, es muy simple y tiene muchas otras características útiles.

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

Esto te dará una idea de qué hacer.

Esto es lo que obtengo de la documentación de Java :

Detalle del método

parseBoolean

public static boolean parseBoolean(String s)

Analiza el argumento de cadena como booleano. El valor booleano devuelto representa el valor verdadero si el argumento de cadena no nulles y es igual, ignorando mayúsculas y minúsculas, a la cadena " true".

Parámetros:

s - la cadena que contiene la representación booleana a analizar

Devuelve: el booleano representado por el argumento de cadena

Desde: 1.5

puede establecer directamente un valor booleano equivalente a cualquier cadena por clase de sistema y acceder a él desde cualquier lugar.

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