Defining a Generic List

I'm fairly new to Generics, and would really appreciate some help here. I've got a method,

1 public static List<classA> convertA(List<List<Object>> dataframe) throws Exception {
2		List<classA> objA = new ArrayList<classA>();
3		for (List<Object> objs : dataframe) {
4			if (objs != null) {
5				classA a = new classA();
						
6				//generic logic to set value from objs to object `a` irrespective of type of `a`. 
						
7				objA.add(a);
8			}
9		}
			
10		return objA;
11	}

The method basically assigns the values of List<List<Object>> dataframe to a list of classA.

I also have another method convertB which has the same logic and argument of convertA except that it stores the values of dataframe to a list of classB(List<classB>), like so,

21 public static List<classB> convertB(List<List<Object>> dataframe) throws Exception {
22		List<classB> objA = new ArrayList<classB>();
23		for (List<Object> objs : dataframe) {
24			if (objs != null) {
25				classB b = new classB();
						
26				//generic logic to set value from objs to object `b` irrespective of type of `b`. 
						
27				objA.add(b);
28			}
29		}
			
30		return objA;
31	}

So I'm trying to combine the 2 methods into a single one to write a common generic method with return type of List<T> and arguments including type of T(which can be classA, classB,..), something like so,

public static List<T> convertGeneric(List<List<Object>> dataframe, T t) 

But I'm not sure how to write the lines 2,5,7 in a generic manner.

So could someone point me in the right direction?

Please Note:

Both the methods convertA and convertB are independant of each other and are used to handle 2 seperate scenarios. There is no relation between the two, except the fact that both have the same logic to convert List<Object> objs to its respective object namely a(classA) or b(classB).

Rather than maintaining 2 seperate methods like convertA() and convertB(), I'm just trying to make it into a single one which I can call by passing arguments like

List<ClassA> ls = convertGeneric(dataframe, ClassA.class); instead of convertA() and

List<ClassB> ls1 = convertGeneric(dataframe, ClassB.class); instead of convertB().

A Solution Using a Generic Method

Define your generic method as

public static <T> List<T> convertGeneric(List<List<Object>> dataframe, Function<Object, T> converter)

i.e. the first argument is your collection of objects, and as the second argument you provide a conversion function from Object to the target class. The method returns a List<T>. (Note the <T> after static which is required to declare a generic method.

An implementation of the method could be

public static <T> List<T> convertGeneric(List<List<Object>> dataframe, Function<Object, T> converter) {

  List<T> result = new ArrayList<>();

  for (List<Object> objects : dataframe) {
    for (Object object : objects) {
      T t = converter.apply(object);
      result.add(t);
    }
  }

  return result;
}

or another one using streams:

public static <T> List<T> convertGeneric(List<List<Object>> dataframe, Function<Object, T> converter) {

  return dataframe.stream()
          .flatMap(Collection::stream)    // get the objects from the inner list
          .map(converter)                 // convert object to T
          .collect(Collectors.toList());  // put everything in a new list
}

The conversion function can be implemented as a lambda, e.g.

Function<Object, Foo> fooLambda = object -> {
  Foo foo = new Foo();
  // logic for mapping obj to foo
  return foo;
};

And converting a List<List<Object>> to a List<Foo> becomes:

List<Foo> fooList = GenericMethodConverter.convertGeneric(dataFrame, fooLambda);

I think the reason why you were struggling with the problem is that you tried to do everything (the abstract and the concrete part) in the generic method. You were aware that the generic method then requires additional information what concrete implementation to use (in your version by passing as the second argument the target type for the conversion). In the above solution, the generic method requires a conversion function Function<Object,T>, i.e a function that maps an object to the target type T. The generic method applies this function to all objects and puts the results in the returned list. The concrete implementation for mapping an object to a Foo is supplied as a lambda expression thus reifying the generic T to Foo. Other conversion functions can be added as required.

Another Approach

This is a solution using object orientation / classes instead of static methods:

Define an abstract base class GenericConverter that contains the iteration to over the list and declares an abstract method how to convert an Object to the target type:

public abstract class GenericConverter<T> {

  public List<T> convertGenerically(List<List<Object>> dataFrame) {

    List<T> tList = new ArrayList<>();

    for (List<Object> objectList : dataFrame) {
      for (Object obj : objectList) {
         T t = convert(obj);
         tList.add(t);
       }
    }
    return tList;
  }

  protected abstract T convert(Object obj);
}

Add an implementation for each target class, e.g. for converting Object to Foo:

public class FooConverter extends GenericConverter<Foo> {

    @Override
    protected Foo convert(Object obj) {
        Foo foo = new Foo();

        // logic for mapping obj to foo

        return foo;
    }
}

And then convert the Objects by calling the method of implementing class:

List<Foo> foos = fooConverter.convertGenerically(dataFrame);

If I get you right you need to create interface and implement it in your classA and classB. Then use this interface as generic placeholder. Example:

public class ClassA implements  Interface {
}

public class ClassB implements  Interface {
}



 ArrayList<Interface> objA = new ArrayList<>();
        objA.add(new ClassA());
        objA.add(new ClassB());
        for (Interface obj : objA) {
            //logic
            }
        }