How to Create a Java Comparator for Custom String Sorting with Numeric Comparison

Question

How can I implement a Java Comparator that sorts strings based on a specific rule for numeric values while ignoring other integers?

@Override
public int compare(String s1, String s2) {
    // Custom comparison logic goes here
}

Answer

To create a Java Comparator that sorts strings with a specific requirement of comparing numeric parts if they are located in the middle and framed by the same prefix and suffix, we can follow a structured approach. This includes traversing the string to identify matching parts and extracting numerical segments for comparison.

import java.util.Comparator;

public class CustomStringComparator implements Comparator<String> {
    @Override
    public int compare(String s1, String s2) {
        // Trimming spaces and splitting strings for processing
        s1 = s1.trim();
        s2 = s2.trim();

        // Finding the smallest length to avoid IndexOutOfBound
        int minLength = Math.min(s1.length(), s2.length());

        // Step 1: Identify prefix
        int i = 0;
        while (i < minLength && s1.charAt(i) == s2.charAt(i)) {
            i++;
        }

        // Step 2: Identify suffix
        int j = 1;
        while (j <= minLength && s1.charAt(s1.length() - j) == s2.charAt(s2.length() - j)) {
            j++;
        }

        // If i counts equal length of both strings, they are identical in prefix and suffix
        if (i + j > s1.length() && i + j > s2.length()) {
            return 0;
        }

        // Step 3: Extract middle part
        String middlePart1 = s1.substring(i, s1.length() - j + 1).trim();
        String middlePart2 = s2.substring(i, s2.length() - j + 1).trim();

        // Step 4: Check if the middle parts represent integers
        if (middlePart1.matches("\d+") && middlePart2.matches("\d+")) {
            // Numeric comparison
            return Integer.compare(Integer.parseInt(middlePart1), Integer.parseInt(middlePart2));
        }

        // Lexical comparison if not numeric
        return s1.compareTo(s2);
    }
}

Causes

Strings have shared prefixes and suffixes.
Middle sections of the strings are numeric and need comparison.
Presence of other numeric values that should not be confused with the primary numeric comparison.

Solutions

Walk through the strings from the start to find the first differing character.
Walk from the end to locate the last matching character.
Extract the middle segment and determine if it's numeric (using regex).
Compare the numeric values if they are both integers, otherwise proceed with lexicographical comparison.

Common Mistakes

Mistake: Assuming all integers have spaces around them.

Solution: Ensure to handle leading/trailing spaces in the substring extraction.

Mistake: Not accounting for strings with identical prefixes but different integer parts.

Solution: Use regex while extracting the middle part to ensure a proper numeric check.

Helpers

Java Comparator
String sorting with integers
Custom string comparison Java
Comparator for numeric values in strings
Java string comparison example