mjhjmtu

I have a list of objects and I want to sort it alphabetically by an attribute. But I want to add an exception rule if this attribute matches a specific string. For example:

public class Car 
 String name;

List<Car> cars = asList(
 new Car("Unassigned"), 
 new Car("Nissan"), 
 new Car("Yamaha"), 
 new Car("Honda"));

List<Car> sortedCars = cars
 .stream
 .sorted(Comparator.comparing(Car::getName))
 .collect(Collectors.toList());

If cars.name == "Unassigned" then this car should remain at the end of the list and the result would be:

[Car<Honda>, Car<Nissan>, Car<Yamaha>, Car<Unassigned>]

 List<Car> sortedCars = cars
 .stream()
 .sorted(Comparator.comparing(
 Car::getName,
 Comparator.comparing((String x) -> x.equals("Unassigned"))
 .thenComparing(Comparator.naturalOrder())))
 .collect(Collectors.toList());

There are a lot of things going on here. First I am using Comparator.comparing(Function, Comparator); then (String x) -> x.equals("Unassigned") which actually compares a Boolean (that is Comparable); then the fact that (String x) is used - as this type witness is used to correctly infer the types...

The most direct and and easy-to-read solution is probably to write a custom comparator that implements your sorting logic.

You can still use the Comparator.comparing method to make it a bit prittier, though:

public static final String UNASSIGNED = "Unassigned";

List<Car> cars = List.of(
 new Car("Unassigned"), 
 new Car("Nissan"), 
 new Car("Yamaha"), 
 new Car("Honda"));

List<Car> sortedCars = cars.stream()
 .sorted(Comparator.comparing(Car::getName, (name1, name2) -> 
 if (name1.equals(name2)) return 0;
 if (name1.equals(UNASSIGNED)) return 1;
 if (name2.equals(UNASSIGNED)) return -1;
 return name1.compareTo(name2);
 ))
 .collect(Collectors.toList());

Also, it's good style to use a named constant for special values like your "Unassigned".

Also, note that if you don't need to keep the unsorted cars list, then you can sort that list in place instead of using a stream:

cars.sort(UNASSIGNED_COMPARATOR);

One way to possibly do that would be using partitioning as:

Map<Boolean, List<Car>> partitionedCars = cars
 .stream()
 .collect(Collectors.partitioningBy(a -> a.getName().equals("Unassigned")));

List<Car> sortedCars = Stream.concat(partitionedCars.get(Boolean.FALSE).stream()
 .sorted(Comparator.comparing(Car::getName)), partitionedCars.get(Boolean.TRUE).stream())
 .collect(Collectors.toList());

You could just replace "Unassigned" with an end-of-alphabet string in your comparator.

Comparator.comparing(car -> car.getName().equals("Unassigned") ? "ZZZ" : car.getName())

Alternatively, just remove all instances of "Unassigned" and add however many to the end of the List after. For example:

int numberOfUnassigned = 0;
for (Iterator<Car> iterator = sortedCars.iterator(); iterator.hasNext();) 
 String str = iterator.next().getName();
 if (str.equals("Unassigned")) 
 iterator.remove();
 numberOfUnassigned++;
 

And then add the number of numberOfUnassigned to the end.