Группировка и сортировка вложенных объектов с использованием Java Streams

Вы можете создать промежуточную карту, сгруппировав данные по id, а затем преобразовав каждую запись в новый DTO объект.

Для этого вы можете использовать комбинацию встроенных сборщиков groupingBy() и flatMapping() для создания промежуточной карты.

Чтобы отсортировать элементы, сопоставленные каждому id, flatMapping() используется вместе с collectionAndThen().

public static void main(String[] args) {
    // input
    List<DTO> dtoList = List.of(
        new DTO(1L, List.of(new ItemDTO(1L, 1L), new ItemDTO(7L, 2L))),
        new DTO(2L, List.of(new ItemDTO(1L, 1L), new ItemDTO(2L, 2L))),
        new DTO(1L, List.of(new ItemDTO(10L, 3L), new ItemDTO(1L, 4L)))
    );
    
    List<DTO> result = dtoList.stream()
        .collect(Collectors.groupingBy(DTO::getId,
            Collectors.collectingAndThen(
            Collectors.flatMapping(dto -> dto.getItems().stream(), Collectors.toList()),
                (List<ItemDTO> items) -> {
                    items.sort(Comparator.comparing(ItemDTO::getPriority).reversed());
                    return items;
            })))
        .entrySet().stream()
        .map(entry -> new DTO(entry.getKey(), entry.getValue()))
        .collect(Collectors.toList());
    
    result.forEach(System.out::println);
}

Выход

DTO{id = 1, items = [ItemDTO{10, 3}, ItemDTO{7, 2}, ItemDTO{1, 1}, ItemDTO{1, 4}]}
DTO{id = 2, items = [ItemDTO{2, 2}, ItemDTO{1, 1}]}

Как отметил @shmosel, flatMapping() — одно из преимуществ Java 9. Вы также можете думать об этом как о напоминании, возможно, пришло время перейти к модульной системе, предоставляемой Java 9, и другим полезным функциям.

Версия, полностью соответствующая Ява 8, будет выглядеть так:

List<DTO> result = dtoList.stream()
    .collect(Collectors.groupingBy(DTO::getId,
        Collectors.collectingAndThen(
            Collectors.mapping(DTO::getItems, Collectors.toList()),
                (List<List<ItemDTO>> items) ->
                    items.stream().flatMap(List::stream)
                        .sorted(Comparator.comparing(ItemDTO::getPriority).reversed())
                        .collect(Collectors.toList())
                    )))
            .entrySet().stream()
            .map(entry -> new DTO(entry.getKey(), entry.getValue()))
            .collect(Collectors.toList());

Я бы начал с простой группировки, чтобы получить карту Map<Long,List<DTO>>, пропустить записи этой карты и сопоставить каждую с новым DTO. Вы можете извлечь метод/функцию для сортировки ItemDTO:

import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

....


Function<List<DTO>, List<ItemDTO>> func =
        list -> list.stream()
                .map(DTO::getItems)
                .flatMap(List::stream)
                .sorted(Comparator.comparing(ItemDTO::getPriority,Comparator.reverseOrder()))
                .collect(Collectors.toList());

List<DTO> result = 
        dtoList.stream()
               .collect(Collectors.groupingBy(DTO::getId))
               .entrySet().stream()
               .map(entry -> new DTO(entry.getKey(), func.apply(entry.getValue())))
               //.sorted(Comparator.comparingLong(DTO::getId)) if the resulting list need to be sorted by id
               .collect(Collectors.toList());

Имхо, это самый простой способ. Я предполагаю, что у вас есть соответствующие геттеры, определенные для ваших классов.

• просто скрыто на карту, указанную на идентификаторе.
• объединить соответствующие списки
• и вернуть значения и преобразовать в ArrayList.

List<DTO> results = new ArrayList<>(dtoList.stream().collect(
        Collectors.toMap(DTO::getId, dto -> dto, (a, b) -> {
            a.getItems().addAll(b.getItems());
            return a;
        })).values());

Затем просто отсортируйте их на месте в соответствии с вашими требованиями. Это занимает не больше времени, чем в конструкции потока, но, на мой взгляд, менее загромождено.

for (DTO d: results) {   
    d.getItems().sort(Comparator.comparing(ItemDTO::getPriority)
       .reversed());
}

results.forEach(System.out::println);

печатает (используя простой toString для двух классов)

DTO[1, [ItemDTO[10, 3], ItemDTO[7, 2], ItemDTO[1, 1], ItemDTO[1, 4]]]
DTO[2, [ItemDTO[2, 2], ItemDTO[1, 1]]]

Примечание: List.of неизменяем, поэтому вы не можете их изменить. Я бы использовал new ArrayList<>(List.of(...)) в конструкции вашего списка.