Como você lança uma lista de supertipos para uma lista de subtipos?

Por exemplo, digamos que você tenha duas classes:

public class TestA {}
public class TestB extends TestA{}

Eu tenho um método que retorna List<TestA>ae gostaria de converter todos os objetos nessa lista para TestBque eu acabe com a List<TestB>.

Simplesmente converter List<TestB>quase funciona; mas não funciona porque você não pode converter um tipo genérico de um parâmetro para outro. No entanto, você pode transmitir através de um tipo curinga intermediário e isso será permitido (já que você pode transmitir para e a partir de tipos curinga, apenas com um aviso desmarcado):

List<TestB> variable = (List<TestB>)(List<?>) collectionOfListA;

a conversão de genéricos não é possível, mas se você definir a lista de outra maneira, será possível armazenar o TestB nela:

List<? extends TestA> myList = new ArrayList<TestA>();

Você ainda tem a verificação de tipo para fazer quando estiver usando os objetos na lista.

Você realmente não pode *:

Exemplo é retirado deste tutorial Java

Suponha que existem dois tipos Ae Btal B extends A. O código a seguir está correto:

    B b = new B();
    A a = b;

O código anterior é válido porque Bé uma subclasse de A. Agora, o que acontece com List<A>e List<B>?

Acontece que List<B>não é uma subclasse de, List<A>portanto, não podemos escrever

    List<B> b = new ArrayList<>();
    List<A> a = b; // error, List<B> is not of type List<A>

Além disso, nem podemos escrever

    List<B> b = new ArrayList<>();
    List<A> a = (List<A>)b; // error, List<B> is not of type List<A>

*: Para possibilitar a transmissão, precisamos de um pai comum para ambos List<A>e List<B>: List<?>por exemplo. O seguinte é válido:

    List<B> b = new ArrayList<>();
    List<?> t = (List<B>)b;
    List<A> a = (List<A>)t;

Você receberá, no entanto, um aviso. Você pode suprimi-lo adicionando @SuppressWarnings("unchecked")ao seu método.

Com o Java 8, você realmente pode

List<TestB> variable = collectionOfListA
    .stream()
    .map(e -> (TestB) e)
    .collect(Collectors.toList());

Eu acho que você está lançando na direção errada ... se o método retornar uma lista de TestAobjetos, não será realmente seguro lançá-los TestB.

Basicamente, você está solicitando ao compilador que permita executar TestBoperações em um tipo TestAque não as suporta.

_{Como essa é uma pergunta amplamente referenciada e as respostas atuais explicam principalmente por que ela não funciona (ou propõe soluções perigosas e hacky que eu nunca gostaria de ver no código de produção), acho apropriado adicionar outra resposta, mostrando as armadilhas e uma possível solução.}

A razão pela qual isso não funciona em geral já foi apontada em outras respostas: A validade ou não da conversão depende dos tipos de objetos contidos na lista original. Quando houver objetos na lista cujo tipo não seja do tipo TestB, mas de uma subclasse diferente de TestA, a conversão não será válida.

Obviamente, os lançamentos podem ser válidos. Às vezes, você tem informações sobre os tipos que não estão disponíveis para o compilador. Nesses casos, é possível lançar as listas, mas, em geral, não é recomendado :

Pode-se também ...

• ... lançar a lista inteira ou
• ... lança todos os elementos da lista

As implicações da primeira abordagem (que corresponde à resposta atualmente aceita) são sutis. Pode parecer funcionar corretamente à primeira vista. Mas se houver tipos errados na lista de entrada, a ClassCastExceptionserá lançada, talvez em um local completamente diferente no código, e pode ser difícil depurar isso e descobrir onde o elemento errado entrou na lista. O pior problema é que alguém pode até adicionar os elementos inválidos após a lista ser lançada, tornando a depuração ainda mais difícil.

O problema de depurar esses espúrios ClassCastExceptionspode ser aliviado com a Collections#checkedCollectionfamília de métodos.

Filtrando a lista com base no tipo

Uma maneira mais segura de se converter de um List<Supertype> para um List<Subtype>é filtrar a lista e criar uma nova lista que contenha apenas elementos que tenham determinado tipo. Existem alguns graus de liberdade para a implementação de um método desse tipo (por exemplo, com relação ao tratamento de nullentradas), mas uma possível implementação pode ser assim:

/**
 * Filter the given list, and create a new list that only contains
 * the elements that are (subtypes) of the class c
 * 
 * @param listA The input list
 * @param c The class to filter for
 * @return The filtered list
 */
private static <T> List<T> filter(List<?> listA, Class<T> c)
{
    List<T> listB = new ArrayList<T>();
    for (Object a : listA)
    {
        if (c.isInstance(a))
        {
            listB.add(c.cast(a));
        }
    }
    return listB;
}

Este método pode ser usado para filtrar listas arbitrárias (não apenas com um determinado relacionamento Subtype-Supertype em relação aos parâmetros de tipo), como neste exemplo:

// A list of type "List<Number>" that actually 
// contains Integer, Double and Float values
List<Number> mixedNumbers = 
    new ArrayList<Number>(Arrays.asList(12, 3.4, 5.6f, 78));

// Filter the list, and create a list that contains
// only the Integer values:
List<Integer> integers = filter(mixedNumbers, Integer.class);

System.out.println(integers); // Prints [12, 78]

Você não pode lançar List<TestB>a List<TestA>como Steve Kuo menciona, mas você pode despejar o conteúdo de List<TestA>dentro List<TestB>. Tente o seguinte:

List<TestA> result = new List<TestA>();
List<TestB> data = new List<TestB>();
result.addAll(data);

Eu não tentei esse código, provavelmente há erros, mas a idéia é que ele itere através do objeto de dados, adicionando os elementos (objetos TestB) à Lista. Espero que funcione para você.

A melhor maneira segura é implementar AbstractListe lançar itens na implementação. Eu criei a ListUtilclasse auxiliar:

public class ListUtil
{
    public static <TCastTo, TCastFrom extends TCastTo> List<TCastTo> convert(final List<TCastFrom> list)
    {
        return new AbstractList<TCastTo>() {
            @Override
            public TCastTo get(int i)
            {
                return list.get(i);
            }

            @Override
            public int size()
            {
                return list.size();
            }
        };
    }

    public static <TCastTo, TCastFrom> List<TCastTo> cast(final List<TCastFrom> list)
    {
        return new AbstractList<TCastTo>() {
            @Override
            public TCastTo get(int i)
            {
                return (TCastTo)list.get(i);
            }

            @Override
            public int size()
            {
                return list.size();
            }
        };
    }
}

Você pode usar o castmétodo para converter objetos às cegas na lista e no convertmétodo para transmitir com segurança. Exemplo:

void test(List<TestA> listA, List<TestB> listB)
{
    List<TestB> castedB = ListUtil.cast(listA); // all items are blindly casted
    List<TestB> convertedB = ListUtil.<TestB, TestA>convert(listA); // wrong cause TestA does not extend TestB
    List<TestA> convertedA = ListUtil.<TestA, TestB>convert(listB); // OK all items are safely casted
}

A única maneira que eu sei é copiando:

List<TestB> list = new ArrayList<TestB> (
    Arrays.asList (
        testAList.toArray(new TestB[0])
    )
);

Quando você lança uma referência ao objeto, está apenas lançando o tipo da referência, não o tipo do objeto. a conversão não altera o tipo real do objeto.

Java não possui regras implícitas para converter tipos de objetos. (Ao contrário dos primitivos)

Em vez disso, você precisa fornecer como converter um tipo para outro e chamá-lo manualmente.

public class TestA {}
public class TestB extends TestA{ 
    TestB(TestA testA) {
        // build a TestB from a TestA
    }
}

List<TestA> result = .... 
List<TestB> data = new List<TestB>();
for(TestA testA : result) {
   data.add(new TestB(testA));
}

Isso é mais detalhado do que em um idioma com suporte direto, mas funciona e você não precisa fazer isso com muita frequência.

se você tiver um objeto da classe TestA, não poderá convertê-lo TestB. Todo TestBé um TestA, mas não o contrário.

no seguinte código:

TestA a = new TestA();
TestB b = (TestB) a;

a segunda linha lançaria a ClassCastException.

você só pode converter uma TestAreferência se o próprio objeto for TestB. por exemplo:

TestA a = new TestB();
TestB b = (TestB) a;

portanto, nem sempre você pode converter uma lista TestAem uma lista de TestB.

Você pode usar o selectInstancesmétodo nas Coleções Eclipse . Isso envolverá a criação de uma nova coleção, no entanto, portanto, não será tão eficiente quanto a solução aceita que usa a conversão.

List<CharSequence> parent =
        Arrays.asList("1","2","3", new StringBuffer("4"));
List<String> strings =
        Lists.adapt(parent).selectInstancesOf(String.class);
Assert.assertEquals(Arrays.asList("1","2","3"), strings);

Eu incluí StringBufferno exemplo para mostrar que selectInstancesnão apenas o tipo de downcasts, mas também filtrará se a coleção contiver tipos mistos.

Nota: Sou um colaborador das Coleções Eclipse.

Isso é possível devido ao apagamento do tipo. Vai descobrir que

List<TestA> x = new ArrayList<TestA>();
List<TestB> y = new ArrayList<TestB>();
x.getClass().equals(y.getClass()); // true

Internamente, ambas as listas são do tipo List<Object>. Por esse motivo, você não pode converter um para o outro - não há nada para transmitir.

O problema é que seu método NÃO retorna uma lista de TestA se ele contém um TestB, e daí se ele foi digitado corretamente? Então este elenco:

class TestA{};
class TestB extends TestA{};
List<? extends TestA> listA;
List<TestB> listB = (List<TestB>) listA;

funciona tão bem quanto você poderia esperar (Eclipse avisa sobre um elenco não verificado, que é exatamente o que você está fazendo, então meh). Então, você pode usar isso para resolver seu problema? Na verdade, você pode por causa disso:

List<TestA> badlist = null; // Actually contains TestBs, as specified
List<? extends TestA> talist = badlist;  // Umm, works
List<TextB> tblist = (List<TestB>)talist; // TADA!

Exatamente o que você pediu, certo? ou para ser realmente exato:

List<TestB> tblist = (List<TestB>)(List<? extends TestA>) badlist;

parece compilar muito bem para mim.

class MyClass {
  String field;

  MyClass(String field) {
    this.field = field;
  }
}

@Test
public void testTypeCast() {
  List<Object> objectList = Arrays.asList(new MyClass("1"), new MyClass("2"));

  Class<MyClass> clazz = MyClass.class;
  List<MyClass> myClassList = objectList.stream()
      .map(clazz::cast)
      .collect(Collectors.toList());

  assertEquals(objectList.size(), myClassList.size());
  assertEquals(objectList, myClassList);
}

Este teste mostra como transmitir List<Object>para List<MyClass>. Mas você precisa prestar atenção, pois objectListdeve conter instâncias do mesmo tipo que MyClass. E este exemplo pode ser considerado quando List<T>é usado. Para esse fim, pegue o campo Class<T> clazzno construtor e use-o em vez de MyClass.class.

Isso deveria funcionar

List<TestA> testAList = new ArrayList<>();
List<TestB> testBList = new ArrayList<>()
testAList.addAll(new ArrayList<>(testBList));

É bastante estranho que a transmissão manual de uma lista ainda não seja fornecida por alguma caixa de ferramentas que implementa algo como:

@SuppressWarnings({ "unchecked", "rawtypes" })
public static <T extends E, E> List<T> cast(List<E> list) {
    return (List) list;
}

Obviamente, isso não verificará os itens um por um, mas é exatamente isso que queremos evitar aqui, se soubermos que nossa implementação fornece apenas o subtipo.