首先对整数列表进行排序，然后在java 8中按10整除排序

Question

I have arraylist containing {3,10,17,9,20,15,40,30, 55} so I want to sort this method so that all the divisible by 10 values are come in last in sorted list aftet the sorting the list. ie o/p should be like this : {3, 9, 15, 17, 55, 10, 20, 30, 40}

I have tried with below code but a I am not able to successfully sort out this list,

List<Integer> list = Arrays.asList(3,10,17,9,20,55,40,30);

list.stream().sorted(((Comparator<Integer>) (v1, v2) -> Integer.compare(v1, v2))).sorted((Comparator<Integer>) (v1, v2) -> v1 % 10 == 0 ? 0 : -1).forEach(System.out::println);

output of above code is: 55 17 9 3 10 20 30 40

Thanks,

Answer 1

It looks like you want to logically divide the numbers into two groups and sort each group separately.

You can either split the list based on the division by 10 criteria, and perform the sort on the 2 sub-lists separately, or you can achieve the same result with a single Comparator that checks whether the 2 compared numbers belong to the same group:

• if they don't, determine which should come first based on the group

• if they do, compare them within their group by their value

   list.stream() .sorted((v1, v2) -> { if (v1 % 10 == 0) { if (v2 % 10 == 0) return Integer.compare(v1, v2); // both are divisible by 10 // sort by value else return 1; // only v1 is divisible by 10, should come after v2 } else { if (v2 % 10 != 0) return Integer.compare(v1, v2); // both are not divisible by 10 // sort by value else return -1; // only v2 is divisible by 10, should come after v1 } }) .forEach(System.out::println); 

Output:

3
9
17
55
10
20
30
40

Answer 2

There are two things to know.

First, grouping by a particular predicate when sorting is quiet easy when you know that Boolean values are comparable since Java 5. So you can use

Comparator.comparing(i -> i%10==0)

to sort numbers dividable by ten to the end.

Second, you can chain comparators using thenComparing , so that elements being equal according to the first comparator will be sorted according to the next one.

Together, the operation becomes

List<Integer> list = Arrays.asList(3,10,17,9,20,55,40,30);

list.stream()
    .sorted(Comparator.comparing((Integer i) -> i%10==0)
                      .thenComparing(Comparator.naturalOrder()))
    .forEach(System.out::println);

Note that the complete operation requires an explicitly typed parameter for the first lambda expression ( (Integer i) ) due to limitations in the type inference.

You could also write

list.stream()
    .sorted(Comparator.comparing((Integer i) -> i%10==0)
                      .thenComparingInt(i -> i))
    .forEach(System.out::println);

though, I prefer reusing the already existing comparator Comparator.naturalOrder() when applicable.

Answer 3

Well to achieve this you need to:

• First divide the list into two lists, one with numbers divisible by 10 and the second with those who aren't.
• Then just sort them separately
• And finally append the first to second one.

This is how should be your code:

List<Integer> dividedBy10 = list.stream()
    .filter(p -> p % 10 == 0).collect(Collectors.toList());
Collections.sort(dividedBy10);

List<Integer> others = list.stream()
    .filter(p -> p % 10 != 0).collect(Collectors.toList());
Collections.sort(others);

//Then append the first list to the sorted one
others.addAll(dividedBy10);

Edit:

Or like @yahya suggested you can just sort your original list, then filter it into lists and append these two lists later:

Collections.sort(list);

List<Integer> dividedBy10 = list.stream()
    .filter(p -> p % 10 == 0).collect(Collectors.toList());

List<Integer> others = list.stream()
    .filter(p -> p % 10 != 0).collect(Collectors.toList());
others.addAll(dividedBy10);

Answer 4

Currently you are negating the numbers that are not divisible by 10 as a hack to get them out first. But that will reverse the order of those numbers, which accounts for your output!

You need to be more careful when comparing the divisible by 10 numbers, so the comparator ranks them lower than other numbers. Something like this will work:

list.stream().sorted(((Comparator<Integer>) (v1, v2) -> {
    if (v1 % 10 == 0 && v2 % 10 == 0) {
        return Integer.compare(v1, v2);
    } else if (v1 % 10 == 0) {
        // v2 is effectively larger
        return -1;
    } else if (v2 % 10 == 0) {
        // v1 is effectively larger
        return 1;
    }
    return Integer.compare(v1, v2);
}))/*etc*/

Answer 5

A single sort is required :

list.stream().sorted(((Comparator<Integer>) (v1, v2) -> {

    // if both are divisible by 10, you sort them with their order natural
    if (v1 % 10 == 0 && v2 % 10 == 0) {
       return Integer.compare(v1, v2);
    }

    // if only the first argument is divisible by 10, it is always at the end
    else if (v1 % 10 == 0) {
      return 1;
    }       

    // if only the second argument is divisible by 10, it is always at the end
    else if (v2 % 10 == 0) {
      return -1;
    }

    // in other cases, you sort by natural order
    return Integer.compare(v1, v2);
}))
    .forEach(System.out::println);

Here is the output :

3 9 17 55 10 20 30 40

Answer 6

(a,b) -> (a<b?-1:a==b?0:1) + (a%10==0?2:0) - (b%10==0?2:0)

How this works:

(a<b?-1:a==b?0:1) normally compares the integers (Has a weight of 1)

+ (a%10==0?2:0) Checks if the first integer is divisible by 10 (Has a weight of 2)

- (b%10==0?2:0) Checks if the second integer is divisible by 10 (Has a weight of 2)

---

As long as Integer.compare only returns -1,0,1 you could use this (But as @Holger points out there is no guaranty)

(a,b) -> Integer.compare(a, b) + (a%10==0?2:0) - (b%10==0?2:0)

Answer 7

You only have three return values:

• Integer.compare(a, b) if both values are divisible by 10 and when they are not
• > 0 if first value is divisible by 10
• < 0 else

---

list.sort((a, b) -> {
  if ((a % 10 == 0) == (b % 10 == 0)) {
    return a.compareTo(b);
  } else {
    return a % 10 == 0 ? 1 : -1;
  }
});

Or if you prefer non readable code

list.sort((a, b) -> (a % 10 == 0) == (b % 10 == 0) ? a.compareTo(b) : a % 10 == 0 ? 1 : -1);