Write A Program To Remove All Vowels From A String In Java

Removing specific characters from a string is a common task in programming. In this article, you will learn how to efficiently remove all vowels (a, e, i, o, u) from a given string in Java using several effective methods.

Problem Statement

The core problem involves transforming an input string by eliminating all occurrences of both lowercase and uppercase vowels. This seemingly simple task has implications in various text processing scenarios, such as data normalization, specific string transformations, or even basic text obfuscation.

Example

• Input: "Hello World"
• Output: "Hll Wrld"

Background & Knowledge Prerequisites

To effectively understand the solutions presented, readers should have:

• A basic understanding of Java syntax and fundamental data types, especially String.
• Familiarity with loops (for loop) and conditional statements (if).
• Basic knowledge of regular expressions will be beneficial for one of the approaches.
• An understanding of StringBuilder for efficient string manipulation in Java.

Use Cases or Case Studies

Removing vowels from a string can be useful in various practical scenarios:

• Data Cleaning and Normalization: When processing text data, removing specific character types can help normalize data for consistent analysis, such as preparing search keywords or identifiers.
• Text Encoding or Obfuscation: In simple text games or puzzles, removing vowels can create a slightly altered version of words for a fun challenge, though it offers no real security.
• Constraint-Based Shortening: In systems with strict character limits (e.g., old SMS messages, specific display fields), removing vowels can help shorten text while retaining its core consonantal structure.
• Linguistic Analysis: For specific linguistic or phonetic studies, isolating consonants by removing vowels might be a preliminary step to analyze sound patterns.
• Educational Demonstrations: It serves as an excellent basic exercise to demonstrate string manipulation techniques, character iteration, and conditional logic in programming courses.

Solution Approaches

Here are three distinct methods to remove vowels from a string in Java, ranging from concise regular expressions to more explicit iterative and modern stream-based approaches.

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

This approach leverages Java's built-in regular expression support to concisely replace all vowel occurrences with an empty string.

// Remove Vowels using replaceAll
import java.util.Scanner;

// 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 originalString = "Programming Is Fun";
        System.out.println("Original String: " + originalString);

        // Step 2: Define the regular expression for vowels and replace
        // "[aeiouAEIOU]" matches any single lowercase or uppercase vowel.
        // The replaceAll method substitutes all matched characters with an empty string "".
        String stringWithoutVowels = originalString.replaceAll("[aeiouAEIOU]", "");

        // Step 3: Print the result
        System.out.println("String without Vowels: " + stringWithoutVowels);

        // Example with user input
        Scanner scanner = new Scanner(System.in);
        System.out.print("\\nEnter another string: ");
        String userInput = scanner.nextLine();
        String processedInput = userInput.replaceAll("[aeiouAEIOU]", "");
        System.out.println("Processed String: " + processedInput);
        scanner.close();
    }
}

Run

Sample Output:

Original String: Programming Is Fun
String without Vowels: Prgrmmng s Fn

Enter another string: Hello World
Processed String: Hll Wrld

Stepwise Explanation:

1. A source String is declared, containing the text from which vowels need to be removed.
2. The replaceAll() method, part of the String class, is called. This method takes two arguments: a regular expression and a replacement string.
3. The regular expression "[aeiouAEIOU]" is a character class. It instructs the engine to match any single character that is either a lowercase vowel (a, e, i, o, u) or an uppercase vowel (A, E, I, O, U).
4. The replacement string is an empty string "". This means that every character matched by the regular expression will be replaced by nothing, effectively removing it from the string.
5. The resulting string, now free of vowels, is stored in stringWithoutVowels and printed.

Approach 2: Iterating with StringBuilder

This method provides explicit control by iterating through each character of the string and conditionally appending non-vowel characters to a StringBuilder to form the new string.

// Remove Vowels using StringBuilder
import java.util.Scanner;

// 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 originalString = "Java Development";
        System.out.println("Original String: " + originalString);

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

        // Step 3: Define a string containing all vowels for quick lookup
        String vowels = "aeiouAEIOU";

        // Step 4: Iterate through each character of the original string
        for (int i = 0; i < originalString.length(); i++) {
            char ch = originalString.charAt(i);

            // Step 5: Check if the character is a vowel
            // If the character's index in the 'vowels' string is -1, it's not a vowel.
            if (vowels.indexOf(ch) == -1) {
                sb.append(ch); // Append non-vowel characters to StringBuilder
            }
        }

        // Step 6: Convert StringBuilder to String and print the result
        String stringWithoutVowels = sb.toString();
        System.out.println("String without Vowels: " + stringWithoutVowels);

        // Example with user input
        Scanner scanner = new Scanner(System.in);
        System.out.print("\\nEnter another string: ");
        String userInput = scanner.nextLine();
        StringBuilder userSb = new StringBuilder();
        for (int i = 0; i < userInput.length(); i++) {
            char ch = userInput.charAt(i);
            if (vowels.indexOf(ch) == -1) {
                userSb.append(ch);
            }
        }
        System.out.println("Processed String: " + userSb.toString());
        scanner.close();
    }
}

Run

Sample Output:

Original String: Java Development
String without Vowels: Jv Dvlpment

Enter another string: Computer Science
Processed String: Cmptr Scnc

Stepwise Explanation:

1. A StringBuilder object is initialized. StringBuilder is preferred over direct String concatenation in loops because String objects are immutable, making repeated concatenations inefficient.
2. A String named vowels is created, containing all lowercase and uppercase vowels. This acts as a lookup table.
3. A for loop iterates through each character of the originalString from beginning to end.
4. Inside the loop, originalString.charAt(i) retrieves the character at the current index.
5. vowels.indexOf(ch) == -1 is used to check if the current character ch is present in the vowels string. If indexOf() returns -1, it means the character is not a vowel.
6. If the character is not a vowel, it is appended to the StringBuilder using sb.append(ch).
7. After the loop finishes, sb.toString() converts the content of the StringBuilder into a final String, which is then printed.

Approach 3: Using Java 8 Streams

This modern approach leverages the Java 8 Stream API to process characters in a more functional and declarative style, filtering out vowels and collecting the remaining characters.

// Remove Vowels using Java 8 Streams
import java.util.Scanner;
import java.util.stream.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 originalString = "Stream API Example";
        System.out.println("Original String: " + originalString);

        // Step 2: Define a string containing all vowels for quick lookup
        String vowels = "aeiouAEIOU";

        // Step 3: Convert the string to a stream of characters, filter, and collect
        String stringWithoutVowels = originalString.chars() // Gets an IntStream of char values (int)
            .filter(c -> vowels.indexOf(c) == -1) // Filters out characters that are found in the 'vowels' string
            .mapToObj(c -> String.valueOf((char) c)) // Converts each int (char value) back to a String object
            .collect(Collectors.joining()); // Joins the filtered String objects into a single string

        // Step 4: Print the result
        System.out.println("String without Vowels: " + stringWithoutVowels);

        // Example with user input
        Scanner scanner = new Scanner(System.in);
        System.out.print("\\nEnter another string: ");
        String userInput = scanner.nextLine();
        String processedInput = userInput.chars()
            .filter(c -> vowels.indexOf(c) == -1)
            .mapToObj(c -> String.valueOf((char) c))
            .collect(Collectors.joining());
        System.out.println("Processed String: " + processedInput);
        scanner.close();
    }
}

Run

Sample Output:

Original String: Stream API Example
String without Vowels: Strm P xmpl

Enter another string: Functional Programming
Processed String: Fnctnl Prgrmmng

Stepwise Explanation:

1. originalString.chars(): This method returns an IntStream, where each integer represents the Unicode code point of a character in the string.
2. .filter(c -> vowels.indexOf(c) == -1): This is an intermediate operation that filters the stream. The lambda expression c -> vowels.indexOf(c) == -1 acts as a predicate. It checks if the current character c (as an int code point) exists in the vowels string. If indexOf() returns -1, it means c is not a vowel, and the character passes the filter.
3. .mapToObj(c -> String.valueOf((char) c)): Another intermediate operation that transforms the IntStream into a Stream. Each int (representing a character's code point) is cast back to a char and then converted to a single-character String.
4. .collect(Collectors.joining()): This is a terminal operation that collects all the String elements from the stream and concatenates them into a single String. The joining() collector concatenates them without any delimiter.
5. The final String (without vowels) is then printed.

Conclusion

Removing vowels from a string in Java can be achieved using several effective approaches, each with its own advantages. Whether opting for the concise regular expression method for its brevity, the explicit control of a StringBuilder loop for its performance on large strings, or the modern functional style of Java 8 Streams for its readability and elegance, developers have flexible tools to tackle this common string manipulation task efficiently.

Summary

• String.replaceAll() with Regex: The most concise and often easiest solution for simple pattern-based character removal, leveraging regular expressions.
• Iterating with StringBuilder: Provides fine-grained control over character processing, offering good performance, especially for longer strings, by avoiding immutable String object overhead.
• Java 8 Streams: A modern, declarative approach that enhances readability and simplifies complex data transformations, suitable for those familiar with functional programming paradigms.
• All demonstrated methods effectively remove both lowercase and uppercase vowels from a given string.