Converting a collection of subtype to collection of supertype

Question

What's the best way in Java to convert a collection of a subtype to a collection of a supertype ?

class A {}
class B extends A {}

final A a = new B(); // OK.

final Collection<B> bs = Arrays.asList(new B());
final Collection<A> as1 = bs; // <- Error
final Collection<A> as2 = (Collection<A>) (Collection<?>) bs; // <- Unchecked cast warning
final Collection<A> as3 = bs.stream().collect(Collectors.toList()); // Browses through all the elements :-/

I have to implement a method (defined in an interface) that returns a Collection<A> while the concrete result I get is a Collection<B> .

Why do you want to convert collection of subtype to collection of supertype? — hellzone, Jan 26 '18 at 14:30
Collection is not interchangeable with Collection in that way, see https://stackoverflow.com/questions/47313816/java-generics-in-list-return-type-on-a-method-inherited-from-multiple-interfaces/47314161#47314161 You can add a bunch of B's to a Collection though — Taylor, Jan 26 '18 at 14:33
@hellzone Well, I stated it : because of the method signature. — Emmanuel Guiton, Jan 26 '18 at 14:36

score 2 · Accepted Answer · answered Jan 26 '18 at 14:30

2

Easiest way, assuming you don't need to modify the collection through as1:

Collection<A> as1 = Collections.unmodifiableCollection(bs);

If you do need to modify the collection, the only safe thing to do is to copy it:

Collection<A> as1 = new ArrayList<>(bs);

answered Jan 26 '18 at 14:30

Andy Turner

137,514
11
162
243

I like this because it is clean (and indeed, I do not need to modify the list). But copying or casting : what is the most efficient ? – Emmanuel Guiton Jan 26 '18 at 14:38
@EmmanuelGuiton I believe `Collection extends A> as = bs;` is most efficient and safe. – Venkata Raju Jan 26 '18 at 14:47
@VenkataRaju `Collection` is required (not `Collection extends A>`). – Emmanuel Guiton Jan 26 '18 at 14:50
1

@EmmanuelGuiton it is more efficient to cast, because once that cast is done, it's never checked again. If you use the unmodifiableCollection approach, every call to that collection goes through an extra layer of dispatch. It's a question of whether the perceived performance benefits of casting outweigh the risks of losing type safety. – Andy Turner Jan 26 '18 at 15:09

score -1 · Answer 2 · answered Jan 26 '18 at 14:31

-1

Additional suggestion :

public static <A> Collection<A> coerce(final Collection<? extends A> col)
{
    return (Collection<A>) col;
}

answered Jan 26 '18 at 14:31

Emmanuel Guiton

1,315
13
24

1

There's a reason why Java stops you doing the assignment directly. Circumventing its protections is irresponsible. – Andy Turner Jan 26 '18 at 14:31
1

Even if this were the right thing to do, you're using a generic type parameter (``), so the `A` in this method's signature is not the class `A`. Replace it with `T` and you'll see what I mean. – Michael Jan 26 '18 at 14:33
Indeed this solution works only if the collection is not mutated after the cast. @Michael the type parameter is not the A presented in the question but the solution is nonetheless correct for any subclass relation `S extends T` (albeit omitting mutations) – J. Fraudeau Jan 26 '18 at 15:09
@O.Gre it works after casting *if you don't add anything into the collection that wasn't already in the collection (aside from `null`)*. Some mutations can be performed with no problem. – Andy Turner Jan 26 '18 at 15:10
@O.Gre I didn't say it wouldn't work. It's just misleading. – Michael Jan 29 '18 at 08:20

Converting a collection of subtype to collection of supertype

2 Answers2