I'm always stubbing my toes against this in Java - I have a collection of one type that I want to cast to a collection of a super-type (or interface) instead so that I can add more varied things to it.
Java 7:
public class CollectionCastTest {
class B implements Runnable {
@Override
public void run() { ; }
}
public void main(String... args) {
// First we'll try with a list that looks like it's allowed
// to contain anything between B and Object.
List<B> bList = new ArrayList<>();
bList.add(new B());
// Java error: incompatible types
// List<Runnable> rList1 = bList;
// Java error: unchecked cast
// List<Runnable> rList2 = (List<Runnable>) bList;
// Works, but has a time cost
List<Runnable> rList3 = new ArrayList<>();
rList3.addAll(bList);
// Just works!
List<? extends Runnable> rList4 = bList;
// Interestingly, this doesn't work.
// Java error: addAll in List cannot be applied to...
// List<? extends Runnable> rList5 = new ArrayList<>();
// rList5.addAll(bList);
// Primitive arrays can cast most things, but using them takes time.
List<Runnable> rList6 = Arrays.asList(
bList.toArray(new Runnable[bList.size()]));
List<? extends Runnable> rList7 = Arrays.asList(
bList.toArray(new Runnable[bList.size()]));
}
}
Scala
Scalas collections are covariant, meaning that you can substitute a sub-type and get away with it. It's certainly powerful.
object CollectionCastTest {
trait A {
def hello:String
}
class B extends A {
override def hello = "Hello World!"
}
def main(args: Array[String]) {
val bList = List[B](new B())
// Works
val aList1:List[A] = bList
// Works
val aList2:List[A] = bList match {
case l:List[A] => l
case _ => throw new ClassCastException
}
val aList3:List[A] = List[A]() ++ bList
}
}
But does Scala know that these lists are the same?
scala> val bList = List(new B())
bList: List[B] = List(B@555301c4)
scala> val aList:List[A] = List(new B())
aList: List[A] = List(B@23014460)
scala> aList == bList
res6: Boolean = falseWhoops - no. This is because it is using referential equality for B. Why? Because I didn't define an equals() method on A or B so it uses the default equals(). Let's use the same B() in both lists and see what happens:
scala> val b = new B()
b: B = B@4ffe5c31
scala> val bList = List(b)
bList: List[B] = List(B@4ffe5c31)
scala> val aList:List[A] = List[A](b)
aList: List[A] = List(B@4ffe5c31)
scala> aList == bList
res0: Boolean = trueUsing different objects for B() are possible too, if we make Scala use an equality test based on the fields of the object instead of it's address. We could define equals() methods that inspect the object's fields, but this is the default implementation of equals() for case classes, so we can make this simple change:
- class B extends A {
+ case class B extends A {then
scala> val bList = List(new B())
bList: List[B] = List(B@555301c4)
scala> val aList:List[A] = List(new B())
aList: List[A] = List(B@23014460)
scala> aList == bList
res6: Boolean = true