Необходимо сделать карту & lt; K, карту & lt; V, список & gt; & gt; & gt; & gt; & gt; & gt; & gt; [Дубликат]

Метод groupingBy имеет первый параметр Function<T,K> где:

@param <T> тип входных элементов

@param <K> ] тип ключей

Если мы заменим лямбда на анонимный класс в вашем коде, мы увидим что-то вроде этого:

people.stream().collect(Collectors.groupingBy(new Function<Person, int>() {
            @Override
            public int apply(Person person) {
                return person.getAge();
            }
        }));

Теперь измените выходной параметр <K>. В этом случае, например, я использовал парный класс из org.apache.commons.lang3.tuple для группировки по имени и возрасту, но вы можете создать свой собственный класс для фильтрации групп по мере необходимости.

people.stream().collect(Collectors.groupingBy(new Function<Person, Pair<Integer, String>>() {
                @Override
                public YourFilter apply(Person person) {
                    return Pair.of(person.getAge(), person.getName());
                }
            }));

Наконец, после замены с помощью лямбда-кода код выглядит следующим образом:

Map<Pair<Integer,String>, List<Person>> peopleByAgeAndName = people.collect(Collectors.groupingBy(p -> Pair.of(person.getAge(), person.getName()), Collectors.mapping((Person p) -> p, toList())));

Привет Вы можете просто объединить ваши groupingByKey, такие как

Map<String, List<Person>> peopleBySomeKey = people
                .collect(Collectors.groupingBy(p -> getGroupingByKey(p), Collectors.mapping((Person p) -> p, toList())));



//write getGroupingByKey() function
private String getGroupingByKey(Person p){
return p.getAge()+"-"+p.getName();
}

Мне нужно было сделать отчет для фирмы общественного питания, которая предлагает обеды для разных клиентов. Другими словами, кейтеринг может иметь или больше фирм, которые принимают заказы от общественного питания, и он должен знать, сколько обедов он должен производить каждый день для всех своих клиентов!

Чтобы заметить, я не использовал сортировку, чтобы не усложнять этот пример.

Это мой код:

@Test
public void test_2() throws Exception {
    Firm catering = DS.firm().get(1);
    LocalDateTime ldtFrom = LocalDateTime.of(2017, Month.JANUARY, 1, 0, 0);
    LocalDateTime ldtTo = LocalDateTime.of(2017, Month.MAY, 2, 0, 0);
    Date dFrom = Date.from(ldtFrom.atZone(ZoneId.systemDefault()).toInstant());
    Date dTo = Date.from(ldtTo.atZone(ZoneId.systemDefault()).toInstant());

    List<PersonOrders> LON = DS.firm().getAllOrders(catering, dFrom, dTo, false);
    Map<Object, Long> M = LON.stream().collect(
            Collectors.groupingBy(p
                    -> Arrays.asList(p.getDatum(), p.getPerson().getIdfirm(), p.getIdProduct()),
                    Collectors.counting()));

    for (Map.Entry<Object, Long> e : M.entrySet()) {
        Object key = e.getKey();
        Long value = e.getValue();
        System.err.println(String.format("Client firm :%s, total: %d", key, value));
    }
}

Посмотрите на код:

Вы можете просто создать функцию и позволить ей выполнять работу для вас, своего рода функциональный стиль!

Function<Person, List<Object>> compositeKey = personRecord ->
    Arrays.<Object>asList(personRecord.getName(), personRecord.getAge());

Теперь вы можете использовать это как карта:

Map<Object, List<Person>> map =
people.collect(Collectors.groupingBy(compositeKey, Collectors.toList()));

Приветствия!

Определите класс для определения ключа в вашей группе.

class KeyObj {

    ArrayList<Object> keys;

    public KeyObj( Object... objs ) {
        keys = new ArrayList<Object>();

        for (int i = 0; i < objs.length; i++) {
            keys.add( objs[i] );
        }
    }

    // Add appropriate isEqual() ... you IDE should generate this

}

Теперь в вашем коде

peopleByManyParams = people
            .collect(Collectors.groupingBy(p -> new KeyObj( p.age, p.other1, p.other2 ), Collectors.mapping((Person p) -> p, toList())));

У вас есть несколько вариантов. Самое простое - связать своих коллекционеров:

Map<String, Map<Integer, List<Person>>> map = people
    .collect(Collectors.groupingBy(Person::getName,
        Collectors.groupingBy(Person::getAge));

. Затем, чтобы получить список 18-летних людей по имени Фред, вы будете использовать:

map.get("Fred").get(18);

Второй вариант - определить класс, представляющий группировку. Это может быть внутри Person:

class Person {
    public static class NameAge {
        public NameAge(String name, int age) {
            ...
        }

        // must implement equals and hash function
    }

    public NameAge getNameAge() {
        return new NameAge(name, age);
    }
}

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

Map<NameAge, List<Person>> map = people.collect(Collectors.groupingBy(Person::getNameAge));

и искать с помощью

map.get(new NameAge("Fred", 18));

Наконец, если вы этого не сделаете хотите реализовать свой собственный групповой класс, тогда многие из фреймворков Java вокруг имеют класс pair, предназначенный именно для такого типа вещей. Например: apache commons pair Если вы используете одну из этих библиотек, вы можете сделать ключ к карте парой имен и возраста:

Map<Pair<String, Integer>, List<Person>> map =
    people.collect(Collectors.groupingBy(p -> Pair.of(p.getName(), p.getAge())));

и получить с помощью :

map.get(Pair.of("Fred", 18));

Лично мне очень не нравятся эти кортежные библиотеки. Они, кажется, являются полной противоположностью хорошему дизайну OO: они скрывают намерение, а не обнажают его.

Сказав, что вы можете объединить два вторых варианта, определив свой собственный класс группировки, но реализуя его, просто расширив Pair, что значительно облегчает вам работу по определению equals и т. д. и скрывает использование кортежа как удобную деталь реализации, как и любую другую коллекцию.

Удачи.