How to check if a string is a number

Question

I have conversion to Map problem in Core Java.

Below is requirement:
Given a String array below

String str[] = {"abc","123","def","456","ghi","789","lmn","101112","opq"};          

Convert it into a Map such that the resultant output is below

Output

======      ======         
key         Value        
======      ======                  
abc          true       
123          false       
def          true      
456          false

The above should be printed for each element in the array. I have written the code but it's not working and I'm stuck. Please let me know how it can be resolved. Thanks in advance.

import java.util.HashMap;       
import java.util.Iterator;       
import java.util.Map;       

public class CoversionToMap {

/**
 * @param args
 */
public static void main(String[] args) {
    String str[] = {"abc","123","def","456","ghi","789","lmn","101112","opq"};
    Map m = new HashMap();
    for(int i=0;i<str.length;i++){
        if(Integer.parseInt(str[i]) < 0){
            m.put(str[i],true);
        }else{
            m.put(str[i],false);
        }
    }
    //Print the map values finally
    printMap(m);
}   

public static void printMap(Map mp) {
        Iterator it = mp.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry pairs = (Map.Entry)it.next();          
            System.out.println(pairs.getKey() + " = " + pairs.getValue());
        }
}  
}           

exception:

Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"       
    at java.lang.NumberFormatException.forInputString(Unknown Source)       
    at java.lang.Integer.parseInt(Unknown Source)       
    at java.lang.Integer.parseInt(Unknown Source)       
    at CoversionToMap.main(CoversionToMap.java:22)       

Answer 1

Everyone is suggesting using exception handling for this, there is nothing exceptional here to warrant using exceptions like this, you don't try turning left in your car and if you crash go right do you? Something like this should do it

Map<String, Boolean> m = new HashMap<String, Boolean>();
for (String str: strs) {
    m.put(str, isInteger(str));
}

public boolean isInteger(String str) {
    int size = str.length();

    for (int i = 0; i < size; i++) {
        if (!Character.isDigit(str.charAt(i))) {
            return false;
        }
    }

    return size > 0;
}

Much clearer and more efficient that catching throwing exception, even when there are 99% integers as the integer value is not even needed so no conversion required.

Answer 2

Integer.parseInt(..) throws an exception for invalid input.

Your if clause should look like this:

if (isNumber(str[i])) {
   ...
} else {
   ...
}

Where isNumber can be implemented in multiple ways. For example:

• using try { Integer.parseInt(..) } catch (NumberFormatException ex) (see this related question)
• using commons-lang NumberUtils.isNumber(..)

Answer 3

You check if parseInt returns a number smaller than 0 to see if the input is non-numeric.

However, that method doesn't return any value at all, if the input is non-numeric. Instead it throws an exception, as you have seen.

The simplest way to do what you want is to catch that exception and act accordingly:

try {
  Integer.parseInt(str[i]);
  // str[i] is numeric
} catch (NumberFormatException ignored) {
  // str[i] is not numeric
}

Answer 4

If you want to check if the string is a valid Java number you can use the method isNumber from the org.apache.commons.lang.math (doc here: http://commons.apache.org/lang/api-2.4/org/apache/commons/lang/math/NumberUtils.html).

This way you won't have to write your own implementation of isNumber

Answer 5

You need to use a try/catch block instead of testing the return value for parseInt.

try {
    Integer.parseInt(str[i]);
    m.put(str[i],true);
} catch(NumberFormatException e) {
    m.put(str[i],false);
}

Answer 6

Your error occurs here:

if(Integer.parseInt(str[i]) < 0){

Integer.parseInt throws a NumberFormatException when the input isn't a number, so you need to use a try/catch block, for example:

try{
    int number = Integer.parseInt(str[i]);
    m.put(str[i],false);
}catch NumberFormatException nfe{
    m.put(str[i],true);
}

Answer 7

Assuming you won't use any external libraries, you can also use a Regular Expression Matcher to do that. Just like

for (String element : str) {
     m.put(element, element.matches("\\d+"));
}

Note that this works only with non-negative integers, but you can adapt the regular expression to match the number formats you want to map as true. Also, if element is null, you'll get a NullPointerException, so a little defensive code is required here.

Answer 8

Here is an improved answer which can be used for numbers with negative value, decimal points etc. It uses Regular Expressions.

Here it it:

public class StringValidator {

    public static void printMap(Map<String, Boolean> map) {
        Iterator it = map.entrySet().iterator();
        for(Map.Entry<String, Boolean> entry:map.entrySet()){
            System.out.println(entry.getKey()+" = "+ entry.getValue());
        }
    }
}

class ValidateArray{
        public static void main(String[] args) {
        String str[] = {"abcd", "123", "101.112", "-1.54774"};
        Map<String, Boolean> m = new HashMap<String, Boolean>();
        for (String s : str) {
            m.put(s, isNumber(s));
        }
        StringValidator.printMap(m);
    }

    public static boolean isNumber(String str) {
        Pattern pattern = Pattern.compile("^-?\\d+\\.?\\d*$");
        Matcher matcher = pattern.matcher(str);
        return matcher.matches();
    }
}

Answer 9

Here's a more general way to validate, avoiding exceptions, and using what the Format subclasses already know. For example the SimpleDateFormat knows that Feb 31 is not valid, as long as you tell it not to be lenient.

import java.text.Format;
import java.text.NumberFormat;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map;

public class ValidatesByParsePosition {

    private static NumberFormat _numFormat = NumberFormat.getInstance();
    private static SimpleDateFormat _dateFormat = new SimpleDateFormat(
            "MM/dd/yyyy");

    public static void printMap(Map<String, Boolean> map) {

        for (Map.Entry<String, Boolean> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }

    public static void main(String[] args) {

        System.out.println("Validating Nums with ParsePosition:");
        String numStrings[] = { "abcd", "123", "101.112", "-1.54774", "1.40t3" };
        Map<String, Boolean> rslts = new HashMap<String, Boolean>();
        for (String s : numStrings) {
            rslts.put(s, isOk(_numFormat, s));
        }
        ValidatesByParsePosition.printMap(rslts);

        System.out.println("\nValidating dates with ParsePosition:");
        String dateStrings[] = { "3/11/1952", "02/31/2013", "03/14/2014", 
                "05/25/2014", "3/uncle george/2015" };
        rslts = new HashMap<String, Boolean>();
        _dateFormat.setLenient(false);
        for (String s : dateStrings) {
            rslts.put(s, isOk(_dateFormat, s));
        }
        ValidatesByParsePosition.printMap(rslts);
    }

    public static boolean isOk(Format format, String str) {

        boolean isOK = true;
        int errorIndx = -1;
        int parseIndx = 0;

        ParsePosition pos = new ParsePosition(parseIndx);

        while (isOK && parseIndx < str.length() - 1) {
            format.parseObject(str, pos);
            parseIndx = pos.getIndex();
            errorIndx = pos.getErrorIndex();
            isOK = errorIndx < 0;
        }

        if (!isOK) {
            System.out.println("value \"" + str
                    + "\" not parsed; error at char index " + errorIndx);
        }

        return isOK;
    }

}

Answer 10

Replace your parseInt line with a call to isInteger(str[i]) where isInteger is defined by:

public static boolean isInteger(String text) {
  try {
    new Integer(text);
    return true;
  } catch (NumberFormatException e) {
    return false;
  }
}

Answer 11

I would like to enter the contrary view on 'don't use exception handling' here. The following code:

try
{
  InputStream in = new FileInputStream(file);
}
catch (FileNotFoundException exc)
{
  // ...
}

is entirely equivalent to:

if (!file.exists())
{
  // ...
}
else
try
{
  InputStream in = new FileInputStream(file);
}
catch (FileNotFoundException exc)
{
 // ...
}

except that in the former case:

1. The existence of the file is only checked once
2. There is no timing-window between the two checks during which things can change.
3. The processing at // ... is only programmed once.

So you don't see code like the second case. At least you shouldn't.

The present case is identical except that because it's a String there is no timing window. Integer.parseInt() has to check the input for validity anyway, and it throws an exception which must be caught somewhere anyway (unless you like RTEs stopping your threads). So why do everything twice?

The counter-argument that you shouldn't use exceptions for normal flow control just begs the question. Is it normal flow control? or is it an error in the input? [In fact I've always understood that principle to mean more specifically 'don't throw exceptions to your own code' within the method, and even then there are rare cases when it's the best answer. I'm not a fan of blanket rules of any kind.]

Another example detecting EOF on an ObjectInputStream. You do it by catching EOFException. There is no other way apart from prefixing a count to the stream, which is a design change and a format change. So, is EOF part of the normal flow, or is it an exception? and how can it be part of the normal flow given that it is only reported via an exception?

Answer 12

boolean intVal = false;
    for(int i=0;i<str.length;i++) {
            intVal = false;
            try {
                if (Integer.parseInt(str[i]) > 0) {
                    intVal = true;
                }
            } catch (java.lang.NumberFormatException e) {
                intVal = false;
            }
        m.put(str[i], !intVal);
    }