Jak sprawić, by metoda Java zwracała ogólną listę dowolnego typu?

Nie trzeba nawet zdawać klasy:

public <T> List<T> magicalListGetter() {
    return new ArrayList<T>();
}

Inną opcją jest wykonanie następujących czynności:

public class UserList extends List<User>{

}

public <T> T magicalListGetter(Class<T> clazz) {
    List<?> list = doMagicalVooDooHere();
    return (T)list;
}

List<User> users = magicalListGetter(UserList.class);

`

Let us have List<Object> objectList which we want to cast to List<T>

public <T> List<T> list(Class<T> c, List<Object> objectList){        
    List<T> list = new ArrayList<>();       
    for (Object o : objectList){
        T t = c.cast(o);
        list.add(t);
    }
    return list;
}

Możesz użyć starego sposobu:

public List magicalListGetter() {
    List list = doMagicalVooDooHere();

    return list;
}

Lub możesz użyć Object i klasy nadrzędnej wszystkiego:

public List<Object> magicalListGetter() {
    List<Object> list = doMagicalVooDooHere();

    return list;
}

Uwaga być może istnieje lepsza Klasa nadrzędna dla wszystkich obiektów, które umieścisz na liście. Na przykład Number pozwoli Ci umieścić tam Double i Integer.

Coś takiego

publiс <T> List<T> magicalListGetter(Class<T> clazz) {
    List list = doMagicalVooDooHere();
    return list;
}

Możesz po prostu rzucić do listy, a następnie sprawdzić, czy każdy element może być rzucony do T.

public <T> List<T> asList(final Class<T> clazz) {
    List<T> values = (List<T>) this.value;
    values.forEach(clazz::cast);
    return values;
}

Jestem prawie pewien, że możesz całkowicie usunąć , który wygeneruje Ostrzeżenie i możesz użyć, @ tłumić Ostrzeżenia. Jeśli naprawdę chcesz, aby był ogólny, ale aby użyć dowolnego z jego elementów, będziesz musiał wykonać odlewanie typu. Na przykład zrobiłem prostą funkcję sortowania bąbelków i używa ona ogólnego typu podczas sortowania listy, która w rzeczywistości jest tablicą porównywalnych w tym przypadku. Jeśli chcesz użyć elementu, zrób coś w stylu: System.Wynocha.println ((Double)arrayOfDoubles[0] + (Double)arrayOfDoubles[1]); ponieważ wstawiłem Podwójne (S) do porównywalnych(s), co jest polimorfizmem, ponieważ wszystkie podwójne(s) dziedziczą z porównywalnych, aby umożliwić łatwe sortowanie przez zbiory.sort ()

        //INDENT TO DISPLAY CODE ON STACK-OVERFLOW
@SuppressWarnings("unchecked")
public static void simpleBubbleSort_ascending(@SuppressWarnings("rawtypes") Comparable[] arrayOfDoubles)
{
//VARS
    //looping
    int end      =      arrayOfDoubles.length - 1;//the last index in our loops
    int iterationsMax = arrayOfDoubles.length - 1;

    //swapping
    @SuppressWarnings("rawtypes")
    Comparable tempSwap = 0.0;//a temporary double used in the swap process
    int elementP1 = 1;//element + 1,   an index for comparing and swapping


//CODE
    //do up to 'iterationsMax' many iterations
    for (int iteration = 0; iteration < iterationsMax; iteration++)
    {
        //go through each element and compare it to the next element
        for (int element = 0; element < end; element++)
        {
            elementP1 = element + 1;

            //if the elements need to be swapped, swap them
            if (arrayOfDoubles[element].compareTo(arrayOfDoubles[elementP1])==1)
            {
                //swap
                tempSwap = arrayOfDoubles[element];
                arrayOfDoubles[element] = arrayOfDoubles[elementP1];
                arrayOfDoubles[elementP1] = tempSwap;
            }
        }
    }
}//END public static void simpleBubbleSort_ascending(double[] arrayOfDoubles)