How do you cast a List of supertypes to a List of subtypes

Question

For example  lets say you have two classes   public class TestA    public class TestB extends TestA     I have a method that returns a List lt TestA gt  and I would like to cast all the objects in that list to TestB so that I end up with a List lt TestB gt

User · Answer

This is possible due to type erasure  You will find that  List lt TestA gt  x   new ArrayList lt TestA gt     List lt TestB gt  y   new ArrayList lt TestB gt     x getClass   equals y getClass        true   Internally both lists are of type List lt Object gt   For that reason you can t cast one to the other - there is nothing to cast

User · Answer

This should would work  List lt TestA gt  testAList   new ArrayList lt  gt     List lt TestB gt  testBList   new ArrayList lt  gt    testAList addAll new ArrayList lt  gt  testBList

User · Answer

The best safe way is to implement an AbstractList and cast items in implementation  I created ListUtil helper class   public class ListUtil       public static  lt TCastTo  TCastFrom extends TCastTo gt  List lt TCastTo gt  convert final List lt TCastFrom gt  list                return new AbstractList lt TCastTo gt                   Override             public TCastTo get int i                                return list get i                               Override             public int size                                 return list size                                        public static  lt TCastTo  TCastFrom gt  List lt TCastTo gt  cast final List lt TCastFrom gt  list                return new AbstractList lt TCastTo gt                   Override             public TCastTo get int i                                return  TCastTo list get i                               Override             public int size                                 return list size                                       You can use cast method to blindly cast objects in list and convert method for safe casting   Example   void test List lt TestA gt  listA  List lt TestB gt  listB        List lt TestB gt  castedB   ListUtil cast listA      all items are blindly casted     List lt TestB gt  convertedB   ListUtil  lt TestB  TestA gt convert listA      wrong cause TestA does not extend TestB     List lt TestA gt  convertedA   ListUtil  lt TestA  TestB gt convert listB      OK all items are safely casted

User · Answer

Simply casting to List lt TestB gt  almost works  but it doesn t work because you can t cast a generic type of one parameter to another  However  you can cast through an intermediate wildcard type and it will be allowed  since you can cast to and from wildcard types  just with an unchecked warning    List lt TestB gt  variable    List lt TestB gt   List lt   gt   collectionOfListA

User · Answer

When you cast an object reference you are just casting the type of the reference  not the type of the object  casting won t change the actual type of the object   Java doesn t have implicit rules for converting Object types   Unlike primitives   Instead you need to provide how to convert one type to another and call it manually   public class TestA    public class TestB extends TestA       TestB TestA testA               build a TestB from a TestA          List lt TestA gt  result         List lt TestB gt  data   new List lt TestB gt     for TestA testA   result       data add new TestB testA        This is more verbose than in a language with direct support  but it works and you shouldn t need to do this very often

User · Answer

You can use the selectInstances method in Eclipse Collections  This will involved creating a new collection however so will not be as efficient as the accepted solution which uses casting   List lt CharSequence gt  parent           Arrays asList  1   2   3   new StringBuffer  4     List lt String gt  strings           Lists adapt parent  selectInstancesOf String class   Assert assertEquals Arrays asList  1   2   3    strings     I included StringBuffer in the example to show that selectInstances not only downcasts the type  but will also filter if the collection contains mixed types   Note  I am a committer for Eclipse Collections

User · Answer

Quite strange that manually casting a list is still not provided by some tool box implementing something like    SuppressWarnings    unchecked    rawtypes     public static  lt T extends E  E gt  List lt T gt  cast List lt E gt  list        return  List  list      Of course  this won t check items one by one  but that is precisely what we want to avoid here  if we well know that our implementation only provides the sub-type

User · Answer

You really can t    Example is taken from this Java tutorial  Assume there are two types A and B such that B extends A  Then the following code is correct         B b   new B        A a   b    The previous code is valid because B is a subclass of A  Now  what happens with List lt A gt  and List lt B gt      It turns out that List lt B gt  is not a subclass of List lt A gt  therefore we cannot write       List lt B gt  b   new ArrayList lt  gt         List lt A gt  a   b     error  List lt B gt  is not of type List lt A gt    Furthermore  we can t even write      List lt B gt  b   new ArrayList lt  gt         List lt A gt  a    List lt A gt  b     error  List lt B gt  is not of type List lt A gt       To make the casting possible we need a common parent for both List lt A gt  and List lt B gt   List lt   gt  for example  The following is valid       List lt B gt  b   new ArrayList lt  gt         List lt   gt  t    List lt B gt  b      List lt A gt  a    List lt A gt  t    You will  however  get a warning  You can suppress it by adding  SuppressWarnings  unchecked   to your method

User · Answer

The problem is that your method does NOT return a list of TestA if it contains a TestB  so what if it was correctly typed   Then this cast   class TestA    class TestB extends TestA    List lt   extends TestA gt  listA  List lt TestB gt  listB    List lt TestB gt   listA    works about as well as you could hope for  Eclipse warns you of an unchecked cast which is exactly what you are doing  so meh    So can you use this to solve your problem   Actually you can because of this   List lt TestA gt  badlist   null     Actually contains TestBs  as specified List lt   extends TestA gt  talist   badlist      Umm  works List lt TextB gt  tblist    List lt TestB gt  talist     TADA    Exactly what you asked for  right  or to be really exact   List lt TestB gt  tblist    List lt TestB gt   List lt   extends TestA gt   badlist    seems to compile just fine for me

User · Answer

Since this is a widely referenced question  and the current answers mainly explain why it does not work  or propose hacky  dangerous solutions that I would never ever like to see in production code   I think it is appropriate to add another answer  showing the pitfalls  and a possible solution     The reason why this does not work in general has already been pointed out in other answers  Whether or not the conversion is actually valid depends on the types of the objects that are contained in the original list  When there are objects in the list whose type is not of type TestB  but of a different subclass of TestA  then the cast is not valid      Of course  the casts may be valid  You sometimes have information about the types that is not available for the compiler  In these cases  it is possible to cast the lists  but in general  it is not recommended   One could either          cast the whole list or     cast all elements of the list   The implications of the first approach  which corresponds to the currently accepted answer  are subtle  It might seem to work properly at the first glance  But if there are wrong types in the input list  then a ClassCastException will be thrown  maybe at a completely different location in the code  and it may be hard to debug this and to find out where the wrong element slipped into the list  The worst problem is that someone might even add the invalid elements after the list has been casted  making debugging even more difficult    The problem of debugging these spurious ClassCastExceptions can be alleviated with the Collections checkedCollection family of methods     Filtering the list based on the type  A more type-safe way of converting from a List lt Supertype gt   to a List lt Subtype gt  is to actually filter the list  and create a new list that contains only elements that have certain type  There are some degrees of freedom for the implementation of such a method  e g  regarding the treatment of null entries   but one possible implementation may look like this          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  lt T gt  List lt T gt  filter List lt   gt  listA  Class lt T gt  c        List lt T gt  listB   new ArrayList lt T gt         for  Object a   listA                if  c isInstance a                         listB add c cast a                        return listB      This method can be used in order to filter arbitrary lists  not only with a given Subtype-Supertype relationship regarding the type parameters   as in this example      A list of type  List lt Number gt   that actually     contains Integer  Double and Float values List lt Number gt  mixedNumbers        new ArrayList lt Number gt  Arrays asList 12  3 4  5 6f  78        Filter the list  and create a list that contains    only the Integer values  List lt Integer gt  integers   filter mixedNumbers  Integer class    System out println integers      Prints  12  78

User · Answer

casting of generics is not possible  but if you define the list in another way it is possible to store TestB in it   List lt   extends TestA gt  myList   new ArrayList lt TestA gt       You still have type checking to do when you are using the objects in the list

User · Answer

if you have an object of the class TestA  you can t cast it to TestB  every TestB is a TestA  but not the other way   in the following code   TestA a   new TestA    TestB b    TestB  a    the second line would throw a ClassCastException   you can only cast a TestA reference if the object itself is TestB  for example   TestA a   new TestB    TestB b    TestB  a    so  you may not always cast a list of TestA to a list of TestB

User · Answer

You cannot cast List lt TestB gt  to List lt TestA gt  as Steve Kuo mentions BUT you can dump the contents of List lt TestA gt  into List lt TestB gt   Try the following   List lt TestA gt  result   new List lt TestA gt     List lt TestB gt  data   new List lt TestB gt     result addAll data     I ve not tried this code so there are probably mistakes but the idea is that it should iterate through the data object adding the elements  TestB objects  into the List  I hope that works for you

User · Answer

With Java 8  you actually can  List lt TestB gt  variable   collectionOfListA      stream        map e - gt   TestB  e       collect Collectors toList

User · Answer

class MyClass     String field     MyClass String field        this field   field          Test public void testTypeCast       List lt Object gt  objectList   Arrays asList new MyClass  1    new MyClass  2        Class lt MyClass gt  clazz   MyClass class    List lt MyClass gt  myClassList   objectList stream          map clazz  cast         collect Collectors toList        assertEquals objectList size    myClassList size       assertEquals objectList  myClassList       This test shows how to cast List lt Object gt  to List lt MyClass gt   But you need to take an attention to that objectList must contain instances of the same type as MyClass  And this example can be considered when List lt T gt  is used  For this purpose get field Class lt T gt  clazz in constructor and use it instead of MyClass class

User · Answer

The only way I know is by copying   List lt TestB gt  list   new ArrayList lt TestB gt        Arrays asList           testAList toArray new TestB 0

User · Answer

I think you are casting in the wrong direction though    if the method returns a list of TestA objects  then it really isn t safe to cast them to TestB   Basically you are asking the compiler to let you perform TestB operations on a type TestA that does not support them

[java] How do you cast a List of supertypes to a List of subtypes?

Examples related to java

Examples related to list

Examples related to generics

Examples related to collections

Examples related to casting