Question

我收到一堆字符串，如果它们与指定的类型匹配，我想检查每一个字符串。

我可以这样做：

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;
    ...
    }
}

但是因为添加新条件应该很容易，所以我想创建类似这样的东西

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

然后检查整个stringarray。

提前致谢！

Answer 1

假设您的代码仅检查3种数据类型。您的代码可能是这样的：

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

Answer 2

我想也许这就是你所追求的？主代码循环遍历所有字符串，然后依次对该字符串运行每个可能的“检查”。 “检查”代码本身存储在一个数组中，该数组包含具有单个check（String）方法的对象，该方法被内联覆盖。您可以使check（）方法执行您需要的任何操作，只要它可以使用标准签名，因此如果您需要正则表达式检查或更复杂的事情，那么这也可以正常工作。

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;
                }
            }, 
    };
}

这会产生输出：

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

这个解决方案很多更详细，并且具有一定程度的间接性，有可能使其混乱，所以如果你只有少量可能的类型，我会只是内省了很多，并为大家省去了麻烦！

如果您需要在测试中运行复杂的算法，或者您需要能够自定义在运行时动态执行哪些测试，那么这种方法实际上只是一种很好的方法。

在Java中存储变量类型

2 个答案: