String to Integer in Java: How to Convert

Converting a string to an integer in Java means turning text like “42” into the number 42 so you can do math with it. You do this with Integer.parseInt() for a primitive int, or Integer.valueOf() for an Integer object. This article explains both methods, how to handle invalid input, and common pitfalls.

Why Convert Strings to Integers?

In Java, data often arrives as text: from a user typing into a console, a form field in a web app, a CSV file, or a configuration setting. Before you can add, compare, or use that value in arithmetic, you must parse it into a numeric type. The String class stores characters, not numbers, so “123” is not the same as 123. The conversion is a fundamental operation in almost every Java program that handles input.

The Two Main Methods: parseInt() and valueOf()

Java provides two primary ways to convert a string to an integer, both in the java.lang.Integer class. They look similar but return different types.

• Integer.parseInt(String s) – returns a primitive int. This is the most common and fastest method for most use cases.
• Integer.valueOf(String s) – returns an Integer object. It uses a cache for values between -128 and 127, so it can be slightly more efficient if you need an object anyway.

Both methods throw a NumberFormatException if the string does not contain a valid integer. Here is a simple example:

String number = "123";
int primitive = Integer.parseInt(number);  // 123
Integer object = Integer.valueOf(number);  // 123

For most code, parseInt() is the better choice because it avoids unnecessary boxing. Use valueOf() when you specifically need an Integer object, such as when adding to a List<Integer>.

What Input Is Accepted?

The conversion is stricter than you might expect. The string must contain only digits, with an optional leading minus sign for negative numbers. Spaces, plus signs (in most versions), commas, or decimal points will cause an exception.

• Valid: “0”, “-42”, “123456”
• Invalid: ” 123″ (leading space), “12.3” (decimal), “1,000” (comma), “+123” (plus sign, except in some rare cases)

Also, the value must fit within the int range: -2,147,483,648 to 2,147,483,647. Trying to parse “2147483648” (one more than the maximum) throws a NumberFormatException.

Handling Exceptions and Edge Cases

The most common mistake is not catching the NumberFormatException. If your program receives user input, you should always wrap the conversion in a try-catch block or check the input first.

String userInput = "abc";
try {
    int value = Integer.parseInt(userInput);
} catch (NumberFormatException e) {
    System.out.println("Invalid number: " + userInput);
}

Another edge case is the empty string. Integer.parseInt("") throws an exception because there is no digit to parse. Similarly, a string with only a minus sign “-” is invalid. For null input, both methods throw a NullPointerException, so check for null before parsing.

Alternatives for Special Cases

Sometimes you need more flexibility than parseInt() offers. Here are common alternatives:

• Remove non-digit characters: Use replaceAll("[^0-9-]", "") to strip commas, spaces, or currency symbols before parsing. For example, “$1,234” becomes “1234”.
• Parse a decimal string: If the input is “12.5”, use Double.parseDouble() first, then cast to int if you must truncate. But be aware that casting rounds toward zero.
• Use Integer.decode(): This method handles hexadecimal (0x1F), octal (017), and decimal formats. It is useful for parsing numbers from configuration files that may use different bases.
• Use Scanner.nextInt(): If you are reading from a file or console, the Scanner class can parse integers directly, which simplifies code.

Performance and Best Practices

For most applications, the performance difference between parseInt() and valueOf() is negligible. The real cost is in exception handling: throwing and catching an exception is expensive. If you expect invalid input frequently, consider using a regex to pre-validate, or use a library like Apache Commons Lang’s NumberUtils.toInt() which returns a default value instead of throwing.

In modern Java (8+), you can also use OptionalInt with a stream, but that is overkill for simple conversions. Stick with parseInt() for clarity.

Common Mistakes and Misconceptions

One frequent error is assuming that parseInt() will handle whitespace. It does not. You must call trim() on the string first if it comes from a source that might include spaces, like a text file with trailing newlines.

String line = " 42 \n";
int value = Integer.parseInt(line.trim()); // works

Another misconception is that valueOf() is always slower because it creates an object. In fact, for values in the cache range (-128 to 127), it returns a cached instance and is just as fast as parseInt(). For larger values, it creates a new object, but the difference is still tiny.

Finally, remember that Integer.parseInt() only works for base-10 numbers. If you need to parse binary or hex, use the overloaded version with a radix: Integer.parseInt("1010", 2) returns 10.

Frequently Asked Questions

What is the difference between parseInt() and valueOf()?

parseInt() returns a primitive int, while valueOf() returns an Integer object. For most code, use parseInt() unless you need an object for collections or generics.

How do I convert a string to an int without throwing an exception?

You can use a try-catch block to catch NumberFormatException, or use a utility like NumberUtils.toInt() from Apache Commons Lang, which returns a default value (e.g., 0) if the parse fails.

Can I convert a string with commas like “1,000” to an int?

No, not directly. You must first remove the commas with replaceAll(",", "") or use a NumberFormat to parse locale-specific numbers.

Why does Integer.parseInt(” 123″) throw an exception?

Because the string contains a leading space, which is not a valid digit. Call trim() to remove surrounding whitespace before parsing.

What is the maximum value I can parse with Integer.parseInt()?

The maximum is 2,147,483,647, which is Integer.MAX_VALUE. Any larger number will throw a NumberFormatException. For larger values, use Long.parseLong().

Related

• Relationship Vocabulary Words: 50+ Terms Explained
• How to Navigate a Workbook in Excel
• VLOOKUP Override Output: How to Force a Result