77

我想编写一个返回java.util.List任何类型的方法，而无需进行任何类型转换：

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

List<Vehicle> vehicles = magicalListGetter(Vehicle.class);

List<String> strings = magicalListGetter(String.class);

方法签名会是什么样子？像这样的东西，也许（？）：

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

    return list;
}
4

8 回答 8

145 
private Object actuallyT;

public <T> List<T> magicalListGetter(Class<T> klazz) {
    List<T> list = new ArrayList<>();
    list.add(klazz.cast(actuallyT));
    try {
        list.add(klazz.getConstructor().newInstance()); // If default constructor
    } ...
    return list;
}

也可以为方法提供泛型类型参数。您已经正确推断出需要正确的类实例来创建事物（klazz.getConstructor().newInstance()）。

于 2013-07-24T17:06:08.640 回答
27

甚至不需要通过课程：

public <T> List<T> magicalListGetter() {
    return new ArrayList<T>();
}
于 2013-07-25T04:53:09.623 回答
3

另一种选择是执行以下操作：

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

`

于 2015-08-05T08:01:47.800 回答
3

让我们拥有List<Object> objectList我们想要投射的东西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;
}
于 2016-02-20T08:57:31.103 回答
2

您可以使用旧方法：

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

    return list;
}

或者你可以使用Object所有东西的父类：

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

    return list;
}

注意对于您将放在列表中的所有对象，也许有一个更好的父类。例如，Number将允许您将DoubleandInteger放在那里。

于 2013-07-24T17:06:48.250 回答
2

像这样的东西

publiс <T> List<T> magicalListGetter(Class<T> clazz) {
    List list = doMagicalVooDooHere();
    return list;
}
于 2013-07-24T17:08:09.117 回答
0

您可以简单地转换为 List，然后检查是否每个元素都可以转换为 T。

public <T> List<T> asList(final Class<T> clazz) {
    List<T> values = (List<T>) this.value;
    values.forEach(clazz::cast);
    return values;
}
于 2017-03-08T10:42:21.480 回答
-1

我很确定你可以完全删除 <stuff> ，这会产生一个警告，你可以使用 @suppress 警告。如果你真的希望它是通用的，但要使用它的任何元素，你将不得不进行类型转换。例如，我做了一个简单的冒泡排序函数，它在对列表进行排序时使用泛型类型，在这种情况下实际上是一个 Comparable 数组。如果您想使用一个项目，请执行以下操作： System.out.println((Double)arrayOfDoubles[0] + (Double)arrayOfDoubles[1]); 因为我将 Double(s) 填充到 Comparable(s) 中，这是多态性，因为所有 Double(s) 都继承自 Comparable 以允许通过 Collections.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)
于 2013-07-24T17:25:29.553 回答