Question

我有类似的要求，我需要将对象类型转换为动态类型以便添加数组。

例如：

我正在动态创建一个Float数组：

T array = (T) Array.newInstance(type, length);

我的项目是双重类型（值= 1.2），我的数组是浮点数组。

我需要在这个数组中添加项目，如：

Array.set(array, i, value);

所以会发生什么，我正在尝试IllegalArgumentException，因为我试图将double添加到float数组。所以我需要在添加之前键入cast to float。但问题是类型是动态的，比如它可以是float，int，char，String等。请帮我一个方法来强制转换并将它添加到数组中。感谢

Answer 1

我认为项目的数据类型是双倍的是一个考虑周全的原因。我建议将数组的类型更改为Double，而不是尝试将double转换为float（这可能会导致严重错误）。

Answer 2

正如API中所指定的，所有java.lang.Number都可以将自己投射到任何其他数字类型。如

(new Double(3.5d)).floatValue()

就数组而言，显然必须为它选择一种类型，然后根据需要将所有值转换为该类型。您已经发现，无法创建泛型类型的数组。但是，您可以动态地找出所需的数组类型并创建它：

public class ArrayOfType  {
   public static final void <N extends Number> N[] get(N number, int length)  {
      if(number.class.isAssignableFrom(Integer.class))  {
          return  new Integer[length];
      else if...

将其用于：

T[] arrayOfT = ArrayOfType.<T>get(someNumOfTypeT, 3);

Answer 3

一种可能的解决办法：

Array.set(array, i, (T) value);

因为您要做的就是将value转换为类型T，该数组已被定义为。当然，这只是一个通用的答案，大部分时间都可以使用，但是从一种数据类型转换到另一种数据类型时必须小心。

如果你使用aliteralmind的回答：

Array.set(array, i, value.floatValue());

假设value是一种扩展Number的类型。

Answer 4

我想Double - ＆gt; Float转换是您遇到的第一个问题。您可能需要在代码之上实现类型转换机制。即。

interface TypeConverter<T> {
    T convertTo(Class<T> clazz, Object value);
}

然后使用所需的所有转换器实现创建注册表，并根据目标类（数组项类）使用它们。

class FloatTypeConverter implements TypeConverter<Float> {
    @Override
    public Float convertTo(Class<Float> clazz, Object value) {
        if (value instanceof Float) {
            return (Float) value;
        } else if (value instanceof Double) {
            return new Float(((Double) value).floatValue());
        } else {
            throw new UnsupportedConversion();
        }
    }
}
TypeConverterRegistry.register(Float.class, new FloatTypeConverter());
...

TypeConverter<?> converter = TypeConverterRegistry.getConverterFor(type);
Array.set(array, i, converter.convertTo(type, value));

Answer 5

最后我找到了一个解决方法：

private Object changeValueToSuitDestType(Object value, Class<?> destType) {
    if (destType == null || value == null) {
        return value;
    }

    String typeString = destType.toString();
    String valueString = value.toString();
    boolean isNull = TextUtils.isEmpty(valueString)
            || valueString.equalsIgnoreCase("null");

    if (typeString.equalsIgnoreCase("boolean")
            || destType == Boolean.class) {
        if (isNull) {
            if (destType == Boolean.class) {
                return null;
            } else {
                return false;
            }
        } else {
            return Boolean.parseBoolean(value.toString());
        }
    } else if (typeString.equalsIgnoreCase("byte")
            || destType == Byte.class) {
        if (isNull) {
            if (destType == Byte.class) {
                return null;
            } else {
                return 0;
            }
        } else {
            return Byte.parseByte(value.toString());
        }
    } else if (typeString.equalsIgnoreCase("short")
            || destType == Short.class) {
        if (isNull) {
            if (destType == Short.class) {
                return null;
            } else {
                return 0;
            }
        } else {
            return Short.parseShort(value.toString());
        }
    } else if (typeString.equalsIgnoreCase("int")
            || destType == Integer.class) {
        if (isNull) {
            if (destType == Integer.class) {
                return null;
            } else {
                return 0;
            }
        } else {
            return Integer.parseInt(value.toString());
        }
    } else if (typeString.equalsIgnoreCase("long")
            || destType == Long.class) {
        if (isNull) {
            if (destType == Long.class) {
                return null;
            } else {
                return 0L;
            }
        } else {
            return Long.parseLong(value.toString());
        }
    } else if (typeString.equalsIgnoreCase("float")
            || destType == Float.class) {
        if (isNull) {
            if (destType == Float.class) {
                return null;
            } else {
                return 0F;
            }
        } else {
            return Float.parseFloat(value.toString());
        }
    } else if (typeString.equalsIgnoreCase("double")
            || destType == Double.class) {
        if (isNull) {
            if (destType == Double.class) {
                return null;
            } else {
                return 0D;
            }
        } else {
            return Double.parseDouble(value.toString());
        }
    } else if (typeString.equalsIgnoreCase("char")
            || destType == Character.class) {
        if (isNull) {
            if (destType == Character.class) {
                return null;
            } else {
                return '\u0000';
            }
        } else {
            return value.toString().charAt(0);
        }
    } else if (destType == String.class) {
        if (isNull) {
            return null;
        } else {
            return value.toString();
        }
    }

    return value;
}

感谢所有人的宝贵答案，对我而言，我发现没有其他简单的方法可以解决这个问题。如果你们发现这样的话，请告诉我。再次感谢所有人。

将对象动态转换为类型

5 个答案: