1

I am new to the idea of comparators and I am looking into ways to sort strings. In my code, below, I have made a list and sorted through it using the Collections.sort() method. Here is the code:

public class ComparatorTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        List<String> list = new ArrayList<String>();
        list.addAll(Arrays.asList("Bob Stone", "Jordan Brand", "Bob Mass", "Dylan Walsh","Tom Mavis","Bob Ganley"));
        System.out.println("Before sort "+ list);
        Collections.sort(list);
        System.out.println("After sort "+ list);
    }



}

How can I modify this to sort using a given String to sort by, instead of just sorting alphabetically? For example, if I give the string BOBthen all the BOB's will move to the front of the list. I did ask a sorting question before but I misunderstood the idea of sorting and it was more of a filtering question (java sort list of strings by string value entered by a user). This question is different from my earlier question because now I am trying to actually sort and rearrange the Strings instead of filtering them.

Improve this question
8
  • What happens to the elements that don't match the criteria? Commented Sep 18, 2019 at 22:15
  • 1
    You could make your own Comparator implementation that sorts the way you want and call the Collections.sort method that takes a Comparator as a second argument. Commented Sep 18, 2019 at 22:17
  • Are you asking about sorting by a special collation that has certain unusual rules about uppercase/lowercase? Your Question is quite unclear as written now. Voting to close as unclear. Commented Sep 18, 2019 at 22:24
  • @munk I am planning on having those placed behind the last element of BOB Commented Sep 18, 2019 at 22:33
  • Are you asking about case-sensitivity or not? Commented Sep 18, 2019 at 22:38

3 Answers 3

Reset to default
4

You can use the Boolean.compare method to check if the strings begin with "Bob":

Comparator<String> bobsFirst = (a, b) -> Boolean.compare(b.startsWith("Bob"), a.startsWith("Bob"));

Comparing them this way around (b first, then a) puts things starting with "Bob" first.

Then, tie break using natural ordering:

Comparator<String> comparator = bobsFirst.thenComparing(a -> a);

Note that startsWith is case sensitive. To ignore the case of "Bob", you could replace b.startsWith("Bob") (similarly for a) with:

 b.regionMatches(true, 0, "Bob", 0, 3)
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

The first thing you need to do is understand the rules, for example, what happens when:

  • Both the left hand side and right hand side start with "Bob"?
  • What happens when neither the left hand side and right hand side start with "Bob"?
  • Do you care about matching the case?
  • Do you only care about first names or should you included the surname or do you want that to be configurable?

A simple implementation might look something like...

public class NameComparator implements Comparator<String> {

    private String name;

    public NameComparator(String name) {
        this.name = name;
    }

    @Override
    public int compare(String lhs, String rhs) {
        if (lhs.startsWith(name) && rhs.startsWith(name)) {
            return lhs.compareTo(rhs);
        } else if (lhs.startsWith(name)) {
            return -1;
        } else if (lhs.startsWith(name)) {
            return 1;
        }

        return lhs.compareTo(rhs);
    }
}

Now, this does a case match (so bob is not the same as Bob) and will sub-sort all the "Bobs" within their own group

As you see, five seconds of thinking has brought up a lot of possible ways to sort the list, so you need to be aware of your options, which ones you might want to be customisable and which ones you want to be fixed.

You can call this example using something like...

Collections.sort(list, new NameComparator("Bob"));

Which will, based on your available input, output...

Before sort [Bob Stone, Jordan Brand, Bob Mass, Dylan Walsh, Tom Mavis, Bob Ganley]
After sort [Bob Ganley, Bob Mass, Bob Stone, Dylan Walsh, Jordan Brand, Tom Mavis]
Improve this answer

6 Comments

All of your if/else would be much more easily written using Boolean.compare.
Thanks for your answer! This is much simpler to follow than the tutorials ive been trying to use online for Comparators
@AndyTurner Undoubtedly, but give then level of the OPs experience, I went for readability and understandability first ;) - I'm sure there are more ways to skin this cat
@MadProgrammer can you explain the compare method so I can be sure that I fully understand how it's working, please
Essentially, Collections.sort is calling the compare method with two items, which it needs to know how they relate to each other, so it can perform it's overall operation - this is essentially a delegation pattern, the work is been delegated. Based on the requirements of the Collections.sort API, you are return either a positive or negative value to indicate how you want the values to be treated (or how they compare to each other based on your custom need).
|
2

Collator class

The rules used in comparing and sorting natural language (human language) are formally referred to as collation.

In Java, the rules of any collation are defined in a class implementing Collator class. Usually, its subclass RulesBasedCollator is used for comparing/sorting. The CollatorProvider class is an SPI (service provider interface) for providing a registered Collator implementation. Recent versions of Java default to collation definitions provided by the Unicode Consortium in their Common Locale Data Repository (CLDR).

Presumably, you are free to build your own Collator implementation with such special rules as you desire.

Be aware that collation is a very complicated field, with rules widely varying by human language and by cultural norms. If you are only concerned with American English, you may have few issues. But if you deal with other languages, cultures, or alternate characters such as © or emoji, well, here be dragons.

Improve this answer

5 Comments

Interesting, I'd love to see an example!
This does look very interesting, also very complex!
@PaPaB1nG0 Yes, implementing a Collator would be complex, but a good solution if you have many such rules, or if those rules may be changing/expanding. If you can make the streams-based solution by Andy Turner work for you, do that instead.
@PaPaB1nG0 Another thought… If your Question is not really about names, and you only showed "Bob" with names as a simplification of your actual business data, then let me suggest the best solution would be looking at the bigger problem. If you have business objects being represented by mere strings whose alphabetical ordering is inconvenient, you should not be relying on such strings. You should be defining a class to properly represent the business object and its requisite parts. In that class define a Comparator/Comparable to properly sort by those parts.
@BasilBourque Thank you for your consideration I will definitely take note of that for future reference :)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.