Course – LS – All
announcement - icon

Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

1. Overview

In this tutorial, we’ll learn how to convert between a boolean and an int value. First, we’ll look at how Java handles these two primitive data types; then, we’ll explore multiple approaches to facilitate conversions between a boolean and an int.

2. Data Types

In Java, an integer can be represented by the int primitive data type or the Integer wrapper class. The primitive data type is a 32-bit signed integer represented by the Two’s Complement encoding method. The Integer class serves as a wrapper that allows you to perform unsigned integer operations, as well as to treat integer (primitive) values as objects to work with Generics.

On the other hand, boolean values don’t have a specific size in memory, but it defaults to the Operating System and Java Virtual Machine (JVM). Similarly, like all primitive data types in Java, boolean has the Boolean wrapper class that allows boolean values to behave like objects.

We can leverage the primitive value and the wrapper class of both data types (boolean and int) to perform the data conversion. Assuming that the true and false boolean values represent 1 and 0, respectively, we have multiple approaches to make a conversion.

3. Primitive boolean to int

To convert a primitive boolean value into an int, we evaluate the condition of the expression to determine the integer we want to return:

public int booleanPrimitiveToInt(boolean foo) {
    int bar = 0;
    if (foo) {
        bar = 1;
    }
    return bar;
}

We can simplify this function by using the ternary operator:

public int booleanPrimitiveToIntTernary(boolean foo) {
    return (foo) ? 1 : 0;
}

This approach uses primitive data types (boolean and int) to make the conversion. As a result, we obtain 1 when the boolean expression is true. Otherwise, the method returns 0.

4. Wrapper Class

Using the Boolean wrapper class, we have a couple of approaches to do the conversion:

  • We can leverage the static methods from the Boolean class.
  • We can call the methods directly from the Boolean object.

4.1. Static Methods

The Boolean class has a compare method that we can use as follows:

public static int booleanObjectToInt(boolean foo) {
    return Boolean.compare(foo, false);
}

Recall that the static compare method returns if both arguments have the same value. In other words, when foo is false, the comparison will result in 0. Otherwise, the function returns when the first argument is true and the second argument is false.

Similarly, we can use the same static method, changing the second argument to true:

public static int booleanObjectToIntInverse(boolean foo) { 
    return Boolean.compare(foo, true) + 1;
}

This time, if foo is true, the compare method evaluates two arguments of the same value, which results in 0. However, adding 1 to the result will return the expected integer value from a truthy boolean variable.

4.2. Boolean Class Object

The Boolean class object has functions such as compareTo that we can use:

public static int booleanObjectMethodToInt(Boolean foo) {
    return foo.compareTo(false);
}

Using the method booleanObjectMethodToInt, we can convert a boolean value to an integer the same way we did with the static method. Similarly, you can apply the reversed version by changing the argument to true and adding 1 to the result.

5. Apache Commons

Apache Commons is a popular open-source library for Java that provides utility class, such as BooleanUtils. We can add the library as a dependency in Maven as follows:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

Once the library is in our pom.xml file, we can use the BooleanUtils class to convert boolean values to integer:

public static int booleanUtilsToInt(Boolean foo) {
    return BooleanUtils.toInteger(foo);
}

Like the example method booleanPrimitiveToIntTernary, internally, the toInteger method performs the same ternary operator to make the conversion.

6. Converting int to boolean

Having explored multiple techniques for converting boolean values to int values, let’s now shift our focus to the reverse process: converting an int value to a boolean.

First, we’ll follow this rule to perform the int to boolean conversion:

  • true – The int value is 1
  • false – The int value is 0
  • Throwing an exception if the int value is neither 1 nor 0

6.1. Using if or if-else Statements

To achieve the conversion, we can use if/if-else statements, for example:

boolean intToBooleanWithThrowing(int theInt) {
    if (theInt == 1) {
        return true;
    }
    if (theInt == 0) {
        return false;
    }
    throw new IllegalArgumentException("Only 0 or 1 is allowed.");
}

6.2. Using the BooleanUtils.toBoolean() method

The BooleanUtils class from the Apache Commons Lang3 library also provides the BooleanUtils.toBoolean(int value, int trueValue, int falseValue) method to convert an int value to a boolean.

This method has three arguments:

  • value – The int value to be converted
  • trueValue – If value equals trueValue, the method returns true
  • falseValue – If value equals falseValue, the method returns false

Further, if value doesn’t equal either trueValue or falseValue, an IllegalArgumentException will be thrown:

public static boolean toBoolean(final int value, final int trueValue, final int falseValue) {
    if (value == trueValue) {
        return true;
    } else if (value == falseValue) {
        return false;
    } else {
        throw new IllegalArgumentException("The Integer did not match either specified value");
    }
}

Next, let’s demonstrate how to use this method through a unit test:

int trueValue = 1;
int falseValue = 0;
 
assertTrue(BooleanUtils.toBoolean(1, trueValue, falseValue));
assertFalse(BooleanUtils.toBoolean(0, trueValue, falseValue));
assertThrows(IllegalArgumentException.class, () -> BooleanUtils.toBoolean(42, trueValue, falseValue));
assertThrows(IllegalArgumentException.class, () -> BooleanUtils.toBoolean(-42, trueValue, falseValue));

6.3. Other Conversion Rules

Sometimes, we may need to implement different conversion rules, for example:

  • true – If the int value is positive, otherwise false
  • true – If the int value is 1, otherwise false
  • true – If the int value is non-zero, otherwise false

A common way to implement these conversions is using boolean expressions.

For simplicity, let’s assume that we want to convert an integer to true if it’s positive. Otherwise, we’ll convert it to false.

Then, the boolean expression “theInt > 0” does the job:

boolean intToBoolean(int theInt) {
    return theInt > 0;
}

Additionally, the BooleanUtils class provides another toBoolean(int value) method to convert an int value to a boolean. This method accepts only one int argument.

Similar to our intToBoolean() implementation, toBoolean(int value) also uses a boolean expression. The method returns false if the int value is zero. Conversely, it returns true for any non-zero value:

public static boolean toBoolean(final int value) {
    return value != 0;
}

7. Conclusion

In this tutorial, we’ve learned how to convert a boolean into an integer value. Assuming that true translates to and false translates to 0, we explored different implementations to achieve this conversion. Additionally, we discussed how to convert an integer value to a boolean.

As always, the complete code samples for this article can be found over on GitHub.

Course – LS – All
announcement - icon

Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

res – REST with Spring (eBook) (everywhere)
2 Comments
Oldest
Newest
Inline Feedbacks
View all comments
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.