Java Integer.parseInt() Method

The Java parseInt() method is a method of Integer class that belong to java.lang package. The parseInt() method in Java is crucial for converting string representations of numbers into actual integer values. This capability is fundamental in various programming scenarios, such as when numerical data comes in text form-through user input, data files, or external systems-and needs to be used for calculations, comparisons, or as part of the application's logic.

The conversion process is essential for handling numeric data correctly and efficiently, enabling developers to write more flexible, reliable, and powerful Java applications. By providing easy-to-use tools for working with different data types, Java helps bridge the gap between the often text-heavy world of data input/output and the numeric calculations central to software development.

There are the following three variants of parseInt() methods that can be differentiated depending on its parameter.

parseInt (String s)
parseInt (String s, int radix)
parseInt(CharSequence s, int beginText, int endText, int radix)

Purpose of parseInt() Method

The parseInt() method in Java is used to change numbers that are written as text (strings) into actual numbers (integers) that the computer can understand and work with.

For example, if you have the text "149" and you want to add 3 to it, you first need to change "149" into a number. The following Java program demonstrate the same.

Filename: ParseIntExample.java

class ParseIntExample {  se
    public static void main(String[] args) {  
        String str = "149";
        int num = Integer.parseInt(str);
        System.out.println(num + 3); // This will print 152
    }  
}

Output:

By using parseInt(), we can easily turn text into numbers, making it easier to do things like math operations. This method is really helpful when we are dealing with data that comes in as text but we need to use it as numbers, like user input or information from files.

Working of parseInt() Method

The parseInt() method in Java is designed to convert a string into an integer. Here's a step-by-step breakdown of how it works:

Input String: The method starts by taking a string that we want to convert into an integer. This string should ideally represent a numerical value.
Checking the Sign: It looks at the first character of the string to figure out if the number is positive or negative. It is done by checking for a '+' (plus) or '-' (minus) sign.
Ignoring the Sign: If there's a sign, the method notes it but then ignores it for the next steps, focusing only on the numerical part of the string.
Converting Characters to Numbers: The method goes through the string character by character, starting from the left (or right after the sign if there was one). Each numerical character (like '2' or '7') is converted into its integer equivalent (2 or 7).
Handling Invalid Characters: If the method finds a character that isn't a number (like a letter 'a' or a symbol '&'), it stops and throws an error because the string can't be turned into a pure number.
Building the Integer: As it converts each character, the method builds the final integer. It does this by taking each digit, starting from the left, and adding it to the total, adjusting for its position (tens, hundreds, etc.).
Returning the Result: Once all characters have been processed and the total integer value is built, this number is returned. If the initial sign was negative, the method makes sure the final result is negative too.

This process allows the parseInt() method to accurately convert a string representation of a number into an actual integer value, ready to be used for mathematical operations and other purposes where a numerical value is required.

Advantages of the parseInt() Method

The parseInt() method in Java offers several advantages that make it a useful tool for developers. Here are some of the key benefits:

Converts Strings to Integers: It enables the conversion of string representations of numbers into integer values, which is essential for performing arithmetic operations and logical comparisons in programs.
Supports Various Number Bases: With the parseInt(String s, int radix) variant, it can parse strings representing numbers in different bases (from binary to hexadecimal and beyond), providing flexibility in handling numerical data encoded in various numeral systems.
Facilitates Data Parsing: It is particularly useful in scenarios involving data parsing from user inputs, files, or network responses, where numeric data is often received as strings.
Error Handling: It throws a NumberFormatException when the input string cannot be parsed into an integer. This exception mechanism helps in validating input data and implementing robust error handling, ensuring that programs can deal with invalid input gracefully.
Improves Performance: Converting string representations of numbers into their integer equivalents is optimized in Java, making the parseInt() method efficient and suitable for performance-sensitive applications.
Simplifies Code: Using parseInt() simplifies code by abstracting the complexity of manual number parsing. Developers can focus on core logic without worrying about the details of converting string data into integers.
Integral Part of Java's Standard Library: Being part of the standard lang package, it is readily available and does not require any additional libraries or frameworks, ensuring compatibility and ease of use across different Java applications.
Strong Type Safety: By converting strings to integers, it reinforces Java's strong type system, allowing developers to work with well-defined data types and leverage Java's compile-time type checking.

Syntax of parseInt() Method

Following are the declarations of parseInt () method:

public static int parseInt (String s)  
public static int parseInt (String s, int radix)  
public static int parseInt (CharSequence s, int beginIndex, int endIndex, int radix)  

Parameter:

DataType	Parameter	Description	Required/Optional
String	s	It is a String which needs to be converted into the Integer equivalent.	Required
int	radix	The radix to be used while parsing the String	Required
int	beginIndex	The beginning index, inclusive.	Required
int	endIndex	The ending index, exclusive.	Required
CharSequence	s	It is the CharSequence which needs to be converted into the Integer equivalent.	Required

Returns:

Method	Returns
parseInt (String s)	This method returns the integer value which is represented by the argument in decimal equivalent.
parseInt (String s, int radix)	This method returns the integer value which is represented by the string argument in the specified radix.
parseInt (String s, int radix)	This method returns the integer value which is represented by the string argument in the specified radix.

Exceptions:

NullPointerException: If s is null.

IndexOutOfBoundsException: If beginIndex is negative, or if beginIndex is greater than endIndex or if endIndex is greater than s.length ().

NumberFormatException: If the CharSequence does not contain a parsable int in the specified radix, or if radix is either smaller than Character.MIN_RADIX or larger than Character.MAX_RADIX.

Compatibility Version:

Java 1.2 and above:

parseInt (String s)
parseInt (String s, int radix)

Java 9:

parseInt (CharSequence s, int beginText, int endText, int radix)

1. Java Integer parseInt (String s) Method

This method parses the String argument as a signed decimal integer object. The characters in the string must be decimal digits, except that the first character of the string may be an ASCII minus sign '-' to indicate a negative value or an ASCII plus '+' sign to indicate a positive value. It returns the integer value which is represented by the argument in a decimal integer.

Syntax:

Filename: ParseIntExample.java

public class ParseIntExample {
    public static void main(String[] args) {
        String strNumber = "1234"; // String representation of a number
        // Using parseInt(String s) method to convert the string into an integer
        int number = Integer.parseInt(strNumber);
        // Printing the converted integer value
        System.out.println("The string converted to integer is: " + number);
        // Performing an arithmetic operation to demonstrate the conversion
        int sum = number + 100;
        System.out.println("After adding 100 to the converted integer: " + sum);
    }
}

Output:

The string converted to integer is: 1234
After adding 100 to the converted integer: 1334

2. Java Integer parseInt (String s, int radix) Method

This method parses the String argument as a signed decimal integer object in the specified radix by the second argument. The characters in the string must be decimal digits of the specified argument except that the first character may be an ASCII minus sign '-' to indicate a negative value or an ASCII plus sign '+' to indicate a positive value. The resulting integer value is to be returned.

Syntax:

Filename: ParseIntRadixExample.java

public class ParseIntRadixExample {
    public static void main(String[] args) {
        // String representation of numbers in different bases
        String binaryStr = "1010"; // binary (base 2)
        String octalStr = "12";    // octal (base 8)
        String hexStr = "A";       // hexadecimal (base 16)
        // Converting strings into integers using parseInt(String s, int radix)
        int binaryNumber = Integer.parseInt(binaryStr, 2); // Binary to decimal conversion
        int octalNumber = Integer.parseInt(octalStr, 8);   // Octal to decimal conversion
        int hexNumber = Integer.parseInt(hexStr, 16);      // Hexadecimal to decimal conversion
        // Printing the converted integer values
        System.out.println("Binary " + binaryStr + " in decimal is: " + binaryNumber);
        System.out.println("Octal " + octalStr + " in decimal is: " + octalNumber);
        System.out.println("Hexadecimal " + hexStr + " in decimal is: " + hexNumber);
    }
}

Output:

ParseIntRadixExample

3. Java Integer parseInt (CharSequence s, int beginText, int endText, int radix)

This method parses the CharSequence argument as a signed integer in the specified radix argument, beginning at the specified beginIndex and extending to endIndex - 1. This method does not take steps to guard against the CharSequence being mutated while parsing.

Syntax:

public static int parseInt (CharSequence s, int beginIndex, int endIndex, int radix)

Filename: ParseIntCharSequenceExample.java

public class ParseIntCharSequenceExample {
    public static void main(String[] args) {
        CharSequence sequence = "1234ABCD5678"; // Example CharSequence
        int beginIndex = 4; // Start index (inclusive)
        int endIndex = 8; // End index (exclusive)
        int radix = 16; // Hexadecimal base
        // Extracting a substring based on the specified indices
        String subStr = sequence.subSequence(beginIndex, endIndex).toString();
        // Parsing the substring to an integer with the specified radix
        int result = Integer.parseInt(subStr, radix);
        // Printing the result
        System.out.println("The parsed integer is: " + result);
    }
}
} 

Output:

The parsed integer is: 43981

Example 1

Filename: IntegerParseIntExample1.java

public class IntegerParseIntExample1 {
	public static void main(String[] args) {
		int decimalExample = Integer.parseInt("20");
                      int signedPositiveExample = Integer.parseInt("+20");
                      int signedNegativeExample = Integer.parseInt("-20");
        
                  System.out.println("Value = "+decimalExample);
                  System.out.println("Value = "+signedPositiveExample);
                  System.out.println("Value = "+signedNegativeExample);
	      }
   }

Test it Now

Output:

Value = 20
Value = 20
Value = -20

Example 2

Filename: IntegerParseIntExample2.java

public class IntegerParseIntExample2 {  
    public static void main(String[] args) {          
      int a = Integer.parseInt("150", 8);  
             int b = Integer.parseInt("+200", 16);  
             int c = Integer.parseInt("-344", 12);        
             System.out.println("Value = "+a);  
             System.out.println("Value = "+b);  
             System.out.println("Value = "+c);  
    }  
}  

Test it Now

Output:

Value = 104
Value = 512
Value = -484

Example 3

Filename: IntegerParseIntExample3.java

public class IntegerParseIntExample3 {
	public static void main(String[] args) {
		String s="200";  
		int i=Integer.parseInt(s);  
		System.out.println(s+100);//200100 because + is string concatenation operator  
		System.out.println(i+100);//300 because + is binary plus operator  
	}
}

Test it Now

Output:

200100
300

Example 4

Filename: IntegerParseIntExample4.java

public class IntegerParseIntExample4 {
	public static void main(String[] args) {
		String s = "100";	 
	    try
	    {
	      // the String to int conversion happens here
	      int i = Integer.parseInt(s.trim());	 
	      // print out the value after the conversion
	      System.out.println("int i = " + i);
	    }
	    catch (NumberFormatException nfe)
	    {
	      System.out.println("NumberFormatException: " + nfe.getMessage());
	    }
	}
}

Test it Now

Output:

int i = 100

Example 5

Filename: IntegerParseIntExample5.java

public class IntegerParseIntExample5 {
	public static void main(String[] args) {
		String number = "10A";
		int result = Integer.parseInt(number);
		System.out.println(result);
	}
}

Test it Now

Output:

Exception in thread "main" java.lang.NumberFormatException: For input string: "10A"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.base/java.lang.Integer.parseInt(Integer.java:652)
	at java.base/java.lang.Integer.parseInt(Integer.java:770)
	at myPackage.IntegerParseIntExample5.main(IntegerParseIntExample5.java:6)

Overall, the parseInt() method is a powerful utility for processing and manipulating numeric data within Java applications, offering a combination of flexibility, efficiency, and robustness.

Next TopicInteresting-facts-about-null-in-java

← prev next →