generic List type conversions

[Pat Farrell]

I have an interface, Human, and a bunch of subclasses: Users, Managers, Clowns, etc.

My utility functions return

List<? extends Human>

Some of the public functions want to return List of specific types, say a List<User>

What is the cleanest way to downcast the result so we can return List<User> when the worker function returns a

List<? extends Human> which is actually a List< humans who are actually User object>

[Jesper de Jong]

I'm not sure I understand your question exactly, but you can just cast it:

import java.util.ArrayList;
import java.util.List;
class Human { }
class User extends Human { }
public class JavaRanch {
public static List<? extends Human> util() {
List<User> result = new ArrayList<User>();
result.add(new User());
return result;
}
public static void main(String[] args) {
// Note: Cast is necessary here
List<User> users = (List<User>) util();
}
}

There's no way to avoid a cast somewhere in this case.

[Rob Spoor]

But the cast will issue a warning, because the List may be a List<Manager> instead of a List<User>.

Pat, do you need to add objects to your List? If no, then using List<? extends User> is just fine.

[Jesper de Jong]

If the warning is a problem, you can suppress the warning by using the @SuppressWarnings annotation:

public static void main(String[] args) {
// Note: Cast is necessary here
@SuppressWarnings("unchecked")
List<User> users = (List<User>) util();
}

[Pat Farrell]

 

Rob Prime wrote:But the cast will issue a warning, because the List may be a List<Manager> instead of a List<User>.

Pat, do you need to add objects to your List? If no, then using List<? extends User> is just fine.

Right, the list may actually contain Ranchers, since Ranchers are Human (usually)
Only some functions explicitly return List<Rancher> others return List<User>

Not sure I grok your suggestion, are you saying that the getUsers() function should return List<? extends User>

[Rob Spoor]

I meant List<? extends Human> of course.

How about using a Class as an extra parameter?

public <T extends Human> List<T> getUsers(Class<T> cls, ...)

If you pass User.class the method returns List<User>, if you pass Manager.class the method returns List<Manager>, etc. A quick example:

public <T extends Human> List<T> filter(Class<T> cls, Collection<?> collection)
{
List<T> list = new ArrayList<T>(collection.size());
for (Object o: collection)
{
if (cls.isInstance(o))
{
list.add(cls.cast(o)); // cls.cast(o) turns o into a T without a warning; will throw a ClassCastException if o isn't an instance
}
}
return list;
}

Collection<?> collection = ...;
List<User> users = filter(User.class, collection);
List<Manager> managers = filter(Manager.class, collection);

[Pat Farrell]

 

Rob Prime wrote:How about using a Class as an extra parameter?

It works, but I really dislike using the Class as an extra parameter to fix flaws in the way Generics work, so I do it only when I really, really have to.

Its a minor thing, but shows how they grafted generics onto Java long after the initial design. The curse of backwards compatibility.

I'll just use the cast as someone mentioned upthread.

Thanks to all

[Rob Spoor]

You could also use type inference if your body can deal with it:

public <T extends Human> List<T> util(...)

List<User> users = util();
List<Managers> managers = util();
List<String> strings = util(); // oh wait, String does not extend Human ;)

The biggest problem with this code is that you cannot use T for creating objects or arrays or any type checking; instanceof T is not possible, nor are new T() and new T[].