Java Program To Remove Characters In A String Except Alphabets

When processing textual data, strings often contain a mix of characters, including numbers, symbols, and whitespace, alongside alphabets. Cleaning these strings by retaining only the alphabetic characters is a common requirement in various programming tasks. In this article, you will learn how to effectively remove all characters from a Java string except for alphabets, using different techniques.

Problem Statement

The core problem is to sanitize a given string by filtering out all non-alphabetic characters, such as digits, punctuation marks, and special symbols, leaving only the letters (a-z, A-Z). This is crucial for tasks like data normalization, input validation, or preparing text for natural language processing where only linguistic content is relevant.

Example

Consider an input string like "Hello123World!@#$". After removing all characters except alphabets, the desired output should be "HelloWorld".

Background & Knowledge Prerequisites

To understand the solutions presented, a basic understanding of the following Java concepts is beneficial:

• String manipulation: How to create, modify, and access characters within strings.
• Regular Expressions (Regex): Familiarity with basic regex patterns for matching character sets.
• Looping constructs: for loops for iterating over collections or character sequences.
• StringBuilder class: Its use for efficient string modification.

No specific imports or special setup are required beyond a standard Java Development Kit (JDK).

Use Cases or Case Studies

Removing non-alphabetic characters is useful in many real-world scenarios:

• Data Cleaning: When processing user input or data scraped from web pages, often non-alphabetic characters need to be stripped to standardize data format.
• Form Validation: Ensuring that fields like "Name" or "City" only contain alphabetic characters, preventing invalid data entry.
• Search Normalization: Before performing a search, queries can be cleaned to match relevant results regardless of extraneous symbols.
• Natural Language Processing (NLP): Preparing text for analysis (e.g., sentiment analysis, tokenization) by removing noise and focusing on words.
• Password/Username Policies: Enforcing rules that disallow certain characters in user credentials.

Solution Approaches

Here are two common and effective approaches to remove non-alphabetic characters from a Java string.

Approach 1: Using String.replaceAll() with Regular Expressions

This approach leverages Java's built-in regular expression support for a concise and powerful solution.

• Summary: Uses a regular expression [^a-zA-Z] to match any character that is *not* an uppercase or lowercase alphabet and replaces it with an empty string.

// Remove Non-Alphabets using replaceAll
public class Main {
    public static void main(String[] args) {
        // Step 1: Define the input string
        String originalString = "Java123 Programming! is #Fun.";
        System.out.println("Original String: " + originalString);

        // Step 2: Use replaceAll() with a regular expression
        // [^a-zA-Z] matches any character that is NOT an alphabet (a-z or A-Z)
        String cleanedString = originalString.replaceAll("[^a-zA-Z]", "");

        // Step 3: Print the cleaned string
        System.out.println("Cleaned String: " + cleanedString);
    }
}

Run

Sample Output:

Original String: Java123 Programming! is #Fun.
Cleaned String: JavaProgrammingisFun

Stepwise Explanation:

1. We start with an originalString that contains mixed characters.
2. originalString.replaceAll("[^a-zA-Z]", "") is called.

• replaceAll() is a String method that replaces all occurrences of a substring that matches the given regular expression.
• [^a-zA-Z] is the regular expression:
• [] denotes a character class.
• ^ inside the character class ([^...]) negates it, meaning "match any character *not* in this set".
• a-z matches any lowercase alphabet from 'a' to 'z'.
• A-Z matches any uppercase alphabet from 'A' to 'Z'.
• The second argument "" specifies that all matched characters (non-alphabets) should be replaced with an empty string, effectively removing them.

1. The result, cleanedString, now contains only alphabetic characters.

Approach 2: Iterating Through Characters with StringBuilder

This manual approach offers more control and can be useful in scenarios where regular expressions are not desired or performance for very specific character sets is critical.

• Summary: Iterates through each character of the input string, checks if it's an alphabet using Character.isLetter(), and appends only alphabets to a StringBuilder.

// Remove Non-Alphabets by Iteration
public class Main {
    public static void main(String[] args) {
        // Step 1: Define the input string
        String originalString = "Learn Java @ CodeAcademy!";
        System.out.println("Original String: " + originalString);

        // Step 2: Create a StringBuilder to efficiently build the new string
        StringBuilder cleanedStringBuilder = new StringBuilder();

        // Step 3: Iterate through each character of the original string
        for (char c : originalString.toCharArray()) {
            // Step 4: Check if the character is a letter
            if (Character.isLetter(c)) {
                // Step 5: Append the letter to the StringBuilder
                cleanedStringBuilder.append(c);
            }
        }

        // Step 6: Convert the StringBuilder content back to a String
        String cleanedString = cleanedStringBuilder.toString();

        // Step 7: Print the cleaned string
        System.out.println("Cleaned String: " + cleanedString);
    }
}

Run

Sample Output:

Original String: Learn Java @ CodeAcademy!
Cleaned String: LearnJavaCodeAcademy

Stepwise Explanation:

1. An originalString is initialized.
2. A StringBuilder called cleanedStringBuilder is created. Using StringBuilder for concatenating characters in a loop is more efficient than repeatedly using String concatenation (+ operator), as String objects are immutable.
3. The originalString is converted to a character array using toCharArray() to allow easy iteration over individual characters.
4. A for-each loop iterates through each character c in the array.
5. Inside the loop, Character.isLetter(c) is used to determine if the current character c is an alphabet (both uppercase and lowercase).
6. If Character.isLetter(c) returns true, the character c is appended to the cleanedStringBuilder.
7. After the loop finishes, cleanedStringBuilder.toString() converts the content of the StringBuilder into a final String.
8. The cleanedString is then printed.

Conclusion

Both String.replaceAll() with regular expressions and iterating with StringBuilder are effective methods for removing non-alphabetic characters from a string in Java. The replaceAll() method is often more concise and readable for common patterns due to the power of regular expressions, making it a preferred choice for many developers. The iterative approach provides more granular control, which can be beneficial in niche scenarios or for understanding the underlying logic. Choose the approach that best fits your project's readability, performance requirements, and personal preference.

Summary

• Problem: Remove all characters from a string except alphabets.
• Approach 1 (String.replaceAll()):
• Uses a regular expression [^a-zA-Z] to match any non-alphabetic character.
• Concise and powerful for pattern-based replacements.
• Approach 2 (Iteration with StringBuilder):
• Iterates character by character.
• Uses Character.isLetter() to identify alphabets.
• Builds the new string efficiently using StringBuilder.
• Provides more explicit control over character processing.
• Both methods are suitable, with replaceAll() generally favored for its brevity and elegance when dealing with regular expression patterns.