Jak przekonwertować obiekt String na obiekt boolowski?

Jak przekonwertować Stringobiekt na Booleanobiekt?

Spróbuj (w zależności od rodzaju pożądanego wyniku):

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

Korzyść:

• Boolean: nie tworzy to nowych instancji Boolean, więc wydajność jest lepsza (i mniej wyrzucania elementów bezużytecznych). Ponownie wykorzystuje dwa wystąpienia jednego Boolean.TRUElub Boolean.FALSE.
• boolean: nie jest wymagana żadna instancja, używasz typu pierwotnego.

Oficjalna dokumentacja znajduje się w Javadoc .

AKTUALIZACJA:

Można również użyć automatycznego porównywania, ale wiąże się to z obniżeniem wydajności.
Sugeruję, aby używać go tylko wtedy, gdy będziesz musiał rzucić się, a nie wtedy, gdy można tego uniknąć.

Należy zachować ostrożność podczas korzystania z Boolean.valueOf (ciąg) lub Boolean.parseBoolean (ciąg) . Powodem tego jest to, że metody zawsze zwracają wartość false, jeśli ciąg znaków nie jest równy „true” (wielkość liter jest ignorowana).

Na przykład:

Boolean.valueOf("YES") -> false

Z powodu takiego zachowania zaleciłbym dodanie mechanizmu zapewniającego, że ciąg znaków, który powinien zostać przetłumaczony na wartość logiczną, ma określony format.

Na przykład:

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

Boolean b = Boolean.valueOf(string);

Wartość b true, jeśli ciąg znaków nie jest pusty i równy true(ignorując liter).

Oprócz doskonałej odpowiedzi KLE możemy również uczynić coś bardziej elastycznym:

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

(zainspirowany odpowiedzią zlajo ... :-))

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

Cóż, podobnie jak teraz w styczniu 2018 roku, najlepszym sposobem na to jest użycie apache BooleanUtils.toBoolean.

Spowoduje to konwersję dowolnego ciągu typu logicznego na boolean, np. Y, tak, prawda, N, nie, fałsz itp.

Naprawdę przydatne!

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

Mój sposób na konwersję łańcucha znaków na wartość logiczną.

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

Wynik:

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

Oto jak to zrobiłem:

"1##true".contains( string )

W moim przypadku jest to albo 1 albo prawda. Używam skrótów jako dzielników.

Aby uzyskać wartość boolowską ciągu, spróbuj tego:

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

Jeśli wystąpi błąd, zwróci wartość null. Przykład:

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

Dlaczego nie użyć wyrażenia regularnego?

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

Stworzyliśmy bibliotekę Soyuz-To, aby uprościć ten problem (przekonwertuj X na Y). To tylko zestaw SO odpowiedzi na podobne pytania. Używanie biblioteki w przypadku tak prostego problemu może być dziwne, ale naprawdę pomaga w wielu podobnych przypadkach.

import io.thedocs.soyuz.to;

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

Sprawdź to - jest bardzo prosty i ma wiele innych przydatnych funkcji

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

To da ci wyobrażenie o tym, co robić.

Oto, co otrzymuję z dokumentacji Java :

Szczegół metody

parseBoolean

public static boolean parseBoolean(String s)

Analizuje argument ciągu jako wartość logiczną. Zwracana wartość logiczna reprezentuje wartość true, jeśli argument ciągu nie nulljest i jest równy, ignorując wielkość liter, ciągowi „ true”.

Parametry:

s - ciąg zawierający reprezentację logiczną, którą należy przeanalizować

Zwraca: wartość logiczna reprezentowana przez argument ciągu

Od: 1.5

możesz bezpośrednio ustawić wartość logiczną równoważną dowolnemu ciągowi według klasy System i uzyskać do niego dostęp w dowolnym miejscu ..

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