How to convert String object to Boolean Object?

Boosting performance

If your application demands the speed of Quicksilver, avoid autoboxing by using boolean primitives:

// true for Quicksilver's speed, false otherwise
boolean boolPrimitive = Boolean.parseBoolean("true"); // true


Here, Boolean.parseBoolean(String) sends true for "true" without caring about the case (very polite indeed), and false otherwise.

Tackling the alternatives

If you're dealing with the Infinity Stones of Boolean i.e. "yes" or "1", consider the mighty Apache Commons Lang:

// Is Vision still alive?
boolean isTrue = StringUtils.equalsAnyIgnoreCase("yes", "true", "y", "1");
Boolean customBool = Boolean.valueOf(isTrue);


Defeating unexpected exceptions

Your code can sometimes encounter strings stronger than Thanos, that are not valid boolean values. You need to implement error handling:

try {
    // Thanos snap 
    Boolean bool = Boolean.valueOf(myInputString);
} catch (IllegalArgumentException e) {
    // Oh-oh, someone survived Thanos snap 
}


Remember, Boolean.valueOf is like Doctor Strange's Time Stone– it doesn't throw any exception but defaults to Boolean.FALSE on invalid inputs like "maybe".

Adding flexibility to your code

Let's see what to do when your boolean values are more flexible than Mister Fantastic.

Alternative string representations

If your application uses "yes"/"no" or "on"/"off" instead of "true"/"false", you might need to define a method like this to convert these to Booleans:

public Boolean convertToBoolean(String str) {
	// The 'yes' or 'on' switch has been flicked, it's a party!
    if ("yes".equalsIgnoreCase(str) || "on".equalsIgnoreCase(str)) {
        return Boolean.TRUE;
    } 
    // Oh no, the 'no' or 'off' switch has been hit, party's over!
    else if ("no".equalsIgnoreCase(str) || "off".equalsIgnoreCase(str)) {
        return Boolean.FALSE;
    }
    // Panic mode... More coffee required...
    throw new IllegalArgumentException("Invalid boolean value");
}


Explicit false checks

In very critical situations, it's necessary to explicitly check for false values to avoid any confusion:

boolean isExplicitlyFalse = "false".equalsIgnoreCase(stringValue);
// True if not explicitly false and vice versa, like Schrödinger's cat 
Boolean result = isExplicitlyFalse ? Boolean.FALSE : Boolean.TRUE;


Bulletproofing your code

Let's talk about how to achieve a Black Panther level of defense for your code with input validation and error handling.

Validate input

Before converting the string, make sure it is actually a valid boolean:

String input = myInputString.trim().toLowerCase();
if (!input.matches("true|false")) {
    // It's not really yes or no... so... why are we here?
}
Boolean myBool = Boolean.valueOf(input);


Gracefully managing edge cases

Null strings can be well managed without initiating a civil war inside your JVM:

Boolean convertSafely(String str) {
    if (str == null) { 
        return Boolean.FALSE; // Null... so it's false, like an empty cup of coffee ☕
    }
    return Boolean.valueOf(str); // Not null... so it's true, like coffee is awesome ☕
}


Handling large volume conversions

When it's like you're running a Rescue Mission for millions of string citizens, keep these in mind:

• Use static methods to make it faster than a Quinjet.
• Repeated try-catch blocks can be worse than a horde of Outriders. Avoid them to prevent performance degradation.