проверка типа отражения?

Question

Я хотел бы найти способ динамически проверять, может ли строка анализироваться в заданном типе.другими словами,

public boolean canBeParsed(String type, String val) {
    // use reflect to check if val can be parsed into type
}

ясно, я хотел бы иметь возможность проверять разные типы с разными значениями ..

типы будут такими строками как: Java.lang.Integer

---------- дополнение -------------

так, например, если я вызову эту функцию,

canBeParsed("Java.lang.Integer", "1"); //returns true

canBeParsed("Java.lang.Integer", "HelloWorld"); //returns false

canBeParsed("Java.lang.String", "HelloWorld"); //returns true

canBeParsed("Java.lang.Boolean", "false"); // returns true

canBeParsed("Java.lang.Boolean", "HelloWorld"); //returns false

Answer 1

Этот метод работает с классами, которые объявляют статический метод valueOf.Любой класс без этого вернет false.Несколько исключений были опущены, чтобы код был коротким.

Class<?> cls = Class.forName(type);
//Get a converter method, String to  type
//Requires static method valueOf
Method converter;
try{
converter = cls.getDeclaredMethod("valueOf",new Class[]{String.class});
}catch(NoSuchMethodError ex){
   //No conversion method found
   return false;
}
if(!Modifier.isStatic(converter.getModifiers()){
   //the method has to be static in order to be called by us
   return false;
}
if(!cls.isAssignableFrom(converter.getReturnType())
    //The conversion method has the wrong return type
    return false;
try{
    //try to parse the value
    Object o = converter.invoke(null,new Object[]{value};
    if( o == null)return false;//false if method returned null
    else return true;//success
}catch(Exception ex)
{
    //could not parse value
    return false;
}

Метод valueOf (String) присутствует в классах-оболочках Short, Long, Integer, Float, Double, Boolean, поэтому он поддерживает эти и любые другиекласс, который имеет этот метод.

Answer 2

Динамическая проверка типов - это нечто отличное от того, что вы просите.С помощью динамической проверки вы проверяете, является ли obect экземпляром определенного типа (в основном разрешен тот же тип или более узкий тип), и вы можете сделать это с помощью оператора instanceof.Но это касается иерархии объектов, а не концепции «может быть преобразован в», которую вы хотели бы иметь.Вы можете попробовать с string instanceof Integer, но это ВСЕГДА будет ложным.

В вашей ситуации вы хотите проверить, представляет ли строка целое число, и вам следует сделать это по-другому:

try {
  int number = Integer.parseInt(string);
}
catch (NumberFormatException e) {
  System.out.println("String is not an integer string!");
}

В противном случае вы можете определить регулярное выражение для каждого типа и проверить, что строка содержит через него:

if (string.matches("[1-9][0-9]*"))
  ...

В любом случае, поскольку String - это просто строковый тип и ничего больше, RTTI выигралтебе здесь не поможет.Сама строка является ортогональной каждому другому типу (int, float и т. Д.), Даже если она представляет текстовую версию другого типа.

Решение можно найти, если вы можете изменить типы исходных строк, в этом случаевы можете определить, например,

class IntString extends String {
  IntString(int i) {
     super(Integer.toString(i));
  }
}

, тогда вы можете проверить, если string instanceof IntString, но это будет работать, только если строки построены с их конкретным типом, например, String s = new IntString(20).

Answer 3

Самое простое решение - это, вероятно, оператор switch, с одним case для каждого типа, который вы хотите поддерживать.

public boolean canBeParsed(String type, String val)
{
     switch(type) {
         case "Java.lang.Integer" : return(tryParseInteger(val) != null);
         case ...
}


public static Integer tryParseInteger(String text) {
  try {
    return new Integer(text);
  } catch (NumberFormatException e) {
    return null;
  }
}

В C # это было бы проще, поскольку для каждого числового типа существует реальный метод TryParse (), и нет необходимости перехватывать исключение для его проверки.