Сборщики Java 8 группируются по и в отдельный класс

Я полагаю, что один из способов:

 persons
   .stream()          
   .collect(Collectors.collectingAndThen(Collectors.groupingBy(
           Person::getName),
           map -> {
               return map.entrySet()
                         .stream()
                         .map(en -> new GroupedPerson(en.getKey(), en.getValue()))
                         .collect(Collectors.toList());
}));

Или вы можете использовать toMap:

persons  
   .stream()
   .collect(Collectors.toMap(
            Person::getName,
            x -> {
                  List<Person> l = new ArrayList<>();
                  l.add(x);
                  return new GroupedPerson(x.getName(), l);
            },
            (left, right) -> {
                 left.getAs().addAll(right.getAs());
                 return left;
            }))
   .values();

Да, вы можете это сделать. Вот как это сделать:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class GroupedStream {

    public static void main(String[] args) {
        List<GroupedPerson> groupedPersons = Arrays.asList("john harry john harry sam jordon bill steve bill".split(" "))
            .stream()
            .map(name -> new Person(name))
            .map(person -> new Object[] {person.name, new ArrayList<>()})
            .collect(Collectors.toMap(tuple-> (String) tuple[0], tuple -> (List<Person>) tuple[1] ))
            .entrySet()
            .stream()
            .map(entry -> new GroupedPerson(entry.getKey(), entry.getValue()))
            .collect(Collectors.toList());
    }

    static class Person {
        public final String name;

        public Person(String name) {
            super();
            this.name = name;
        }

    }

    static class GroupedPerson {

        public final String name;
        public final List<Person> person;

        public GroupedPerson(String name, List<Person> person) {
            this.name = name;
            this.person = person;
        }

    }

}

если вы измените свою модель GroupedPerson, чтобы она выглядела примерно так:

public class GroupedPerson {
    private String name;
    private List<Person> people;

    public GroupedPerson(String name) {
        this.name = name;
        people = new ArrayList<>();
    }

    public void addPeople(List<Person> people) {
        this.people.addAll(people);
    }

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

    public List<Person> getPeople(){
        return Collections.unmodifiableList(people);
    }

    public String getName() {
        return name;
    }    
}

Затем у вас может быть Collection из GroupedPerson объектов с именами и всеми соответствующими людьми с этим конкретным именем, например:

Collection<GroupedPerson> resultSet = peopleList
                .stream()
                .collect(Collectors.toMap(Person::getName,
                        p -> {
                            GroupedPerson groupedPerson = new GroupedPerson(p.getName());
                            groupedPerson.addPerson(p);
                            return groupedPerson;
                        },
                        (p, p1) -> {
                            p.addPeople(p1.getPeople());
                            return p;
                        }
                )).values();

если по какой-то причине вы не хотите, чтобы тип получателя был Collection<T>, вы можете преобразовать его в определенный тип коллекции, если считаете это целесообразным, просто выполнив действие.

List<GroupedPerson> result = new ArrayList<>(resultSet);