Compare two lists based on highest value and subsequent values?

I have two lists of:

List<Person> persons;

each Person has the attribute - score

e.g.

list1:

person.score = 3
person.score = 5
person.score = 8

list2:

person.score = 8
person.score = 4
person.score = 7

I want to compare each list to find the highest score in each. If both highest are the same, then I want to compare the second highest etc and so on.

How can I do so?

You can make a copy of each List, sort these copies, then compare them element by element.

Comparator<List<Person>> comp = (a, b) -> {
    List<Person> s1 = a.stream().sorted(Comparator.comparingInt(Person::getScore).reversed()).toList(), 
                 s2 = b.stream().sorted(Comparator.comparingInt(Person::getScore).reversed()).toList();
    for (int i = 0; i < Math.min(a.size(), b.size()); i++) {
        int c = Integer.compare(s1.get(i).getScore(), s2.get(i).getScore());
        if (c != 0) return c;
    }
    return Integer.compare(a.size(), b.size());
};

Define a comparator to compare the lists. After, sorting each list, The comparator short circuits as soon corresponding scores are unequal, returning the value of the the last comparison. Otherwise, if the two lists are equal or if if their sizes are different, the shortest list will return as the smaller.

Details

Since the score is the target of the comparison, I decided to grab it early and place in int arrays which are sorted. Then I iterate over the arrays in reverse order to ensure I am testing the largest elements first (IntStreams can't take a comparator for sorting and I didn't want to box the int values).

Iterating over the lists, the scores are compared and the result is mapped to the stream. Then the result of the comparison (-1,0, or 1) is filtered to ignore zero values, capturing the result in an OptionalInt.

Then either the OptionalInt value is returned, or the comparison of the array sizes. Then, all comparisons being equal, the smaller array length would return -1, larger 1, and equal lengths 0

Comparator<List<Person>> listComp = (lst1, lst2) -> {
    int[] scores1 = lst1.stream().mapToInt(Person::getScore).sorted()
            .toArray();
    int[] scores2 = lst2.stream().mapToInt(Person::getScore).sorted()
            .toArray();
    
    OptionalInt diff = IntStream
            .iterate(Math.min(scores1.length-1, scores2.length-1),
                    i -> i >= 0, i -> i-1)
            .map(i -> Integer.compare(scores1[i], scores2[i]))
            .filter(delta -> delta != 0).findFirst();

    return diff.orElse(Integer.compare(scores1.length, scores2.length));
};

Demos

Some Data - comparing every two lists in the list of lists to each other. For demo purposes, I am using a record with a modified toString().

record Person(int getScore) {
     @Override
     public String toString() {
         return "%d".formatted(getScore);
     }
}

List<List<Person>> lists = List.of(
        // first is smaller
        List.of(new Person(3), new Person(5), new Person(8)),
        List.of(new Person(8), new Person(4), new Person(7)),
        // equal lists
        List.of(new Person(3), new Person(7), new Person(8)),
        List.of(new Person(8), new Person(3), new Person(7)),
        // first is smaller due to length
        List.of(new Person(3), new Person(7), new Person(8)),
        List.of(new Person(8), new Person(3), new Person(7),
                new Person(2)));

To compare the lists, use int result = listComp.compare(list1, list2);

 int v;
 for (int i = 0; i < lists.size(); i += 2) {
     System.out.println(lists.get(i)
             + ((v = listComp.compare(lists.get(i), lists.get(i + 1))) > 0
                     ? " > "
                     : (v < 0) ? " < " : " == ")
             + lists.get(i + 1));
 }

prints the following:

[3, 5, 8] < [8, 4, 7]
[3, 7, 8] == [8, 3, 7]
[3, 7, 8] > [8, 3, 7, 2]



</details>