Java-返回特定类型T的所有对象的集合，其中T传递给方法

Question

I'm looking to write a method that given an original set A and a type T returns a new set containing all the objects of type T in A.

I've set up a test with a Person class and its subclasses Man and Woman , along with a World class to house the set of Person objects.

public class World {

    public World() {
        this.people = new HashSet<Person>();
    }

    public void addPerson(Person person) {
        getAllPeople().add(person);
    }

    public void removePerson(Person person) {
        getAllPeople().remove(person);
    }

    public Set<Person> getAllPeople() {
        return people;
    }

    public <T> Set<T> getAllPeople(Class<T> cls) {
        Set<T> ItemsOfClass = new HashSet<>();
        // Incompatible type error on next line
        ItemsOfClass = getAllPeople().stream().filter(object -> object.getClass().equals(cls)).collect(Collectors.toSet());
        return ItemsOfClass;
    }

    public Set<Person> people;
}

So I'd like getAllPeople(Man.class) to return a new set of Man objects.

My current implementation of getAllPeople is based on the following answers: https://stackoverflow.com/a/17840541 and
https://stackoverflow.com/a/16727596
although I can't figure out how they are supposed to fit together, if at all.

I'm not good at generics so any and all explanation/advice is welcome.

Answer 1

You have to cast your element inside stream first:

public <T> Set<T> getAllPeople(Class<T> clazz) {
    return obj.stream().filter(object -> object.getClass().equals(clazz))
              .map(v -> (T) v).collect(Collectors.toSet());
}

Answer 2

Here the problem is very probably the assignment :

 ItemsOfClass = getAllPeople().stream().filter(object -> object.getClass().equals(T)).collect(Collectors.toSet());

The created Set by the collect() method is not typed as Set<T> even if you filtered only object which the class is T .
Actually you iterate on Person . So you collect a Set<Person>
So you are constraint to cast explicitly Set<Person> to Set<T> such as :

 ItemsOfClass = (Set<T>) getAllPeople().stream()
                                       .filter(object -> object.getClass().equals(T))
                                       .collect(Collectors.toSet());

or with Class::cast such as :

 ItemsOfClass =  getAllPeople().stream()
                              .filter(object -> object.getClass().equals(T))
                              .map(T::cast)
                              .collect(Collectors.toSet());

Answer 3

You have a Stream<Person> that you are trying to collect into a Set<T> . But a Stream<Person> will produce a Set<Person> .

You can map your Person instances to T instances and get a Stream<T> .

public <T> Set<T> getAllPeople(Class<T> cls) {
    Set<T> itemsOfClass = getAllPeople().stream()
              .filter(cls::isInstance)
              .map(cls::cast)
              .collect(Collectors.toSet());
    return itemsOfClass;
}

This uses cls::isInstance as a predicate to find elements of the class cls , and cls::cast as a mapper to regard your elements as T instances instead of Person instances.