How to generically specify a Serializable List

Question

I have the following interface:

public interface Result<T extends Serializable> extends Serializable{
    T getResult();
}

With that interface, I can not define a variable of type

Result<List<Integer>>

because List is not serializable.

However, if I change the interface to this:

public interface Result<T> extends Serializable{
    T getResult();
}

It now becomes impossible to implement, with compile time checking, because there is no guarantee that T is serializable, and the whole point of the class is to store the result so that I can get it back later, possibly after a transfer over the internet.

My question is this, is there a way to declare a variable so that it is of two types, or is there some other way to do this that I am not seeing? So, maybe something like:

(List<Integer> extends Serializable) value = new ArrayList();

I am trying to put as much of the burden of this problem on the implementation, so that future consumers of this interface are unaware of the problem.

Thanks for your help!

Here is a more detailed example of what I am trying to do: I am calling a server, The result of which I want to store in a result object, but I do not want to have to deal with casting. So, each method that can be called on the server will define the type of the result by using generics. This result object will also store other meta-data about the result, for example maybe there was too much information to return. In many cases I want to use a list, but the List interface is not serializable, although many of the implementations are.

So, how to I specify that the type used must be Serializable, but still allow for a List(and not a specific implementation of List) to be used?

Answer 1

Initial thought. If you are planning on using serialization for any kind of long term data storage, don't. Serialization is not guaranteed to work between invocations of the JVM.

You probably should not be extending Serializable unless you are adding functionality related to Object serialization. Instead, your class that implements Result should also implement Serializable.

Answer 2

If your intention is to use the Result type for lists in general, and what you want is to make sure the elements of the list are serializable, you could define it like this:

public interface Result<T extends List<? extends Serializable>> {}

That way, you could define something like:

Result<List<Integer>> r;

But something like this would not compile:

Result<List<List>> r;

Now if you want to use the result both for, say, Integer, and for List, then the type is not required to be serializable, right? In that case I don't really understand what your goal is.

Answer 3

You could simply declare the variable as Result<ArrayList<Integer>>. As long as you still program to the List interface, you haven't really sacrificed replaceability.

I was going to also suggest creating a new interface ListResult:

public interface ListResult<T extends Serializable & List<E extends Serializable>>
        implements Result<T> {
    T getResult();
}

but then you would still have to declare the variable as ListResult<ArrayList<Integer>>. So I'd go the simpler route.

Answer 4

You kind of can, I think:

public class Thing<T extends Serializable> implements Serializable {
    private static class Holder<V extends Serializable> {
        private final V value;
        private Holder(V value) {
            this.value = value;
        }
    }
    private Holder<? extends List<T>> holder;
    private <V extends List<T> & Serializable> void set(V value) {
        holder = new Holder<V>(value);
    }
}

Does that look ugly enought for you?

Can I suggest that you do not attempt to enforce implementing Serializable using the Java static type system? It's only an interface because annotations weren't about back then. It's just not practical to enforce it. OTOH, you could enforce it using a type checker that does static analysis in a closed system.

Answer 5

The way I ended up solving this problem is to use this as the interface:

public interface Result<T> extends Serializable{
    T getResult();
}

Then create an implementation for each of the different types of collections as well as one for any object.

So, for example here is what the ListResult class would look like:

public class ListResult<T> implements Result<List<T>>{
    public List<T> getResult(){
        //return result
    }

    public <V extends List<T> & Serializable> void setResult(V result){
        //store result
    }
}

Answer 6

You need to declare your variable type as Result<? extends List<Integer>>.

The type checking knows that List isn't serializable, but a subtype of List can be serializable.

Here is some sample code. The interface implementation was just done with anonymous inner classes. You can see that the getResult will return a List<Integer> on the 2nd object

   Result<Integer> res = new Result<Integer>() {

  Integer myInteger;

  private static final long serialVersionUID = 1L;

  @Override
  public Integer getResult() {
   return myInteger;
  }

  @Override
  public void addResult(Integer input) {
   this.myInteger = input;
  }
 };

 Integer check = res.getResult();


 Result<? extends List<Integer>> res2 = new Result<ArrayList<Integer>>() {

  ArrayList<Integer> myList;

  private static final long serialVersionUID = 1L;

  @Override
  public ArrayList<Integer> getResult() {
   return myList;
  }

  @Override 
  public void addResult(ArrayList<Integer> input) {
   this.myList = input;
  }

 };

 List<Integer> check2 = res2.getResult();

Edit: Made the example more complete by implementing a void addResult(T input) interface method

Answer 7

Although the List interface doesn't implement Serializable, all of the built-in Collection implementations do. This is discussed in the Collections Implementations tutorial.

The Collections Design FAQ has a question "Why doesn't Collection extend Cloneable and Serializable?" which talks about why Sun designed it without extending Serializable.