Remove Vowels From A String In Java

Last Updated on May 24, 2023 by Prepbytes

String manipulation is an essential aspect of programming, particularly when it comes to text processing and data analysis. In many cases, it becomes necessary to transform strings to extract meaningful information or modify them to meet specific requirements. One common task is removing vowels from a string, a procedure frequently encountered in text preprocessing, data cleaning, and even certain linguistic applications.

In this article, we delve into the topic of removing vowels from a string in Java. Whether you’re a beginner in Java programming or an experienced developer looking to refresh your knowledge, this article will guide you through the process step by step, providing clear explanations and practical examples.

By understanding the underlying concepts and learning the techniques involved in removing vowels from a string, you’ll be equipped with a valuable toolset to tackle various text-related challenges efficiently and effectively. The article assumes basic familiarity with Java syntax and concepts, making it accessible to programmers at different skill levels.

Approaches for Implementing Remove Vowels from a String In Java

We will discuss two different approaches to implement the logic for removal of vowels from the string in Java.

Approach 1: To Remove Vowels from a String in Java using a Loop

We can follow the steps outlined below:

1. Declare a string variable to store the original string and another string variable to store the modified string without vowels.
2. Iterate through each character in the original string using a loop.
3. Within the loop, check if the current character is a vowel.
4. If the character is a vowel (either uppercase or lowercase), skip it and continue to the next iteration of the loop.
5. If the character is not a vowel, append it to the modified string.
6. After the loop finishes iterating through all the characters in the original string, the modified string will contain the original string without vowels.

Code Implementation

class RemoveVowels {
    public static void main(String[] args) {
        String originalString = "Hello, Welcome To PrepBytes!!!";
        String modifiedString = "";


        for (int i = 0; i < originalString.length(); i++) {
            char currentChar = originalString.charAt(i);


            // Check if the current character is a vowel
            if (!isVowel(currentChar)) {
                modifiedString += currentChar;
            }
        }


        System.out.println("Modified string: " + modifiedString);
    }


    public static boolean isVowel(char c) {
        // Convert the character to lowercase for case-insensitive matching
        c = Character.toLowerCase(c);


        // Check if the character is a vowel
        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
    }
}

Output

Modified string: Hll, Wlcm T PrpByts!!!

Explanation:

1. We start by declaring the originalString variable to store the input string and the modifiedString variable to store the string without vowels.
2. Next, we use a for loop to iterate through each character in the originalString. The loop condition i < originalString.length() ensures that we iterate until we reach the end of the string.
3. Within the loop, we retrieve the current character using the charAt() method and store it in the currentChar variable.
4. To check if the character is a vowel, we call the isVowel() method, passing in the currentChar. This method converts the character to lowercase using Character.toLowerCase() for case-insensitive matching and compares it against the vowels ‘a’, ‘e’, ‘i’, ‘o’, and ‘u’. If the character is not a vowel, the isVowel() method returns false.
5. If the character is not a vowel (i.e., isVowel() returns false), we append it to the modifiedString using the += operator.
6. Once the loop finishes, the modifiedString will contain the original string without any vowels.
7. Finally, we print the modifiedString to the console.

The original string "Hello, Welcome To PrepBytes!!!" has been modified, and the vowels (‘e’, ‘o’, ‘e’, ‘o’, ‘e’, ‘o’, ’e’, ‘e’) have been removed, resulting in the modified string "Hll, Wlcm T PrpByts!!!".

Time Complexity:
The time complexity of this approach is O(n), where n is the length of the original string. The loop iterates through each character in the string once, resulting in a linear time complexity. Regardless of the length of the string, the number of iterations remains proportional to the input size.

Space Complexity:
The space complexity of this approach is also O(n), where n is the length of the original string.

Approach 2: To Remove Vowels from a String in Java using Regular Expressions

To remove vowels from a string in Java using regular expressions, we can utilize the replaceAll() method along with a suitable regular expression pattern. Regular expressions provide a concise and powerful way to match and manipulate text patterns.

Code Implementation

class RemoveVowels {
    public static void main(String[] args) {
        String originalString = "Hello, Welcome To PrepBytes!!!";
        String modifiedString = originalString.replaceAll("[aeiouAEIOU]", "");

        System.out.println("Modified string: " + modifiedString);
    }
}

Output

Modified string: Hll, Wlcm T PrpByts!!!

Explanation:

1. We start by declaring the originalString variable to store the input string.
2. The replaceAll() method is invoked on the originalString and accepts two arguments: the regular expression pattern to match and the replacement string. In our case, we want to match all vowels (both lowercase and uppercase) in the string and replace them with an empty string, effectively removing them.
3. The regular expression pattern [aeiouAEIOU] specifies a character class that matches any vowel character (either lowercase or uppercase). The replaceAll() method finds all occurrences of vowels in the originalString and replaces them with an empty string, effectively removing them.
4. The resulting modified string is stored in the modifiedString variable.
5. Finally, we print the modifiedString to the console.

The original string "Hello, Welcome To PrepBytes!!!" has been modified, and the vowels (‘e’, ‘o’, ‘e’, ‘o’, ‘e’, ‘o’, ’e’, ‘e’) have been removed, resulting in the modified string "Hll, Wlcm T PrpByts!!!".

Using regular expressions in this approach simplifies the code significantly by avoiding the need for explicit loops and conditional statements. The regular expression pattern [aeiouAEIOU] handles the matching and removal of vowels in a concise and efficient manner.

The time and space complexity of this approach depend on the implementation of the replaceAll() method. Generally, regular expression operations have a time complexity of O(n), where n is the length of the input string. The space complexity is also O(n) since the modified string is stored in a separate variable, which grows linearly with the size of the input string.

Conclusion
In this article, we explored two different approaches to remove vowels from a string in Java: the loop-based approach and the regular expression-based approach. Each approach offers its own advantages and considerations, providing developers with flexibility based on their specific requirements and coding preferences.

FAQ related to Remove Vowels From A String In Java

Q1: Why would I want to remove vowels from a string in Java?
Ans. Removing vowels from a string can be useful in various scenarios, such as text preprocessing, data cleaning, and certain linguistic applications. It allows you to filter out vowels to extract consonant-based patterns or analyze the non-vowel components of the text.

Q2: What is the difference between the loop-based approach and the regular expression-based approach?
Ans. The loop-based approach involves iterating through each character of the string, checking for vowels, and constructing a modified string without the vowels. It offers more control and customization but requires explicit code implementation. On the other hand, the regular expression-based approach utilizes the replaceAll() method with a suitable regex pattern to remove all occurrences of vowels in a single operation, providing a more concise and convenient solution.

Q3: Are these approaches case-sensitive?
Ans. By default, the loop-based approach and the regular expression-based approach provided in the article are case-sensitive. They consider uppercase and lowercase vowels as distinct. If you want to make the removal case-insensitive, you can convert the string to a consistent case (e.g., lowercase) before applying the removal logic in both approaches.