如何将 List<Object> 转换为 List<MyClass>

Question

这不会编译，任何建议表示赞赏。

 ...
  List<Object> list = getList();
  return (List<Customer>) list;

编译器说：不能将List<Object> 转换为List<Customer>

Answer 1

您始终可以通过先将对象向上转换为 Object 来将任何对象转换为任何类型。在你的情况下：

(List<Customer>)(Object)list; 

您必须确保在运行时列表只包含客户对象。

批评者说这样的转换表明你的代码有问题；你应该能够调整你的类型声明来避免它。但是Java泛型太复杂了，并不完美。有时您只是不知道是否有一个很好的解决方案可以满足编译器的要求，即使您非常了解运行时类型并且知道您正在尝试做的事情是安全的。这种情况下，只要根据需要进行粗铸，就可以下班回家了。

Answer 2

根据您的其他代码，最佳答案可能会有所不同。 试试：

List<? extends Object> list = getList();
return (List<Customer>) list;

或

List list = getList();
return (List<Customer>) list;

但请记住，不建议进行这种未经检查的强制转换。

Answer 3

这是因为虽然客户是一个对象，但客户列表不是对象列表。如果是，那么您可以将 any 对象放入客户列表中。

Answer 4

使用 Java 8 Streams：

有时蛮力铸造很好：

List<MyClass> mythings = (List<MyClass>) (Object) objects

但这里有一个更通用的解决方案：

List<Object> objects = Arrays.asList("String1", "String2");

List<String> strings = objects.stream()
                       .map(element->(String) element)
                       .collect(Collectors.toList());

有很多好处，但如果您不确定列表包含什么内容，您可以更优雅地投射列表：

objects.stream()
    .filter(element->element instanceof String)
    .map(element->(String)element)
    .collect(Collectors.toList());

Answer 5

您可以使用双重转换。

return (List<Customer>) (List) getList();

Answer 6

另一种方法是使用 java 8 流。

    List<Customer> customer = myObjects.stream()
                                  .filter(Customer.class::isInstance)
                                  .map(Customer.class::cast)
                                  .collect(toList());

Answer 7

请注意，我不是 Java 程序员，但在 .NET 和 C# 中，此功能称为逆变或协变。我还没有深入研究这些东西，因为它们是 .NET 4.0 中的新内容，我没有使用它，因为它只是测试版，所以我不知道这两个术语中的哪一个描述了你的问题，但让我描述一下技术问题。

假设您被允许施放。请注意，我说的是 cast，因为这就是你所说的，但有两种操作是可能的，casting 和 converting。

转换意味着你得到了一个新的列表对象，但你说的是转换，这意味着你想暂时把一个对象当作另一种类型。

这就是问题所在。

如果允许以下情况会发生什么（注意，我假设在转换之前，对象列表实际上只包含 Customer 对象，否则即使在这个假设的 java 版本中转换也不起作用）：

List<Object> list = getList();
List<Customer> customers = (List<Customer>)list;
list.Insert(0, new someOtherObjectNotACustomer());
Customer c = customers[0];

在这种情况下，这将尝试将一个不是客户的对象视为客户，并且您会在某一时刻收到运行时错误，无论是在列表中还是来自分配。

然而，泛型应该为您提供类型安全的数据类型，例如集合，并且由于它们喜欢使用“保证”这个词，因此不允许这种类型的转换，以及随之而来的问题。

在 .NET 4.0 中（我知道，你的问题是关于 java 的），在一些非常特殊的情况下是允许的，编译器可以保证你所做的操作是安全的，但是在一般来说，这种类型的演员表是不允许的。 Java 也是如此，尽管我不确定是否有任何计划在 Java 语言中引入协变和逆变。

希望有比我更好的 java 知识的人可以告诉你 java 未来或实现的细节。

Answer 8

您应该只遍历列表并一个一个地转换所有对象

Answer 9

你可以这样做

List<Customer> cusList = new ArrayList<Customer>();

for(Object o: list){        
    cusList.add((Customer)o);        
}

return cusList; 

或 Java 8 方式

list.stream().forEach(x->cusList.add((Customer)x))

return cuslist;

Answer 10

你不能因为List<Object> 和List<Customer> 不在同一个继承树中。

您可以向您的List<Customer> 类添加一个新的构造函数，该类接受List<Object>，然后遍历列表，将每个Object 转换为Customer，并将其添加到您的集合中。请注意，如果调用者的 List<Object> 包含不是 Customer 的内容，则可能会发生无效转换异常。

泛型列表的意义在于将它们限制为特定类型。您正在尝试获取一个可以包含任何内容的列表（订单、产品等），然后将其压缩到一个只能包含客户的列表中。

Answer 11

正如其他人指出的那样，你不能保存它们，因为 List<Object> 不是 List<Customer>。你可以做的是在列表上定义一个视图来进行就地类型检查。使用Google Collections 将是：

return Lists.transform(list, new Function<Object, Customer>() {
  public Customer apply(Object from) {
    if (from instanceof Customer) {
      return (Customer)from;
    }
    return null; // or throw an exception, or do something else that makes sense.
  }
});

Answer 12

您可以创建一个新的 List 并向其中添加元素：

例如：

List<A> a = getListOfA();
List<Object> newList = new ArrayList<>();
newList.addAll(a);

Answer 13

最好的办法是创建一个新的List<Customer>，遍历List<Object>，将每个项目添加到新列表中，然后返回。

Answer 14

与上面的博卓类似。你可以通过这个方法在这里做一些解决方法（虽然我自己不喜欢它）：

public <T> List<T> convert(List list, T t){
    return list;
}

是的。它会将您的列表转换为所需的泛型类型。

在上面给定的情况下，你可以做一些这样的代码：

    List<Object> list = getList();
    return convert(list, new Customer());

Answer 15

根据您要对列表执行的操作，您甚至可能不需要将其转换为 List<Customer>。如果您只想将Customer 对象添加到列表中，您可以声明如下：

...
List<Object> list = getList();
return (List<? super Customer>) list;

这是合法的（嗯，不仅合法，而且正确 - 该列表是“客户的某些超类型”），如果您要将它传递给一个方法只需将对象添加到列表中，那么上述通用边界就足够了。

另一方面，如果您想从列表中检索对象并将它们强类型化为客户 - 那么您就不走运了，这是正确的。因为列表是List<Object>，所以不能保证内容是客户，所以您必须在检索时提供自己的演员表。 （或者真的，绝对地，加倍确保该列表将仅包含 Customers 并使用来自其他答案之一的双重转换，但请意识到您完全规避了您从中获得的编译时类型安全在这种情况下是泛型）。

从广义上讲，在编写方法时考虑尽可能广泛的通用范围总是好的，如果将其用作库方法，则更是如此。如果您只打算从列表中读取，请使用 List<? extends T> 而不是 List<T>，例如 - 这为您的调用者提供了更多更多的参数范围，他们可以传入并意味着它们是不太可能遇到与您在这里遇到的类似的可避免问题。

Answer 16

使用最简单的解决方案

(((List<Object>)(List<?>) yourCustomClassList))

Answer 17

List<Object[]> testNovedads = crudService.createNativeQuery(
            "SELECT ID_NOVEDAD_PK, OBSERVACIONES, ID_SOLICITUD_PAGO_FK FROM DBSEGUIMIENTO.SC_NOVEDADES WHERE ID_NOVEDAD_PK < 2000");

Convertir<TestNovedad> convertir = new Convertir<TestNovedad>();
Collection<TestNovedad> novedads = convertir.toList(testNovedads, TestNovedad.class);
for (TestNovedad testNovedad : novedads) {
    System.out.println(testNovedad.toString());
}

public Collection<T> toList(List<Object[]> objects, Class<T> type) {
    Gson gson = new Gson();
    JSONObject jsonObject = new JSONObject();
    Collection<T> collection = new ArrayList<>();
    Field[] fields = TestNovedad.class.getDeclaredFields();
    for (Object[] object : objects) {
        int pos = 0;
        for (Field field : fields) {
            jsonObject.put(field.getName(), object[pos++]);
        }
        collection.add(gson.fromJson(jsonObject.toString(), type));
    }
    return collection;
}