Convert String to Int Using Encapsulation

Last updated: January 5, 2024

Written by: Deboshree Banerjee

Reviewed by: Vinicius Peixoto

Java String

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

In this tutorial, we’ll explore different ways to encapsulate a method to convert String input to an int in Java while handling exceptions elegantly.

2. Problem Statement

The Integer.parseInt() method is commonly used to perform the conversion of a String to an int, but it throws an exception if the input is not a number.

Handling this exception using a try-catch block can make the code repetitive and unreadable:

try {
    return Integer.parseInt(input);
} catch (NumberFormatException e) {
    logger.error("Encountered an exception while converting string to int");
}

Instead, we can encapsulate the conversion in a method that handles the exception and returns a suitable value in case of an error. This also provides ease of modification or update of the error-handling logic in the future.

Now let’s explore some of the ways to achieve this encapsulation.

3. Converting via Encapsulation

In this section, we’ll explore a few approaches to encapsulate the String to int conversion logic. We can use Optional to encapsulate the Integer value that results from the String-to-int conversion or to indicate that the conversion failed:

3.1. Using Integer.parseInt()

We can use the parseInt() method provided by the Integer class to convert a String value to an int. A try-catch block can handle all exceptions, mainly NumberFormatException, and return a default value in the case of an error:

Optional<Integer> convertStringToIntUsingIntegerParseInt(String input) {
    try {
        return Optional.of(Integer.parseInt(input));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

This method uses autoboxing to convert the primitive type int to its corresponding wrapper class, Integer.

3.2. Using Integer.valueOf()

In Java, the valueOf() method is a static method that’s available on certain classes, including String, Integer, Double, and others. It’s used to convert a String representation of a value into an object of the corresponding class.

It internally calls parseInt() if used on an Integer wrapper class. We can use this method to achieve the conversion and handle the error in a single encapsulated method:

Optional<Integer> convertStringToIntUsingIntegerValueOf(String input) {
    try {
        return Optional.of(Integer.valueOf(input));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

3.3. Using Integer.decode()

Integer.decode() works similarly to Integer.valueOf(), but can also accept some other number representations like decimal, hexadecimal, and octal numbers:

Optional<Integer> convertStringToIntUsingIntegerDecode(String input) {
    try {
        return Optional.of(Integer.decode(input));
    } catch (Exception e) {
        return Optional.empty();
    }
}

3.4. Using Apache Commons’ NumberUtils

We can use the Integer conversion method provided by the NumberUtils class in the Apache Commons Lang 3 library. To use the library, we can add a dependency in our pom.xml file:

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

It accepts a default value to return in case the conversion fails. We can use the toInt() method to achieve our encapsulation:

int convertIntToStringUsingNumberUtils(String input, Integer defaultValue) {
    return NumberUtils.toInt(input, defaultValue);
}

4. Conclusion

In this article, we looked at various approaches for converting a String to an int, handling errors, and dealing with situations where default values need to be returned or errors need to be logged.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.