Wie konvertiere ich ein String-Objekt in ein Boolesches Objekt?

Wie konvertiere ich StringObjekt zu BooleanObjekt?

Versuchen Sie es (je nachdem, welchen Ergebnistyp Sie möchten):

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

Vorteil:

• Boolean: Dadurch werden keine neuen Instanzen von Boolean erstellt, sodass die Leistung besser ist (und weniger Speicherbereinigung erfolgt). Die beiden Instanzen von entweder Boolean.TRUEoder werden wiederverwendet Boolean.FALSE.
• Boolescher Wert: Es wird keine Instanz benötigt. Sie verwenden den primitiven Typ.

Die offizielle Dokumentation befindet sich im Javadoc .

AKTUALISIERT:

Autoboxing könnte auch verwendet werden, hat aber Leistungskosten.
Ich schlage vor, es nur zu verwenden, wenn Sie sich selbst besetzen müssten, nicht, wenn die Besetzung vermeidbar ist.

Sie müssen vorsichtig sein, wenn Sie Boolean.valueOf (Zeichenfolge) oder Boolean.parseBoolean (Zeichenfolge) verwenden . Der Grund dafür ist, dass die Methoden immer false zurückgeben, wenn der String nicht gleich "true" ist (der Fall wird ignoriert).

Zum Beispiel:

Boolean.valueOf("YES") -> false

Aufgrund dieses Verhaltens würde ich empfehlen, einen Mechanismus hinzuzufügen, um sicherzustellen, dass die Zeichenfolge, die in einen Booleschen Wert übersetzt werden soll, einem bestimmten Format folgt.

Zum Beispiel:

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

Boolean b = Boolean.valueOf(string);

Der Wert von bist true, wenn die Zeichenfolge nicht null und gleich ist true(Groß- und Kleinschreibung ignorieren).

Neben der hervorragenden Antwort von KLE können wir auch etwas flexibler machen:

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

(inspiriert von Zlajos Antwort ... :-))

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

Nun, wie jetzt im Januar 2018, ist der beste Weg, Apache zu verwenden BooleanUtils.toBoolean.

Dadurch werden alle booleschen Zeichenfolgen in boolesche Werte konvertiert, z. B. Y, yes, true, N, no, false usw.

Wirklich praktisch!

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

Meine Art, einen String in einen Booleschen Wert umzuwandeln.

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

Ergebnis:

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

So habe ich es gemacht:

"1##true".contains( string )

Für meinen Fall ist meistens entweder 1 oder wahr. Ich benutze Hashes als Teiler.

Versuchen Sie Folgendes, um den booleschen Wert eines Strings zu erhalten:

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

Wenn ein Fehler auftritt, wird null zurückgegeben. Beispiel:

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

Warum nicht einen regulären Ausdruck verwenden?

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

Wir haben Sojuz-to erstellt Bibliothek erstellt, um dieses Problem zu vereinfachen (X in Y konvertieren). Es ist nur eine Reihe von SO-Antworten auf ähnliche Fragen. Es mag seltsam sein, die Bibliothek für ein so einfaches Problem zu verwenden, aber es hilft in vielen ähnlichen Fällen wirklich.

import io.thedocs.soyuz.to;

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

Bitte überprüfen Sie es - es ist sehr einfach und hat viele andere nützliche Funktionen

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

Dies gibt Ihnen eine Vorstellung davon, was zu tun ist.

Folgendes erhalte ich aus der Java-Dokumentation :

Methodendetail

parseBoolean

public static boolean parseBoolean(String s)

Analysiert das String-Argument als Booleschen Wert. Der zurückgegebene Boolesche Wert stellt den Wert true dar, wenn das Zeichenfolgenargument nicht nullund ohne Berücksichtigung der Groß- und Kleinschreibung der Zeichenfolge " true" entspricht.

Parameter:

s - Der String, der die zu analysierende boolesche Darstellung enthält

Rückgabe: Der durch das Zeichenfolgenargument dargestellte Boolesche Wert

Seit: 1.5

Sie können den booleschen Wert, der einer beliebigen Zeichenfolge nach Systemklasse entspricht, direkt festlegen und überall darauf zugreifen.

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