Java How to: Creation of Generic List?

Question

I need to create generic list that can act as List<ClassA> or List<ClassB> because I have following situation.

if(e instanceof A)
return A;
else
return B

But I want to populate one List Result which can act as either List<ClassA> Result or List<ClassB> Result, am sure we can use generics here but i am not sure how to use it?

Update

All i want to do is that runtime, my List should be populated with proper type, either class A or class B,

if()
{
    //data is present in List<ClassA> classAList = new ArrayList<ClassA>();
    //return classAList
}
else
{
  //return List<ClassB> classBList = new ArrayList<ClassB>();
}

Hope this helps.

Answer 1

So if I understand you correctly, you want to be able to construct a list of ClassA or a list of ClassB depending on if a given object is ClassA or ClassB.

public List<? extends Object> getList(Object e) {
    List<? extends Object> list = new ArrayList<? extends Object>();
    if(e instanceof ClassA) {
        List<ClassA> listA = new ArrayList<ClassA>();
        // Populate list somehow
        list = listA;
    } else if (e instanceof ClassB) {
        List<ClassB> listB = new ArrayList<ClassB>();
        // Populate list somehow
        list = listB;
    }
    return list;
}

Unfortunately, the return type must allow for either type (you can alternatively create two methods with different return types, but they must have different names). However, this allows you to use listA and listB as their own types before assigning it to the more generic list.

However this is a violation of the SOLID principal, so an alternative might be:

public abstract class Root<T> {
    public abstract List<T> getList();
}

public class ClassAList extends Root<ClassA> {
    @Override
    public List<ClassA> getList()  {
        List<ClassA> list = new ArrayList<ClassA>();
        // Populate list somehow
        return list;
    }
}

public class ClassBList extends Root<ClassB> {
    @Override
    public List<ClassB> getList()  {
        List<ClassB> list = new ArrayList<ClassB>();
        // Populate list somehow
        return list;
    }
}

Hope that helps!

Answer 2

class A extends C{ ... body ... }
class B extends C{ ... body ... }

//will work

List<C> list = new ArrayList<C>();
list.add(new A());
list.add(new B());

Or suggestion by Bernard

Summary :

Your option is to either create a parent class and extend parent class from A and B and add the parent type to the list or create an interface and implement that interface from A and B and put the interface type in the list. Either way you'll end up changing your classes A and B and creating new interface or class

Answer 3

You should use a common interface that both of your classes implement. Say your interface is called MyInterface. Both of your classes can implement this interface and your generic list can be of type List<MyInterface>.

The alternative is that both of your classes have a common base class.

Edit:

Added some examples as requested by OP.

Example interface:

public interface MyInterface
{
   String getName();

   void setName(String name);
}

Example interface implementation:

public class ClassA implements MyInterface
{
   private String name;

   public String getName()
   {
      return name;
   }

   public void setName(String name)
   {
      this.name = name;
   }
}

Example generic list usage:

List<MyInterface> list = new ArrayList<MyInterface>();

list.add(new ClassA());

MyInterface item = list.get(0);

item.setName("Bob");

String name = item.getName();

Answer 4

If ClassA and ClassB have a common base class (i.e., they both extend the same class), then you can use the base class type in the generic parameter.

Answer 5

Generics are fundamentally for static time checking. In your case, you've got two types of data, so using generics doesn't make any sense unless A & B share a common ancestor class

Answer 6

The only way to do this would be for ClassA and ClassB either to have a common parent class or implement a common interface. In either case, the only way to restrict the list to those specific classes would be if no other classes had that common parent or common interface.

Both of these require either that this common parent or common interface already exists or that you have control over ClassA and ClassB. If they don't and you don't, then there's no way to do what you're after.

Answer 7

This is only really possible if A and B share a common parent (say C). You could then return a List<C>.

It's possible to return a List<Object> but I'd advise against this and consider reworking your design.

Answer 8

Something like this perhaps:

public class Test {
  static class A {}
  static class B {}
  private static List<?> getList() {
    List<A> aList = new ArrayList<A>();
    List<B> bList = new ArrayList<B>();
    aList.add(new A());
    if (aList.size() > 0) {
      return aList;
    } else {
      return bList;
    }
  }

  public static void main(String[] args) {
    List<?> cList = getList();
    System.out.println(cList);
  }
}