Java-泛型与转换对象

  • Z时代
  • 2024-01-10
  • 分类：问答

我有一堂课 Data<T>

具有通用属性

private T value;

有更好的方法来执行以下操作吗？

即以不同的形式返回泛型？

public List<String> getValues() {
    if (value.getClass() != ArrayList.class)
        throw new Exception("Wrong Enum value '%s'", value);
    return (ArrayList<String>) value;
    //ugly
}
public String getStringValue() {
    if (value.getClass() != String.class)
        throw new Exception("Wrong value type '%s'", value);
    return (String) value;
    //ugly
}
public Float getFloatValue() {
    if (value.getClass() != Double.class)
        throw new Exception("Wrong value type '%s'", value);
    return (Float) value;
    //ugly
}
public Long getLongValue() {
    if (value.getClass() != Double.class)
        throw new Exception("Wrong value type '%s'", value);
    return (Long) value;
    //ugly
}
public T getValue() {
    return value;
}

精度，我使用Gson作为反序列化器，以获取列表，然后每个Data对象都可以是异构的

。还可以注册适配器以进行浮点和长检测，但不会更快或更漂亮

：gson无法检索多头：

要么：

 ((Long) d.getValue())

java.lang.Double无法转换为java.lang.Long

要么

Long.parseLong( d.getValue().toString())

java.lang.NumberFormatException：对于输入字符串：“ 212231.0”

我试图注册一个LongAdpater

gsonBuilder.registerTypeAdapter(Long.class, new LongAdapter());
private static class LongAdapter implements 
    JsonSerializer<Long>, JsonDeserializer<Long> 
{
    @Override public Long deserialize(
            JsonElement json, 
            Type type,
            JsonDeserializationContext arg2) throws JsonParseException 
    {
        return json.getAsLong();
    }
    @Override
    public JsonElement serialize(Long l, Type arg1,
            JsonSerializationContext arg2) {
        return new JsonPrimitive(new Double(l));
    }
}

java.lang.IllegalArgumentException：无法为类java.lang.Long注册类型适配器

：

Data<Float> d1 = new Data<Float>( new Float(6.32));
List<String> l = new ArrayList<String>();
    l.add("fr");
    l.add("it");
    l.add("en");
Data<List<String>> d2 = new Data<List<String>>( l);
Data<Long> d3 = new Data<Long>(new Long(212231));
List<Data> data = new ArrayList<Data>();
    data.add(d1);
    data.add(d2);
    data.add(d3)
new Gson().toJson(data);

回答：

泛型的一点是 允许一个类来同时使用不同类型。

泛型允许您 定义/限制 对象 实例 使用的类型。

泛型背后的想法是消除强制转换的需要。

在类中使用泛型应导致如下结果：

Data<String> stringData = new Data<String>();
String someString = stringData.getValue();
Data<Long> longData = new Data<Long>();
Long someLong = longData.getValue();
Data<List<String>> listData = new Data<List<String>>();
List<String> someList = listData.getValue();

您应该使用 对象 并进行强制转换- -使用泛型来避免强制转换。

您似乎相信泛型允许在同一实例中进行异构键入。

那是不对的。

如果您希望列表包含类型混合的列表，则泛型是不合适的。

也…

要从双精度型创建多头，请使用Double.longValue（）。

要从double中创建一个float，请使用Double.floatValue（）。

我建议阅读文档。

以上是 Java-泛型与转换对象 的全部内容， 来源链接： utcz.com/qa/435652.html

回到顶部