Расширенная сортировка Java 8

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

List<Activity> collect = list.stream().filter(activity -> activity.getParent() == null)
            .sorted((o1, o2) -> Long.compare(o2.children.stream().max(Comparator.comparing(Activity::getUpdateDate)).orElse(o2)
                    .getUpdateDate(), o1.children.stream().max(Comparator.comparing(Activity::getUpdateDate)).orElse(o1).getUpdateDate()))
            .collect(Collectors.toCollection(LinkedList::new));

Теперь создайте List, где будет храниться результат.

List<Activity> result = collect.stream().flatMap(set ->
        Stream.concat(Stream.of(set), set.getChildren().stream()
                .sorted((o1, o2) -> Long.compare(o2.getUpdateDate(), o1.getUpdateDate())))
    ).collect(Collectors.toCollection(LinkedList::new);

Вы получите List действий, как вы хотели, сначала родительский, затем дочерний, отсортированный по updateDate и т. д.

ОБНОВЛЕНИЕ

Если дерево имеет несколько уровней, вам придется рекурсивно получить все его дочерние элементы, а затем отсортировать их.

Метод получения всех детей Activity

public static Stream<Activity> getChildren(Activity activity) {
    List<Activity> activities = new LinkedList<>();
    recursiveCall(activities, activity);

    return activities.stream();
}

public static void recursiveCall(List<Activity> activities, Activity activity) {
    if(activity.children.isEmpty()) {
        return;
    }

    activity.getChildren().forEach(child -> {
        activities.add(child);
        recursiveCall(activities, child);
    });
}

И используйте это так:

list.stream().filter(activity -> activity.getParent() == null)
             .flatMap(YourClass::getChildren)
             .sorted...

Сделайте то же самое, когда вы собираете все результаты внутри потока.

вступление

Я начну с подхода SQL, а позже перейду к Java. (SQL — моя любовь).

SQL-подход

Я действительно не знаю, может ли это быть выполнено с помощью sql-запроса, надеюсь, кто-нибудь может предоставить мне решение.

Это может быть решено с использованием подхода SQL. Вот первый неоптимизированный пример:

Схема

create table Activity(
  name varchar(2),
  modificationDate int,
  parentActivity varchar(2)
);

insert into activity values('E1', 1, 'P1' );
insert into activity values('P2', 1, null );
insert into activity values('P1', 1, null );
insert into activity values('P3', 2, null );
insert into activity values('E1', 10, 'P1' );

Запрос (пример игрушки версии 1)

SELECT *
FROM
  ( SELECT a1.*,

      (SELECT max(modificationDate)
       FROM Activity a2
       GROUP BY a2.parentActivity
       HAVING a2.parentActivity = a1.name) AS childMod,
      1 AS isParent
    FROM Activity a1
    WHERE a1.parentActivity IS NULL
    UNION SELECT a3.*,
            (SELECT max(modificationDate)
             FROM Activity a4
             GROUP BY a4.name
             HAVING a3.name = a4.name), 0 AS isParent
          FROM Activity a3
          WHERE a3.parentActivity IS NOT NULL ) AS TEMP
ORDER BY childMod DESC,
  isParent DESC,
  temp.modificationDate DESC;

Вышеупомянутое можно улучшить, удалив некоторые из неэффективных подзапросов и вместо этого используя объединенные подзапросы (временную таблицу с псевдонимом) и/или унарные самосоединения.

Результат: http://i.prntscr.com/hnTeXtQzR5_BRui3TXJFSw.png

Запрос (финальный пример игрушки версии 2)

select
  *
FROM
  (

select name, modificationDate, childMaxMod, 1 as isParent from
Activity a1 left outer join
(select ParentActivity,  max(modificationDate)  as childMaxMod from Activity group by ParentActivity) as a2
on a1.name = a2.parentActivity
WHERE a1.parentActivity IS NULL

UNION

select name, modificationDate, childMaxMod, 0 as isParent from
  Activity a1 inner join
  (select ParentActivity,  max(modificationDate)  as childMaxMod from Activity group by ParentActivity) as a2
    on a1.parentActivity = a2.parentActivity
  ) as Temp
order by childMaxMod desc, isParent desc, modificationDate desc;

Java-подход

Решение Луки довольно хорошее и представляет собой чисто функциональное решение для Java 8. В качестве альтернативы я публикую свой собственный, но он использует императивное программирование на Java.

Класс активности

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

@Builder
@Data
@AllArgsConstructor
class Activity {
    long modificationDate;
    String name;
    Activity parentActivity;
    Set<Activity> subActivities = new HashSet();
    boolean active;
    public String debugString;

    public int hashCode(){
        return Objects.hash(modificationDate, name, subActivities, active);
    }
}

Код — раздел настройки

public static void main(String[] args) {
        //SpringApplication.run(MneServiceApplication.class, args);

        ArrayList<Activity> set = new ArrayList<Activity>();
        Activity p1 = Activity.builder().modificationDate(0).name("P1").subActivities(new HashSet<>()).build();
        Activity e1 = Activity.builder().modificationDate(10).name("E1").subActivities(new HashSet<>()).build();
        Activity e1_2 = Activity.builder().modificationDate(01).name("E1").subActivities(new HashSet<>()).build();

        Activity p3 = Activity.builder().modificationDate(02).name("P3").subActivities(new HashSet<>()).build();
        Activity p2 = Activity.builder().modificationDate(01).name("P2").subActivities(new HashSet<>()).build();

        p1.getSubActivities().add(e1);
        p1.getSubActivities().add(e1_2);
        e1.setParentActivity(p1);
        e1_2.setParentActivity(p1);

        set.add(p1);
        set.add(e1);
        set.add(e1_2);

        set.add(p3);
        set.add(p2);

Код — Логика (продолжение)

        Set<Activity> actives = set.stream()
                .sorted(Comparator.comparing(Activity::getModificationDate).reversed())
                .collect(Collectors.toCollection(LinkedHashSet::new));

        HashMap<Activity, Optional> maxChildModifications = new HashMap<Activity, Optional>();

        actives = actives.stream().sorted((Activity a, Activity b) -> {

            DecimalFormat decimalFormat = new DecimalFormat("0000000000000000");

            String comparisonValue_A = getComparisonString2(maxChildModifications, a, decimalFormat);
            String comparisonValue_B = getComparisonString2(maxChildModifications, b, decimalFormat);

            a.debugString = comparisonValue_A;
            b.debugString = comparisonValue_B;

            return comparisonValue_B.compareTo(comparisonValue_A);

        }).collect(Collectors.toCollection(LinkedHashSet::new));


        for(Activity activity:actives){
            System.out.println(activity.getName() + " " +  activity.getDebugString());
        }

    }

    private static String getComparisonString2(HashMap<Activity, Optional> maxChildModificationsLookup, Activity activity, DecimalFormat decimalFormat) {

        //Is a Parent or a Child
        Activity lookupActivity = activity.getParentActivity();;

        if(lookupActivity == null){ //It is a parent
            lookupActivity = activity;
        }

        String comparisonValue_B = "";
        Long isParent_B = 0L;
        Long maxChildMod_B = 0L;

            Optional<Activity> maxChildActivityOptional_B = getMaxChildModActivity(lookupActivity, maxChildModificationsLookup);

            if(maxChildActivityOptional_B.isPresent()) {
                maxChildMod_B = maxChildActivityOptional_B.get().getModificationDate();
            }

            if(activity.getSubActivities().size() > 0){
                isParent_B = 1L;    //Or use some other comparison system than the concatenated string
            }else{
                isParent_B = 0L;
            }

            comparisonValue_B = String.valueOf( decimalFormat.format(maxChildMod_B)).concat("-").concat(String.valueOf(isParent_B));
            comparisonValue_B  = comparisonValue_B .concat("-").concat(decimalFormat.format(activity.getModificationDate()));

        return comparisonValue_B;
    }

    private static Optional<Activity> getMaxChildModActivity(Activity a, HashMap<Activity, Optional> maxChildModificationsLookup) {

        Optional<Activity> result = maxChildModificationsLookup.get(a);

        if(result!=null){
            return result;
        }

        result =  a.getSubActivities().stream().max((Activity a2, Activity b2) ->
                        {
                            return new Long(a2.getModificationDate()).compareTo(b2.getModificationDate());
                        }
                );
        maxChildModificationsLookup.put(a, result);
        return result;
    }

Результат:

P1 0000000000000010-1-0000000000000000
E1 0000000000000010-0-0000000000000010
E1 0000000000000010-0-0000000000000001
P3 0000000000000000-0-0000000000000002
P2 0000000000000000-0-0000000000000001

Очевидно, что мое решение SQL и решения Luca для Java 8 более лаконичны и элегантны, чем приведенная выше реализация Java (хотя для удобочитаемости могут потребоваться некоторые изменения форматирования).