Analysis and Optimization of Java String Array Sorting Issues

Problem Background and Phenomenon Analysis

In Java programming, sorting string arrays is a common but error-prone operation. The original code uses a double loop structure to implement the selection sort algorithm, comparing strings through the compareTo() method. However, the actual output significantly differs from expectations, specifically: Hello This Example Sorting is instead of the expected Hello This Example Is Sorting.

Core Problem Diagnosis

First, attention must be paid to the issue of whitespace characters in strings. The original array contains " Hello " and " This " with leading and trailing spaces. These space characters have specific values in the ASCII table (space character ASCII value is 32), directly affecting the comparison results of the compareTo() method. When string comparison occurs, space characters participate in the sorting calculation, causing the sort order to deviate from expectations.

The implementation of the sorting algorithm also has room for optimization. The original code's selection sort algorithm may perform multiple element swaps in each inner loop. While functionally correct, this approach is inefficient and prone to errors due to improper handling of boundary conditions.

Standard Library Solution

The Java standard library provides the Arrays.sort() method, which implements an optimized sorting algorithm capable of efficiently and accurately completing array sorting tasks. Here is the improved code example:

String[] strings = { " Hello ", " This ", "Is ", "Sorting ", "Example" };
Arrays.sort(strings);
for (String str : strings) {
    System.out.println(str);
}

Executing the above code will output:

 Hello
 This
Example
Is
Sorting

In-depth Analysis of ASCII Sorting Principle

The Arrays.sort() method internally uses a comparison mechanism based on ASCII values. In the ASCII character set, the space character (32) has a value less than uppercase letters (65-90), which in turn are less than lowercase letters (97-122). This sorting rule explains why strings containing spaces appear at the beginning of sorted results.

Special attention should be paid to the case issue of the string "is". In the original array, this string is in all lowercase form, while in the expected output it should be "Is" with initial capitalization. Since lowercase letters have higher ASCII values than uppercase letters, the all-lowercase "is" will appear at the end of the array after sorting.

Optimization Suggestions and Best Practices

To obtain accurate sorting results, it is recommended to preprocess strings before sorting:

String[] strings = { " Hello ", " This ", "Is ", "Sorting ", "Example" };
// Remove leading and trailing spaces
for (int i = 0; i < strings.length; i++) {
    strings[i] = strings[i].trim();
}
Arrays.sort(strings);

Additionally, for scenarios requiring specific sorting rules, consider implementing custom comparison logic using the Comparator interface:

Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER);

This approach enables case-insensitive sorting, suitable for sorting scenarios where letter case sensitivity is not required.

Performance Comparison Analysis

The manually implemented sorting algorithm has a time complexity of O(n²), while Arrays.sort() uses optimized merge sort or TimSort algorithms for object arrays, with an average time complexity of O(n log n). When processing large-scale data, the performance advantages of standard library methods become more pronounced.

Through the analysis in this paper, developers can better understand the internal mechanisms of Java string sorting, avoid common sorting pitfalls, and improve code quality and performance.