Ако говорим само за Лист - стриймни го, достъпваш пропъртито и го манипулираш с израз. Не става ли?

Ако е някакъв Map с Лист, нещо такова:  Ако пропъртито ти е value, го достъпваш като value. Ако ти е key - като key. Веднъж достъпено, можеш да оперираш с него съвсем нормално. Не знам конкретния ти случай, но някой ламбда израз няма ли да свъши работа?

Примерно за map<String, Integer>

map.entrySet().stream().sorted((e1, e2) -> {

int sort = Integer.compare(e1.getValue(), e2.getValue())

return sort;

})

Да речем пък имаш map<Integer, List<Double>> и искаш да ги подредиш по дължина на листа

същата работа но малка промяна в реда Integer.compare. Ако искаш да са в ascending order на първи ред пишеш в скобите e1, e2 а ако е в descending ги обръщаш e2, e1

1.   map.entrySet().stream().sorted((e1, e2) -> {

2.   int sort = Integer.compare(e1.getValue().size, e2.getValue().size)

3.   return sort;

4. })

Или пък лист от double/Integer

List<Integer> qwer

qwer.stream().sorted() - това ги сортира в ascending order тоест 1 4 5 7 40 60 ...

Дай някакъв конкретен пример ако горните не ти помогнаха.

Номерът е да се опиташ да пресъздадеш ефектът на ".compareTo" методът. Документацията на метода гласи че връща "a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object."

Нека има клас, който има поле age (и гетър за това поле) и искаш да сортираш по това поле. Пресъздаването на .compareTo методът ще изглежда така:

studentList = studentList.stream()
                .sorted((s1, s2) -> {
                    int comparisonResult = s1.getAge() - s2.getAge();
                    return comparisonResult;
                }).collect(Collectors.toList());

Може да се направи и с Integer.compare. Но ако сравняваш double стойности, то тогава може да вкараш и малко повече логика в сравнението. Напр. да искаш да се сравняват до втори знак. Т.е. при сравнение на 4.0000001 и 4.0000002 ако искаш резултатът да са равни, то стриймът ще изглежда някак така:

studentList = studentList.stream()
                .sorted((s1, s2) -> {
                    double difference = s1.getGrade() - s2.getGrade();
                    if (difference < 0.01d)
                        return 0;

                    else return Double.compare(s1.getGrade(), s2.getGrade());
                })
                .collect(Collectors.toList());

Последният начин, по който се сещам че могат да се сравняват обекти по дадено поле е да си overload-неш compareTo методът. Това става като напишеш "implements Comparable<SameClass>". Ето пример:

public class Student implements Comparable<Student> {
    private int age;
    private Double grade;

    @Override
    public int compareTo(Student anotherStudent) {
        int comparisonResult = this.age - anotherStudent.age;
        if (comparisonResult == 0) //if they are equal
            comparisonResult = Double.compare(this.grade, anotherStudent.grade);

        return comparisonResult;
    }
}

И после извикваш .compareTo методът на твоят обект.
 

studentList = studentList.stream()
                .sorted((s1, s2) -> s1.compareTo(s2))
                .collect(Collectors.toList());