For input string ошибка java

Error Message:
Exception in thread "main" java.lang.NumberFormatException: For input string: "Ace of Clubs"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580)
    at java.lang.Integer.parseInt(Integer.java:615)
    at set07102.Cards.main(Cards.java:68)
C:UsersqasimAppDataLocalNetBeansCache8.1executor-snippetsrun.xml:53: Java returned: 1

means:

There was an error. We try to give you as much information as possible
It was an Exception in main thread. It's called NumberFormatException and has occurred for input "Ace of Clubs".
at line 65th of NumberFormatException.java which is a constructor,
which was invoked from Integer.parseInt() which is in file Integer.java in line 580,
which was invoked from Integer.parseInt() which is in file Integer.java in line 615,
which was invoked from method main in file Cards.java in line 68.

It has resulted in exit code 1

In other words, you tried to parse "Ace of Clubs" to an int what Java can’t do with method Integer.parseInt. Java has provided beautiful stacktrace which tells you exactly what the problem is. The tool you’re looking for is debugger and using breakpoints will allow you to inspect the state of you application at the chosen moment.

The solution might be the following logic in case you want to use parsing:

if (cards[index].startsWith("Ace")) 
    value = 1;
else if (cards[index].startsWith("King"))
    value = 12;
else if (cards[index].startsWith("Queen"))
    value = 11;
...
else {
    try {
        Integer.parseInt(string.substring(0, cards[index].indexOf(" "))); 
    } catch (NumberFormatException e){
        //something went wrong
    }
}

What is an Exception in Java?

An exception is an event, which occurs during the execution of a
program, that disrupts the normal flow of the program’s instructions.

-Documentation

Constructors and usage in Integer#parseInt

static NumberFormatException forInputString(String s) {
    return new NumberFormatException("For input string: "" + s + """);
}

public NumberFormatException (String s) {
    super (s);
}

They are important for understanding how to read the stacktrace. Look how the NumberFormatException is thrown from Integer#parseInt:

if (s == null) {
    throw new NumberFormatException("null");
}

or later if the format of the input String s is not parsable:

throw NumberFormatException.forInputString(s); 

What is a NumberFormatException?

Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.

-Documentation

NumberFormatException extends IllegalArgumentException. It tells us that it’s more specialized IllegalArgumentException. Indeed, it’s used for highlighting that although, the argument type was correct (String) the content of the String wasn’t numeric (a,b,c,d,e,f are considered digits in HEX and are legal when needed).

How do I fix it?
Well, don’t fix the fact that it’s thrown. It’s good that it’s thrown. There are some things you need to consider:

1. Can I read the stacktrace?
2. Is the String which causes an Exception a null?
3. Does it look like a number?
4. Is it ‘my string’ or user’s input?
5. to be continued

Ad. 1.

The first line of a message is an information that the Exception occurred and the input String which caused the problem. The String always follows : and is quoted ("some text"). Then you become interested in reading the stacktrace from the end, as the first few lines are usually NumberFormatException‘s constructor, parsing method etc. Then at the end, there is your method in which you made a bug. It will be pointed out in which file it was called and in which method. Even a line will be attached. You’ll see. The example of how to read the stacktrace is above.

Ad. 2.

When you see, that instead of "For input string:" and the input, there is a null (not "null") it means, that you tried to pass the null reference to a number. If you actually want to treat is as 0 or any other number, you might be interested in my another post on StackOverflow. It’s available here.

The description of solving unexpected nulls is well described on StackOverflow thread What is a NullPointerException and how can I fix it?.

Ad. 3.

If the String that follows the : and is quoted looks like a number in your opinion, there might be a character which your system don’t decode or an unseen white space. Obviously " 6" can’t be parsed as well as "123 " can’t. It’s because of the spaces. But it can occure, that the String will look like "6" but actually it’s length will be larger than the number of digits you can see.

In this case I suggest using the debugger or at least System.out.println and print the length of the String you’re trying to parse. If it shows more than the number of digits, try passing stringToParse.trim() to the parsing method. If it won’t work, copy the whole string after the : and decode it using online decoder. It’ll give you codes of all characters.

There is also one case which I have found recently on StackOverflow, that you might see, that the input looks like a number e.g. "1.86" and it only contains those 4 characters but the error still exists. Remember, one can only parse integers with #Integer#parseInt#. For parsing decimal numbers, one should use Double#parseDouble.

Another situation is, when the number has many digits. It might be, that it’s too large or too small to fit int or long. You might want to try new BigDecimal(<str>).

Ad. 4.

Finally we come to the place in which we agree, that we can’t avoid situations when it’s user typing «abc» as a numeric string. Why? Because he can. In a lucky case, it’s because he’s a tester or simply a geek. In a bad case it’s the attacker.

What can I do now? Well, Java gives us try-catch you can do the following:

try {
    i = Integer.parseInt(myString);
} catch (NumberFormatException e) {
    e.printStackTrace();
    //somehow workout the issue with an improper input. It's up to your business logic.
}

The NumberFormatException is one of the most common errors in Java applications, along with NullPointerException. This error comes when you try to convert a String into numeric data types e.g., int, float, double, long, short, char, or byte. The data type conversion methods like Integer.parseInt(), Float.parseFloat(), Double.parseDoulbe(), and Long.parseLong() throws NumberFormatException to signal that input String is not valid numeric value. 

Even though the root cause is always something that cannot be converted into a number, there are many reasons and inputs due to which NumberFormatException occurs in Java applications.

Integer.parseInt(null);
Exception in thread "main" java.lang.NumberFormatException: null
at java.lang.Integer.parseInt(Integer.java:454)
at java.lang.Integer.parseInt(Integer.java:527)

Integer.parseInt("");
Exception in thread "main" java.lang.NumberFormatException: For input string: ""
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Integer.parseInt(Integer.java:504)
at java.lang.Integer.parseInt(Integer.java:527)

Short.parseShort("A1");
Exception in thread "main" java.lang.NumberFormatException: 
For input string: "A1"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Integer.parseInt(Integer.java:492)
at java.lang.Short.parseShort(Short.java:117)
at java.lang.Short.parseShort(Short.java:143)

Long.parseLong(" 123");
Exception in thread "main" java.lang.NumberFormatException: 
For input string: " 123"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Long.parseLong(Long.java:430)
at java.lang.Long.parseLong(Long.java:483)

Long.parseLong("1001 ");
Exception in thread "main" java.lang.NumberFormatException: 
For input string: "1001 "
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Long.parseLong(Long.java:441)
at java.lang.Long.parseLong(Long.java:483)

Float.parseFloat("null");
Exception in thread "main" java.lang.NumberFormatException: 
For input string: "null"
at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1250)
at java.lang.Float.parseFloat(Float.java:452)

Long.parseLong("1.0");
Exception in thread "main" java.lang.NumberFormatException: 
For input string: "1.0"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Long.parseLong(Long.java:441)
at java.lang.Long.parseLong(Long.java:483)

Byte.parseByte("129");
Exception in thread "main" java.lang.NumberFormatException: 
Value out of range. Value:"129" Radix:10
at java.lang.Byte.parseByte(Byte.java:150)
at java.lang.Byte.parseByte(Byte.java:174)

java.lang.NumberFormatException: For input string: "1"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)

Integer.parseInt("l");
Exception in thread "main" java.lang.NumberFormatException: 
For input string: "l"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Integer.parseInt(Integer.java:492)
at java.lang.Integer.parseInt(Integer.java:527)

Also, if you get input from the user, make sure you perform validation. Use Scanner if taking input from the command line and methods like the nextInt() to directly read integer instead of reading String and then parsing it to int again using parseInt() method, only to be greeted by NumberFormatExcpetion.

java.lang.NumberFormatException for input string is one of the most common exceptions java programmers face while doing the coding. This exception occurs when someone tries to convert a String into primitive data types such as int, float, double, long, byte, short, etc. It happens only when the String is not valid to be converted into primitive datatype.

Read Also: Exception Handling Interview Questions

The methods like Integer.parseInt(), Float.parseFloat(), Double.parseDouble() etc. throw java.lang.NumberFormatException when someone tries to convert an invalid String into number.

public class JavaHungry
{
    public static void main(String args[])
    {
        String s = "1";
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}

Output:
1

The above code is perfect and will not throw any error or exception. The String “1” was successfully converted into Integer 1 because the String was legal to be converted into numerical data.

Now, change the above code a little bit and let see what happens:

public class JavaHungry
{
    public static void main(String args[])
    {
        String s = "1A";
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}

Output:
Exception in thread «main» java.lang.NumberFormatException: For input string: «1A»    

The above code will generate a java.lang.NumberFormatException because String “1A” was not a valid String for conversion into a primitive datatype.

What are the possible reasons for NumberFormatException?

These are the following possible reasons for NumberFormatException in Java:

1. Converting Null Value to Number

In Java, String containing null value can’t be converted into a primitive data type. For example, a null String can’t be converted into an int, float, double, long, short, or byte data type.

For example:

class JavaHungry
{
    public static void main(String args[])
    {
        String s = null;
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}

Output:
Exception in thread «main» java.lang.NumberFormatException: For input string: «null»
 

2. Empty String to Number

In Java, Empty String can’t be converted into a primitive data type. Any String of length 0 is referred  as an empty String in Java.

For example:

public class JavaHungry
{
    public static void main(String args[])
    {
        String s = "";
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}

Output:
Exception in thread «main» java.lang.NumberFormatException: For input string: «»

3. Alphanumeric String

Alphanumeric String (String which is a combination of alphabetic characters and numbers) cannot be converted into primitive data types.

For example:

public class JavaHungry
{
    public static void main(String args[])
    {
        String s = "AliveisAwesome2020";
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}

Output:
Exception in thread «main» java.lang.NumberFormatException: For input string: «AliveisAwesome2020»
 

4. Leading or Trailing Spaces

Strings with leading or trailing spaces are not valid Strings for conversion into primitive data types. This is one of the most possible reasons for this exception.

For example:

public class JavaHungry
{
    public static void main(String args[])
    {
        // Trailing Space  
        String s = "123 ";
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}

Output:
Exception in thread «main» java.lang.NumberFormatException: For input string: «123 «

5. Conversion of Floating Point String into Integer

Floating-point Strings such as «1.0» are not considered as a valid String for conversion into primitive data types such as int, long, short, etc. in java.

For example:

public class JavaHungry
{
    public static void main(String args[])
    {
        String s = "1.0";
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}

Output:
Exception in thread «main» java.lang.NumberFormatException: For input string: «1.0»
 

6. Out of Range Value

A valid String can be converted into a primitive data type if and only if its numerical value lies within the range of that data type. For example, the range of byte is -128 to 127. So, if someone tries to convert “131” or “-129” to byte, java.lang.NumberFormatException will occur at runtime.

For example:

public class JavaHungry
{
    public static void main(String args[])
    {
        String s = "-129";
        byte i = Byte.parseByte(s);
        System.out.println(i);
    }
}

Output:
Exception in thread «main» java.lang.NumberFormatException: Value out of range. Value:»-129″ Radix:10
 
So, these were some common reasons for java.lang.NumberFormatException for the input string. We can handle this exception by keeping the above reasons in mind and avoiding them in our code. However, using a try-catch block is still a good choice to handle exceptions.

Reference:
NumberFormatException Oracle docs

The NumberFormatException is the frequently occurred exception in Java applications like NullPointerException.

NumberFormatException is an unchecked exception that occurred we try to convert a String to a number type.

Many Java methods convert String to numeric type e.g. Integer.parseInt() which convert String to int, Double.parseDoble() which convert String to double, and Long.parseLong() which convert String to long throws NumberFormatException to inform that the input String is not numeric.

In this article, we will see how the NumberFormatException exception occurred and ways to avoid NumberFormatExcpetion in Java.

Null String

Some times we see the Exception in thread «main» java.lang.NumberFormatException: «null». In the first case, In this, we have a «null» String i.e. an initialized String object whose value is «null». Since this is also not numeric, parseInt(), or parseFloat() will throw the NumberFormat exception as shown below.

package com.javacodestuffs.core.exception.handling;
public class NumberFormatForNull{

     public static void main(String []args){
        float ft =  Float.parseFloat("null");
        System.out.println(ft);
     }
}
output:
Exception in thread "main" java.lang.NumberFormatException: For input string: "null"
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2043)
	at sun.misc.FloatingDecimal.parseFloat(FloatingDecimal.java:122)
	at java.lang.Float.parseFloat(Float.java:451)
	at NumberFormatForNull.main(NumberFormatForNull.java:4)
 

Converting Float to String

In this case «1.0» is perfectly valid String i.e. it doesn’t contain any alphanumeric String. If you try to convert it into integer values using parseInt(), parseShort(), or parseByte() it will throw NumberFormatException because «1.0» is a floating-point value and cannot be converted into integral one.

These methods don’t cast they just do the conversion.

package com.javacodestuffs.core.exception.handling;
public class NumberFormatForFloat {

     public static void main(String []args){
         
        long lg = Long.parseLong("1.0");
        
        System.out.println(lg );
     }
}
output:
Exception in thread "main" java.lang.NumberFormatException: For input string: "1.0"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:589)
	at java.lang.Long.parseLong(Long.java:631)
	at NumberFormatForFloat.main(NumberFormatForFloat.java:6)
 

Convert String to Out of range values

Suppose we have string «130» to a byte, It throws NumberFormatException as the given type byte has rage is 128, which is exceeded by us.

package com.javacodestuffs.core.exception.handling;
public class NumberFormatForByte {

     public static void main(String []args){
         
        byte bt = Byte.parseByte("129");
        
        System.out.println(bt);
     }
}
output:
Exception in thread "main" java.lang.NumberFormatException: Value out of range. Value:"129" Radix:10
	at java.lang.Byte.parseByte(Byte.java:151)
	at java.lang.Byte.parseByte(Byte.java:175)
	at NumberFormatForByte.main(NumberFormatForByte.java:6)
 

Leading and Trailing space in String

This is a common error when we read values from the properties files and there are leading and trailing spaces present in the string.

If we want to convert » 128″ into an integer, it will throw exception java.lang.NumberFormatException.

package com.javacodestuffs.core.exception.handling;
public class NumberFormatForLeadingSpace {

     public static void main(String []args){
         
     int thumbnailLength = Integer.parseInt(" 128");
        
     System.out.println(thumbnailLength);
     }
}
Exception in thread "main" java.lang.NumberFormatException: For input string: " 128"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:569)
	at java.lang.Integer.parseInt(Integer.java:615)
	at com.javacodestuffs.core.exception.handling.NumberFormatForLeadingSpace.main(NumberFormatForLeadingSpace.java:6)
 

For Trailing Spaces

 package com.javacodestuffs.core.exception.handling;
public class NumberFormatForTrailingSpace {

     public static void main(String []args){
         
     int thumbnailHeight = Integer.parseInt("128  ");
        
     System.out.println(thumbnailHeight);
     }
}
Exception in thread "main" java.lang.NumberFormatException: For input string: "128  "
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at com.javacodestuffs.core.exception.handling.NumberFormatForTrailingSpace.main(NumberFormatForTrailingSpace.java:6)

Alphanumeric Input

This is a common mistake by the programmer for the alphanumeric input. No non-numeric letter other than + and — is not permitted in the input string.
It will throw an exception.

package com.javacodestuffs.core.exception.handling;

public class NumberFormatForAlphanumeric {

     public static void main(String []args){
         
     short sh = Short.parseShort("B6");
         
     System.out.println(sh);
     }
}
output:
Exception in thread "main" java.lang.NumberFormatException: For input string: "B6"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Short.parseShort(Short.java:118)
	at java.lang.Short.parseShort(Short.java:144)
	at com.javacodestuffs.core.exception.handling.NumberFormatForAlphanumeric.main(NumberFormatForAlphanumeric.java:6)

Empty String

This is the most common mistakes that happened from the programmer to convert an empty string to numeric or float values.

The parseInt(),parseFloat() …etc will throw NumberFormatException.

package com.javacodestuffs.core.exception.handling;
public class NumberFormatForAlphanumericEmptyString {

	public static void main(String[] args) {

		int value = Integer.parseInt("");

		System.out.println(value);
	}
}
output:
Exception in thread "main" java.lang.NumberFormatException: For input string: ""
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:592)
	at java.lang.Integer.parseInt(Integer.java:615)
	at com.javacodestuffs.core.exception.handling.NumberFormatForAlphanumericEmptyString.main(NumberFormatForAlphanumericEmptyString.java:6)

null values

This will happens when we pass null to a method like parseInt or parseFloat.It mostly occurs when we expect return values from some other methods and forgot to put a null check before converting it to our required type.

package com.javacodestuffs.core.exception.handling;
public class NumberFormatForNullvalues {

     public static void main(String []args){
         
     int value = Integer.parseInt(null);
         
     System.out.println(value);
     }
}
output:
Exception in thread "main" java.lang.NumberFormatException: null
	at java.lang.Integer.parseInt(Integer.java:542)
	at java.lang.Integer.parseInt(Integer.java:615)
	at com.javacodestuffs.core.exception.handling.NumberFormatForNullvalues.main(NumberFormatForNullvalues.java:6)

characters e.g 1 and l

This is another mistake by the programmer. Consider or typo «1» as «l».

package com.javacodestuffs.core.exception.handling;
public class NumberFormatForTypo {

     public static void main(String []args){
         
     int value = Integer.parseInt("l");
         
     System.out.println(value);
     }
}
output:
Exception in thread "main" java.lang.NumberFormatException: For input string: "l"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at com.javacodestuffs.core.exception.handling.NumberFormatForTypo.main(NumberFormatForTypo.java:6)

Best Practices to avoid java.lang.NumberFormatException

1). Don’t try to convert alphabetic or special characters into numbers – the Java Number
API cannot do that.

2). We may want to validate an input string using regular expressions and throw the exception for
the invalid characters.

3). We can sanitize input against foreseeable known issues with methods like trim() and replaceAll().

4). In some cases, special characters in input may be valid. So, we do special processing for
that, using NumberFormat.

5). validate the input before converting it to antother data types.

6). Checks whether the String a valid Java number.

7). Determine if a string is Int or Float and to represent in longer format.

String cost = "";
if (cost !=null && !"".equals(cost) ){
        try {
           Integer intCost = Integer.parseInt(cost);
           List<Book> books = bookService.findBooksCheaperThan(intCost);  
        } catch (NumberFormatException e) {
           System.out.println("Cost is not a number.");
           System.out.println(e.getMessage());
        }
    }  

Post/Questions related to Java lang number format exception

How to resolve number format exception in java?

How to resolve class cast exception in java?

How to fix «Error: Could not find or load main class» in Eclipse?

Ways to avoid ConcurrentModificationException in Java?

How to solve «could not create the Java virtual machine» error in Java?

How to fix «illegal start of expression» compile-time error in Java?

Cause and solution of «class, interface, or enum expected» compiler error in Java?

How to solve java.lang.ClassNotFoundException: com.mysql.jdbc.Driver error?

How to solve java.lang.classnotfoundexception oracle.jdbc.driver.oracledriver?

Common reasons of java.lang.ArrayIndexOutOfBoundsException in Java?

java.lang.ClassNotFoundException : org.Springframework.Web.Context.ContextLoaderListener

How to solve «variable might not have initialized» compile-time error in Java?

How to fix ‘javac’ is not recognized as an internal or external command

How to solve java.lang.OutOfMemoryError: Java Heap Space in Eclipse, Tomcat?

Best Practices to Handle Exceptions in Java

In this article, we have seen the  Java lang number format exception with examples. All source code in the tutorial can be found in the GitHub repository.

1. Exceptions in Java
2. Handling numberformatexception for Input String in Java

This guide will tell you how you can prevent numberformatexception for input strings in Java. To understand it fully, we need to follow up on some of the basics of exception handling in Java. Let’s take a deeper look into it.

Exceptions in Java

The exception is a class that is used to handle some conditions. This class and its subclasses are a form of Throwable, indicating a certain condition that you need to catch while making applications.

Generally, you will see two types of exceptions. They are known as Checked Exception and Unchecked Exception.

Checked exceptions lie under the compile-time exceptions, while unchecked exceptions lie under RuntimeException. A programmer can make their custom exception by extending from the exception class.

Learn more about the exception here.

Handling numberformatexception for Input String in Java

In general, we handle the exception using the try...catch method. The numberformatexception for input string in Java is the same.

When sending a string as input and parsing it into an integer, it must throw a numberformatexception. You can avoid the error by handing it in using the try...catch methods.

Take a look at the following self-explanatory code.

import java.util.*;
public class Main {
    public static void main(String args[]) {

        String var = "N/A";

        // When String is not an integer. It must throw NumberFormatException
        // if you try to parse it to an integer.
        // we can avoid from Exception by handling Exception.
        // Exception Is usually Handle by try Catch Block.
        try {
            int i = Integer.parseInt(var); 
            // if var is not a number than this statement throw Exception
            // and Catch Block will Run
            System.out.println("Number");
        } catch (NumberFormatException ex) { // handling  exception
            System.out.println(" Not A Number");
        }

    }
}

Output:

In the above code, you can see that parsing the var string will not work. It’s a condition that we need to check.

So, using the try...catch block, we handled it. If the string value is not a number, then the catch block will run.