Store Variable Type in Java

Question

I am getting a bunch of strings and I would like to check each of them if they match to a specified type.

I could do it like this:

String[] strings = ...;
for(int i = 0; i < strings.length; i++) {
    switch(i) {
    case 0:
        try {
            Integer.parseInt(strings[i]);
        } catch(Exception e) {
            valid = false;
        }
        break;
    case 1:
        break;
    ...
    }
}

But since it should be easy to add new conditions I want to create something like this

Type[] conditions = new Type[2];
conditions[0] = int;
conditions[1] = long;

and then check the whole stringarray.

Thanks in advance!

Answer 1

I think perhaps this is what you're after? The main code loops through all Strings, and then runs each possible "check" on that String in turn. The "check" code itself is stored in an array, which contains objects with a single check(String) method, which is overridden inline. You can make a check() method do anything you need, as long as it works from the standard signature, so if you need regular expression checks or something more complex then that would also work fine.

public class TestTypes
{
    public static void main(String[] args)
    {
        String[] strings = new String[] {"123", "9999999999999", "50.4", "not a number"};

        for(String str : strings)
        {
        System.out.print("'" + str + "': ");
            for( TypeChecker checker : typesToCheck)
            {
                if(checker.check(str))
                {
                    System.out.print(checker.type.getSimpleName() + " ");
                }
            }
            System.out.println();
        }
    }


    static abstract class TypeChecker
    {
        public final Class type;
        public abstract boolean check(String s);

        TypeChecker(Class type)
        {
            this.type = type;
        }
    }

    // A list of the code for all the checks
    static TypeChecker[] typesToCheck = 
    {
            new TypeChecker(Integer.TYPE) // is Integer
            {
                public boolean check(String s)
                {
                    try{Integer.parseInt(s);}
                    catch(Exception e)
                    {return false;}
                    return true;
                }
            },

            new TypeChecker(Long.TYPE) // is Long
            {
                public boolean check(String s)
                {
                    try{Long.parseLong(s);}
                    catch(Exception e)
                    {return false;}
                    return true;
                }
            }, 

            new TypeChecker(Double.TYPE) // is Double
            {
                public boolean check(String s)
                {
                    try{Double.parseDouble(s);}
                    catch(Exception e)
                    {return false;}
                    return true;
                }
            }, 
    };
}

This produces the output:

'123': int long double 
'9999999999999': long double 
'50.4': double 
'not a number': 

This solution is a lot more verbose, and has a level of indirection which has the potential to make it confusing, so if you've only got a small number of possible types, I'd just inline the lot of them and save everyone the trouble!

This sort of approach is only really a good approach if you have complicated algorithms which need to be run in the tests, or if you need to be able to customize which tests are being executed dynamically at runtime.

Answer 2

Assuming your code checks for 3 datatypes only..Your code could be something like this:

OUTER:  for(int i = 0; i < strings.length; i++)
    {

    if(strings[i].contains("."))
    {
    //float ..since a '.' is present

    continue OUTER;
    }

    else 
    {
    for(int j=0;j<strings[i].length;j++)
    {

    if(strings[i].charAt(j).isCharacter()) // string contains a character
    {
    //text ...since a character is present
    continue OUTER;

    }
    else
    {
    //int ..no character and no '.' hence an int

    }

    }
    }//end of inner for
    }//end of outer for