How to sort a String collection that contains numbers?

Question

I have a String Vector that contains data like this :

5:34, 5:38, 17:21, 22:11, ...

If i try to merge this using Collections.sort( ... ); it will appear like this :

17:21, 22:11, 5:34, 5:38

Actually i want it to appear like this :

5:34, 5:38, 17:21, 22:11

So i want to sort the elements according to the number before the colon ":" then if some elements have the same number before ":" then sort them according to the number after the ":".

What is the simplest way to do this ?

Answer 1

The correct way to do this is to not store non-string values as strings.

The data in your collection has some structure and rules and can't be any arbitrary string. Therefore you should not use the String data type.

Let's define a type called TwoNumbers (because I don't know what the type should represent, even if I could guess):

class TwoNumbers implements Comparable<TwoNumbers> {
    private final int num1;
    private final int num2;

    public TwoNumbers(int num1, int num2) {
        if (num1 <= 0 || num2 <= 0) {
            throw new IllegalArgumentException("Numbers must be positive!");
        }
        this.num1 = num1;
        this.num2 = num2;
    }

    public static TwoNumbers parse(String s) {
        String[] parts = s.split(":");
        if (parts.length != 2) {
            throw new IllegalArgumentException("String format must be '<num>:<num>'");
        }
        try {
            return new TwoNumbers(Integer.parseInt(parts[0]), Integer.parseInt(parts[0]));
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("parts must be numeric!", e);
        }
    }

    public int getNum1() {
        return num1;
    }

    public int getNum2() {
        return num2;
    }

    @Override
    public int compareTo(TwoNumbers o) {
        if (o == null) {
            return 1;
        }
        int diff = Integer.compare(o.num1, this.num1);
        if (diff == 0) {
            diff = Integer.compare(o.num2, this.num2);
        }
        return diff;
    }
}

The compareTo method exists as the implementation of the Comparable interface: it defines how objects of this type are ordered.

I've used the final fields (and don't provide setters), because the class implements immutable objects.

This way you can directly sort your data without an additional Comparator and don't need to distribute all that "split and parse" code all over your program. Instead you have a single class that's responsible for handling that specific format and all the other pieces of code can just use that.