我想编写一个方法,可以返回任何类型的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;
}
提前致谢!
答案 0 :(得分:111)
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()
)。
答案 1 :(得分:18)
甚至无需通过课程:
public <T> List<T> magicalListGetter() {
return new ArrayList<T>();
}
答案 2 :(得分:2)
另一个选择是执行以下操作:
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);
`
答案 3 :(得分:2)
让我们将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;
}
答案 4 :(得分:1)
您可以使用旧方式:
public List magicalListGetter() {
List list = doMagicalVooDooHere();
return list;
}
或者您可以使用Object
和所有内容的父类:
public List<Object> magicalListGetter() {
List<Object> list = doMagicalVooDooHere();
return list;
}
注意对于您将放入列表中的所有对象,可能有一个更好的父类。例如,Number
允许您将Double
和Integer
放在那里。
答案 5 :(得分:1)
像这样的东西
publiс <T> List<T> magicalListGetter(Class<T> clazz) {
List list = doMagicalVooDooHere();
return list;
}
答案 6 :(得分: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;
}
答案 7 :(得分:-1)
我很确定你可以完全删除&lt; stuff&gt; ,它会产生一个警告,你可以使用@抑制警告。如果你真的希望它是通用的,但要使用它的任何元素,你将不得不进行类型转换。例如,我做了一个简单的冒泡排序函数,它在排序列表时使用泛型类型,在这种情况下实际上是一个Comparable数组。如果你想使用一个项目,做类似的事情:System.out.println((Double)arrayOfDoubles [0] +(Double)arrayOfDoubles [1]);因为我将Double(s)填充到Comparable(s)这是多态的,因为所有Double都继承自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)