 # How to Parse Numbers (Convert Text into a Number)

This article will discuss how to convert text and change it into a number. Having the ability to parse text into a number comes useful when accepting numerical input from the user. Some examples include taking an command line argument which is passed as a `String` and obtaining an `int`, taking an input from a `TextField` and obtaining an `int`.

We will discuss the `Integer.parseInt(String)` method and their variants.

## Using Integer.parseInt(String)

The `Integer.parseInt(String)` method can accept a `String` object and return an `int` primitive. The `parseInt(String)` method is a static method of the `Integer` class, so it is not necessary to instantiate an `Integer` object to call the method.

The following is an example of using the `Integer.parseInt(String)` method to convert a `String` to an `int`:

```/**
* ParseInt demonstrates the use of String parsing methods to retrieve
* a number from text.
* @author coobird
*/
public class ParseInt
{
public static void main(String[] args)
{
// String that we want to make an integer
String str = "123";

// Parses the String to obtain an int called number.
int number = Integer.parseInt(str);

// Just to prove we have an int. Increment it.
number++;

// Displays the incremented int to the console.
// It should print out "124"
System.out.println(number);
}
}```

In the example above, the `String` object containing the text `123` is parsed to obtain an `int` called `number`. The `number` variable is incremented and displayed to the console. The result should be `123 + 1` which is `124`. Running the above program, we obtain:

`124`

As expected, `124` is the result produced by the program.

Another `parseInt` method is the overloaded ```Integer.parseInt(String, int)``` method, which specifies the radix of the number being converted. This comes useful when trying to parse an number that is not base 10, such as binary, octal, hexadecimal to name a few. The following is an example parses a `String` containing FF, hexadecimal for 255, which is parsed as a hexidecimal (base 16) :

```/**
* ParseInt2 demonstrates the use of String parsing methods to retrieve
* a number from text containing a hexadecimal.
* @author coobird
*/
public class ParseInt2
{
public static void main(String[] args)
{
// String that we want to make an integer
// FF is hexadecimal for 255.
String str = "FF";

// Parses the String to obtain an int called number, specifying
int number = Integer.parseInt(str, 16);

// Just to prove we have an int. Increment it.
number++;

// Displays the incremented int to the console.
// It should print out "256"
System.out.println(number);
}
}```

As with the first example, a `String` is parsed and an `int` is returned, this time, the `String` is handled as a hexadecimal, so the line `Integer.parseInt("FF", 16)`returns `255`, which is incremented to `256`. When running the program, the output is:

`256`

As expected, the result is `256`.

This second example may come handy when dealing with memory addresses, byte values, or color codes in HTML which are often expressed in hexadecimal.

So far, we've seen examples where the text contains a number in `String` representation. The next section will handle cases when text that can't be parsed is passed into the `parseInt` method.

## Error Handling

When accepting an `String` as an input that we want to convert to a number, we can't assume that the `String` will contain a number that can be parsed, e.g. the `String` may contain words. For example, what would happen if we try to parse a `String` containing the text `one`? We'll try to run the following program to find out:

```/**
* ParseInt3 demonstrates what happens when we try to parse the
* text "one" to a number.
* @author coobird
*/
public class ParseInt3
{
public static void main(String[] args)
{
// String that we want to make an integer
// "one" is obviously not a number (at least in base 10)
String str = "one";

// Parses the String to obtain an int called number.
// What happens?
int number = Integer.parseInt(str);

// Hint: we never reach this line.
System.out.println(number);
}
}```

Running the above program, the following is what is displayed in the console:

```Exception in thread "main" java.lang.NumberFormatException: For input string: "one"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at ParseInt3.main(ParseInt3.java:16)```

The program generated a `NumberFormatException` when attempting to run the `Integer.parseInt(str)` line. We can see that the exception was thrown because the input string was "one", according to the exception message itself. There is a list of situations where a `NumberFormatException` is thrown by the `parseInt(String)` and `parseInt(String, int)` methods on the ```Integer.parseInt(String, int)``` method page.

As an exception is thrown, the program crashes at that point. To prevent this from happening, the exception must be thrown. The following shows the previous program with exception handling by using `try-catch`:

```/**
* ParseInt4 demonstrates what happens when we try to parse the
* text "one" to a number. This version adds a try-catch block for
* exception handling
* @author coobird
*/
public class ParseInt4
{
public static void main(String[] args)
{
// String that we want to make an integer
// "one" is obviously not a number (at least in base 10)
String str = "one";

// Initialize the variable we want to store to.
int number = 0;

// Parses the String to obtain an int called number.
// What happens?
try
{
number = Integer.parseInt(str);
}
catch (NumberFormatException nfe)
{
System.out.println("Could not parse: " + str);
}

// Print out what's in the variable.
System.out.println(number);
}
}```

The output from running the above example was:

```Could not parse: one
0```

This time, rather than the program crashing at runtime like the previous example, the `NumberFormatException` was caught in the `catch` block. This allows for exception handling where we can print out a message to inform the user that the input was not valid. As evidenced by the second line of `0`, we can see that the final line, `System.out.println(number);`, was executed, so the program didn't crash like the last example.

## Other parse Methods

There are other parse methods in the Java API aside from `Integer.parseInt`. The following is a quick list:

The above methods are static method like the `Integer.parseInt(String)` method, so they work in a similar fashion, where the input is a `String` and the output is a primitive type of the wrapper class of the type (e.g. `Boolean.parseBoolean(String)` returns a primitive `boolean` type.