Java Using Comparators in combination with custom Comparators

Question

I want to sort the following example list which currently contains only Strings with my own custom rules.

ArrayList<String> coll = new ArrayList<>();
coll.add("just");
coll.add("sdsd");
coll.add("asb");
coll.add("b as");
coll.add("just");
coll.add("dhfga");
coll.add("jusht");
coll.add("ktsa");
coll.add("just");
coll.add("just");

I know that I could write my own comparator for this, but as I know that Java also got comparators which solve this problem partially I want to know how I can use the ones from the Java API in combination with my own one.

How should it be sorted?

The word just should always be the first word to appear in the list followed by all other words in alphabetical order.

Comparator.naturalOrder() sorts the list in alphabetical order, but how can I combine this comperator with a custom one which checks whether the word is just or something else.

Do you want to exclude repeated "just" word or not?

ZhekaKozlov
– ZhekaKozlov

2018-05-21 18:56:27 +00:00
Commented May 21, 2018 at 18:56 — ZhekaKozlov
– ZhekaKozlov, Commented May 21, 2018 at 18:56
I don't want to exclude them.

ShadowDragon
– ShadowDragon

2018-05-21 18:59:26 +00:00
Commented May 21, 2018 at 18:59 — ShadowDragon
– ShadowDragon, Commented May 21, 2018 at 18:59

ZhekaKozlov · Accepted Answer · 2018-05-21 19:01:05Z

11

You can do this something like that:

coll.sort(Comparator
    .comparingInt((String s) -> s.equals("just") ? 0 : 1) // Words "just" first
    .thenComparing(Comparator.naturalOrder())); // Then others

edited May 21, 2018 at 19:01

answered May 21, 2018 at 18:53

ZhekaKozlov

40.1k20 gold badges142 silver badges166 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Holger Over a year ago

Boolean is Comparable, so there is no need to deal with int values here: coll.sort(Comparator.comparing((String s) -> !s.equals("just")) .thenComparing(Comparator.naturalOrder()));

ZhekaKozlov Over a year ago

@Holger Right. Or even shorter: coll.sort(null); coll.sort(Comparator.comparing("just"::equals).reversed());

Holger Over a year ago

Yes, the sort operation is stable and null means “natural order”, but I’d avoid exploiting this; performing two sort operations might not be very efficient and using null as comparator undermines the generic type system, as you won’t have a compile-time check whether the elements are actually comparable. So I’d stay with the compound comparator with a single sort. Or do the “move "just" to front” without sorting like in my answer…

ZhekaKozlov Over a year ago

@Holger The null part can be fixed with Collections.sort(coll).

Holger Over a year ago

Or you stay with coll.sort(Comparator.naturalOrder()));

Holger · Accepted Answer · 2018-05-23 09:22:02Z

2

You could integrate the criteria into the comparator like

coll.sort(Comparator.comparing((String s) -> !s.equals("just"))
                    .thenComparing(Comparator.naturalOrder()));

or you separate the operations, first moving all occurrences of "just" to the front, then sorting the remaining elements only:

int howManyJust = 0;
for(int ix = 0, num = coll.size(); ix < num; ix++)
    if(coll.get(ix).equals("just") && ++howManyJust <= ix)
        Collections.swap(coll, ix, howManyJust-1);

coll.subList(howManyJust, coll.size()).sort(Comparator.naturalOrder());

while this may look more complicated, it is potentially more efficient, especially for larger lists.

answered May 23, 2018 at 9:22

Holger

301k43 gold badges483 silver badges827 bronze badges

Comments

Sean Patrick Floyd · Accepted Answer · 2018-05-21 18:59:42Z

0

The first step should be to define the custom order. I would do that by using a Map.

Map<String, Integer> orderMap = new HashMap<>();
int order = 0;
for(String specialWord : yourListOfSpecialWords){
    orderMap.put(specialWord, order++);
}

Now build comparator using that map and natural order as backup:

Comparator<String> comparator = ((Comparator<String>) (o1, o2) -> {
    int leftScore = orderMap.getOrDefault(o1, Integer.MAX_VALUE);
    int rightScore = orderMap.getOrDefault(o2, Integer.MAX_VALUE);
    return Integer.compare(leftScore, rightScore);
}).thenComparing(String::compareTo);

Use this comparator to sort your list. Note: you probably want to initialize your map only once and keep it in a constant or at least in a cache.

But if your special case is only a single word, as your update suggests, then this is of course overkill, and you should go with one of the other answers here.

answered May 21, 2018 at 18:59

Sean Patrick Floyd

301k72 gold badges481 silver badges598 bronze badges

1 Comment

Holger Over a year ago

You can avoid the code duplication by using Comparator.comparingInt((String o) -> orderMap.getOrDefault(o, Integer.MAX_VALUE)). Further, you don’t need the int order variable when you simply use orderMap.put(specialWord, orderMap.size());.

Collectives™ on Stack Overflow

Java Using Comparators in combination with custom Comparators

How should it be sorted?

3 Answers 3

5 Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

How should it be sorted?

3 Answers 3

5 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related