Write A Program To Sort A String In Alphabetical Order In Java

Sorting strings alphabetically is a common task in programming, essential for organizing data and enhancing readability. In this article, you will learn how to sort a string in alphabetical order using various approaches in Java, from basic character array manipulation to modern Stream API techniques.

Problem Statement

Imagine you have a string, such as 'hello', and you need to rearrange its characters to 'ehllo'. This seemingly simple task becomes crucial when dealing with large datasets, lexicographical comparisons, or preparing data for search algorithms. The challenge lies in efficiently reordering the characters of a string based on their Unicode values, which correspond to alphabetical order for standard letters.

Example

Let's consider a practical example of how a string transforms after sorting:

• Input String: java
• Sorted String: aajv

Background & Knowledge Prerequisites

To effectively follow the solutions presented, a basic understanding of the following Java concepts is helpful:

• Java Syntax: Fundamental knowledge of how to write and structure Java code.
• String Class: Familiarity with creating and manipulating String objects.
• Character Arrays (char[]): Understanding how to work with arrays of characters.
• Arrays.sort() Method: Basic knowledge of using the java.util.Arrays class for sorting.

Use Cases or Case Studies

Sorting strings alphabetically has numerous practical applications across different domains:

• Dictionary and Lexicographical Sorting: Arranging words in a dictionary, preparing text for natural language processing, or comparing words based on their alphabetical order.
• Data Normalization: Standardizing string data for consistent storage or comparison, for example, converting 'Race' and 'care' to 'acer' for an anagram detection system.
• Anagram Detection: Determining if two strings are anagrams of each other by sorting both strings and then comparing the sorted results. If the sorted strings are identical, they are anagrams.
• Search Optimization: Sorting strings can sometimes optimize search operations, especially when creating sorted indices or utilizing tree-based data structures where order is paramount.
• Unique Character Identification: Finding unique characters in a string by first sorting it and then iterating through the sorted string to easily identify distinct elements.

Solution Approaches

Java offers several robust ways to sort a string alphabetically. Below, we explore three common approaches.

Approach 1: Convert to Character Array, Sort, and Convert Back

This is a classic and highly efficient method that leverages Java's built-in array sorting capabilities.

• Summary: Convert the input string into a character array, use Arrays.sort() to sort the characters in place, and then construct a new string from the sorted array.

// Sort String using Character Array
import java.util.Arrays; // Required for Arrays.sort()

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Define the input string
        String inputString = "programming";
        System.out.println("Original String: " + inputString);

        // Step 2: Convert the string to a character array
        char[] charArray = inputString.toCharArray();

        // Step 3: Sort the character array alphabetically
        // Arrays.sort() uses an efficient sorting algorithm (like dual-pivot quicksort for primitives)
        Arrays.sort(charArray);

        // Step 4: Convert the sorted character array back to a string
        String sortedString = new String(charArray);

        // Step 5: Print the sorted string
        System.out.println("Sorted String: " + sortedString);
    }
}

Run

• Sample Output:

Original String: programming
Sorted String: agimmnoprr

• Stepwise Explanation:

1. An input String (inputString) is declared and initialized.
2. The toCharArray() method of the String class is called on inputString to convert it into a char[] (character array).
3. Arrays.sort(charArray) is invoked. This static method from the java.util.Arrays utility class sorts the elements of the charArray in ascending (alphabetical) order directly.
4. A new String object (sortedString) is created by passing the sorted charArray to its constructor. This reconstructs the string from the ordered characters.
5. Finally, the original and sorted strings are printed to the console.

Approach 2: Using Java 8 Stream API

For more modern Java applications (Java 8 and later), the Stream API provides a functional and concise way to achieve string sorting.

• Summary: This approach streams the characters of the string, sorts them as integers (their Unicode values), and then collects them back into a new string using a StringBuilder.

// Sort String using Stream API
import java.util.stream.Collectors; // Required for Collectors

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Define the input string
        String inputString = "example";
        System.out.println("Original String: " + inputString);

        // Step 2: Convert the string to an IntStream of characters, sort, and collect
        String sortedString = inputString.chars() // Gets an IntStream where each int is a character's Unicode value
                                        .sorted() // Sorts the character Unicode values in ascending order
                                        .collect(StringBuilder::new, // Supplier: Creates a new StringBuilder
                                                 StringBuilder::appendCodePoint, // Accumulator: Appends each sorted int (code point)
                                                 StringBuilder::append) // Combiner: Used for parallel streams to merge StringBuilders
                                        .toString(); // Convert the final StringBuilder to a String

        // Step 3: Print the sorted string
        System.out.println("Sorted String: " + sortedString);
    }
}

Run

• Sample Output:

Original String: example
Sorted String: aeemplx

• Stepwise Explanation:

1. The inputString.chars() method is called. This returns an IntStream, where each element is the integer Unicode value of a character in the string.
2. The sorted() method is applied to the IntStream, which sorts these Unicode values in ascending order.
3. The collect() method is used to gather the sorted integer code points back into a string.

• StringBuilder::new provides the initial mutable container (StringBuilder).
• StringBuilder::appendCodePoint is the accumulator function, which adds each sorted Unicode integer back into the StringBuilder as a character.
• StringBuilder::append is a combiner used for parallel streams to merge partial results.

1. Finally, toString() is called on the resulting StringBuilder to get the alphabetically sorted String.

Approach 3: Manual Sorting (Bubble Sort Example)

While Arrays.sort() is almost always the preferred method due to its efficiency, understanding a basic manual sorting algorithm can be insightful. Here's an example using Bubble Sort.

• Summary: Convert the string to a character array, then implement a nested loop algorithm like Bubble Sort to manually sort the characters before converting back to a string. This is generally for educational purposes rather than production use.

// Sort String using Manual Bubble Sort
// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        String inputString = "zebra";
        System.out.println("Original String: " + inputString);

        char[] charArray = inputString.toCharArray();
        int n = charArray.length;

        // Step 1: Implement Bubble Sort algorithm
        // Outer loop for passes
        for (int i = 0; i < n - 1; i++) {
            // Inner loop for comparisons and swaps
            for (int j = 0; j < n - i - 1; j++) {
                // If current character is greater than the next, swap them
                if (charArray[j] > charArray[j + 1]) {
                    char temp = charArray[j];
                    charArray[j] = charArray[j + 1];
                    charArray[j + 1] = temp;
                }
            }
        }

        // Step 2: Convert the manually sorted character array back to a string
        String sortedString = new String(charArray);
        System.out.println("Sorted String: " + sortedString);
    }
}

Run

• Sample Output:

Original String: zebra
Sorted String: aberz

• Stepwise Explanation:

1. The input string is converted into a char[].
2. Nested for loops are used to implement the Bubble Sort algorithm. The outer loop iterates n-1 times (where n is the length of the array), and the inner loop performs comparisons.
3. Inside the inner loop, adjacent characters (charArray[j] and charArray[j+1]) are compared. If the character at j is greater than the character at j+1, they are swapped using a temporary variable temp.
4. After the loops complete, the charArray contains the characters in sorted order.
5. A new String is created from this sorted charArray.

Conclusion

Sorting strings alphabetically is a foundational programming skill with various practical applications. Java provides robust and efficient ways to achieve this, from the straightforward character array conversion and Arrays.sort() method to the more modern and expressive Stream API. Understanding these approaches allows developers to choose the most suitable method based on performance requirements, code readability, and Java version constraints.

Summary

• To sort a string alphabetically, the most common and efficient method in Java is to first convert the string into a char[] array.
• The java.util.Arrays.sort(charArray) method can then be used to sort the characters in place, providing an optimized solution.
• After sorting, a new String can be constructed from the sorted char[].
• For Java 8 and newer, the Stream API offers a functional approach: inputString.chars().sorted().collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString().
• Manual sorting algorithms, such as Bubble Sort, can be implemented for educational purposes but are generally less efficient than built-in library methods for production use.