String s ="123456789abcdefgh";
String sub = s.substring(0, 10);
String remainder = s.substring(10);

As @Tom writes, an indexOf type approach is faster than String.split(), since the latter deals with regular expressions and has a lot of extra overhead for them.

However, one algorithm change that might give you a super speedup. Assuming that this Comparator is going to be used to sort your ~100,000 Strings, do not write the Comparator<String>. Because, in the course of your sort, the same String will likely be compared multiple times, so you will split it multiple times, etc...

Split all the Strings once into String[]s, and have a Comparator<String[]> sort the String[]. Then, at the end, you can combine them all together.

Alternatively, you could also use a Map to cache the String -> String[] or vice versa. e.g. (sketchy) Also note, you are trading memory for speed, hope you have lotsa RAM

HashMap<String, String[]> cache = new HashMap();

int compare(String s1, String s2) {
   String[] cached1 = cache.get(s1);
   if (cached1  == null) {
      cached1 = mySuperSplitter(s1):
      cache.put(s1, cached1);
   }
   String[] cached2 = cache.get(s2);
   if (cached2  == null) {
      cached2 = mySuperSplitter(s2):
      cache.put(s2, cached2);
   }

   return compareAsArrays(cached1, cached2);  // real comparison done here
}

Here is one way. No explicit loops involved.

• find midpoint of string.
• find first space after mid point.
• find first space before mid point.
• select split position based on distance from midpoint.

int mid = str.length()/2;
int indexBeyondMid = str.indexOf(' ',mid);
int indexBeforeMid = str.substring(0,mid).lastIndexOf(' ');
int splitPoint = mid - indexBeforeMid < indexBeyondMid - mid 
         ? indexBeforeMid 
         : indexBeyondMid;
String firstHalf = str.substring(0,splitPoint);
String secondHalf = str.substring(splitPoint+1); // ignores leading space.
System.out.println(firstHalf);
System.out.println(secondHalf);

The above will split as evenly as possible. If you want to just split on the first space after the mid point, then just split on indexBeyondMid and forget the rest.

If you want to split a line as optimally as possible to a specified linewidth, you can do it like this.

int lineWidth = 19;
while (!str.isBlank()) {
    lineWidth = lineWidth > str.length() ? str.length() : lineWidth;
    int indexBeyondMid = str.indexOf(' ',lineWidth);
    int indexBeforeMid = str.substring(0,lineWidth).lastIndexOf(' ');
    int splitPoint = lineWidth - indexBeforeMid < indexBeyondMid - lineWidth 
             ? indexBeforeMid 
             : indexBeyondMid;
    if (splitPoint < 0) {
        System.out.println(str);
        break;
    }
    System.out.println(str.substring(0, splitPoint));
    str = str.substring(splitPoint+1);
}

prints

Hey I am string that
will be split but
remember i will not
be cut in the middle
of the word