Question

I have a class Data<T>

with a generic attribute

private T value;

is there nicer way to do the following?
ie returning the generic type in different forms?

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

Precision, I’m using Gson as deserializer, to get a List, each Data objects can then be heterogeous
Could also register adapters for float and long detection, but it wouldn’t be faster or nicer

edit: gson fails to retrieve longs:

either:

 ((Long) d.getValue())

java.lang.Double cannot be cast to java.lang.Long

or

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

java.lang.NumberFormatException: For input string: “212231.0”

I tried to register a 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: Cannot register type adapters for class java.lang.Long

edit2 for tsOverflow:

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);

Answer 1

The point of generics is NOT to allow a class to use different types at the same time.

Generics allow you to define/restrict the type used by an instance of an object.

The idea behind generics is to eliminate the need to cast.

Using generics with your class should result in something like this:

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();

You should either use Objects and casting —OR— use generics to avoid casting.

You seem to believe that generics allow for heterogeneous typing within the same instance.

That is not correct.

If you want a list to contain a mixed bag of types, then generics are not appropriate.

---

Also…

To create a long from a double, use Double.longValue().

To create a float from a double, use Double.floatValue().

I recommend reading the documentation.