How to convert String to int in Java

In this article we are going to discuss converting String to int (primitive type) and Object type (wrapper) Integer. There are many ways to do it in Java.

How to convert String to Int in Java

Here is a couple of ways to convert string to int, Java lets do it using parseInt() and valueOf() methods.

Convert Java string to int using Integer.parseInt(String)

parseInt is a static method of the Integer class that returns an integer object representing the specified String parameter.

Syntax:


public static int parseInt(String str) throws NumberFormatException


public static int parseInt(String str, int radix) throws NumberFormatException

Where str is a String you need to convert and radix is a base of the parsed number

Converting String to Integer, Java example using parseInt()


public class Demo2 {
//  convert string to int java

   public static void main(String args[]) {
       String str = "111";

       int num1 = Integer.parseInt(str);
       System.out.println("parseInt of the String = "
               + num1);

       int num2 = Integer.parseInt(str, 2);//binary number
       System.out.println("parseInt of the String with radix parameter = " + num2);
   }
}

The output is:

parseInt of the String = 111
parseInt of the String with radix parameter =  7

Here we’ve got 111 in the first variant and 7 for the second. 7 is a decimal form of binary 111.

Convert using Integer.valueOf(String)

Integer.valueOf(String s) is a Java method of Integer class. It returns an Integer decimal interpretation of a String object so it is used to convert String to Integer.

Syntax:


public static Integer valueOf(String str)

Example Java String to Integer using valueOf method:
public class Demo2 {
//  java convert string to int using valueOf()
       String myString = "578";
       int parNum = Integer.valueOf(myString);
       System.out.println("Integer from String using valueOf() = " + parNum);
      
   }
}

Output:

Integer from String using valueOf() = 578

Convert using Integer.decode Method

The Integer.decode method is a versatile tool for converting strings to integers. Unlike Integer.parseInt, which requires the programmer to explicitly specify the numeric base, decode can automatically interpret the base of the input string. It supports:

Decimal: Standard base-10 integers.
Hexadecimal: Strings prefixed with 0x or #.
Octal: Strings prefixed with 0.

How `Integer.decode` Handles Different Bases

The decode method uses the prefix of the string to determine the numeric base:

No prefix: Interpreted as a decimal number (base-10).
Prefix 0x or #: Interpreted as a hexadecimal number (base-16).
Prefix 0: Interpreted as an octal number (base-8).

Examples:

public class IntegerDecodeExample {
    public static void main(String[] args) {
        String decimalString = "123";
        String hexString = "0x7B";
        String octalString = "0173";

        int decimalValue = Integer.decode(decimalString);
        int hexValue = Integer.decode(hexString);
        int octalValue = Integer.decode(octalString);

        System.out.println("Decimal: " + decimalValue); // Output: 123
        System.out.println("Hexadecimal: " + hexValue); // Output: 123
        System.out.println("Octal: " + octalValue); // Output: 123
    }
}

Handling Exceptions Specific to `Integer.decode`

While Integer.decode is robust, improper inputs can lead to exceptions. Key exceptions include:

NumberFormatException: Thrown when the input string is not a valid number (e.g., "abc").
NullPointerException: Thrown when the input string is null.

Example with Exception Handling:

public class DecodeExceptionExample {
    public static void main(String[] args) {
        String invalidString = "xyz";
        String nullString = null;

        try {
            int value = Integer.decode(invalidString);
            System.out.println("Value: " + value);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number format: " + e.getMessage());
        }

        try {
            int value = Integer.decode(nullString);
            System.out.println("Value: " + value);
        } catch (NullPointerException e) {
            System.out.println("Null input: " + e.getMessage());
        }
    }
}

When to Use `Integer.decode`

The decode method is particularly useful when working with inputs from external sources (e.g., configuration files or user inputs) that might be in various numeric formats. Its ability to handle multiple bases automatically simplifies code and reduces errors.

To reinforce what you learned, we suggest you watch a video lesson from our Java Course

Choosing Between `Integer` and `int` in Java

Java provides two options for representing integer values: int (a primitive type) and Integer (a wrapper class). Choosing between the two depends on several factors:

Performance: int is more memory-efficient and faster because it is a primitive type and does not involve object overhead.
Nullability: Integer can store null values, making it useful in situations where null represents an uninitialized or missing value.
Collections: Integer is necessary when working with generic collections, such as List<Integer>, because primitives cannot be used as type parameters.

Using `Integer` with Databases and Collections

In database contexts, Integer is often used because:

It allows nullable fields to represent missing or undefined values from the database.
Frameworks like Hibernate and JPA map SQL INTEGER types to Java Integer, ensuring compatibility.

When working with collections, such as Map<Integer, String>, Integer is required since collections work with objects rather than primitive types.

Caching Behavior of `Integer` Objects

Java caches Integer objects for values in the range of -128 to 127. This means that within this range, Integer objects are reused, which can affect equality checks.

Example:

Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true

Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false

When comparing Integer objects, use .equals() instead of == to ensure correct equality checks, especially for values outside the cached range.

Exception Handling for `NumberFormatException`

Attempting to convert a non-numeric string to an integer using Integer.parseInt() or Integer.valueOf() can throw a NumberFormatException. To ensure robustness, wrap the conversion logic in a try-catch block.

Example:

public class NumberFormatExample {
    public static void main(String[] args) {
        String input = "123abc";

        try {
            int value = Integer.parseInt(input);
            System.out.println("Converted value: " + value);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number format: " + input);
        }
    }
}

Handling Integer Overflow Issues

When converting very large strings, integer overflow can occur if the value exceeds Integer.MAX_VALUE or is less than Integer.MIN_VALUE. To handle this, consider the following:

Example:

public class OverflowExample {
    public static void main(String[] args) {
        String largeNumber = "2147483648"; // Exceeds Integer.MAX_VALUE

        try {
            int value = Integer.parseInt(largeNumber);
            System.out.println("Converted value: " + value);
        } catch (NumberFormatException e) {
            System.out.println("Overflow detected: " + largeNumber);
        }
    }
}

Real-World Examples of Exception Handling

In real-world applications, handling invalid inputs is critical. Below is an example of validating user input:

import java.util.Scanner;

public class RealWorldExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter an integer: ");
        String input = scanner.nextLine();

        try {
            int value = Integer.parseInt(input);
            System.out.println("You entered: " + value);
        } catch (NumberFormatException e) {
            System.out.println("Invalid input. Please enter a valid integer.");
        }
    }
}

How to convert String to int in Java