Open In App

Remove all non-alphabetical characters of a String in Java

Improve
Improve
Like Article
Like
Save
Share
Report

Given a string str, consisting of non-alphabetical characters. The task is to remove all those non-alphabetical characters of str and print the words on a new line. 

Examples:

Input: str = “Hello, how are you ?” 
Output: Hello how are you comma(, ), white space and question mark (?) are removed and there are total 4 words in string s. Each token is printed in the same order in which it appears in string s. 

Input: “Azad is a good boy, isn’ t he ?” 
Output: Azad is a good boy isn t he

Approach: 

Non-alphabetic characters are basically any character that is not a number or letter. It can be English alphabetic letters, blank spaces, exclamation points (!), commas (, ), question marks (?), periods (.), underscores (_), apostrophes (‘), and at symbols (@). The approach is to use Java String.split method to split the String, s into an array of substrings. Then print each n words on a new line in the same order as it appears in String s. 

Below is the implementation of the above approach: 

Java




// Java program to split all
// non-alphabetical characters
import java.util.Scanner;
 
public class Main {
 
    // Function to trim the non-alphabetical characters
    static void printwords(String str)
    {
 
        // eliminate leading and trailing spaces
        str = str.trim();
 
        // split all non-alphabetic characters
        String delims = "\\W+"; // split any non word
        String[] tokens = str.split(delims);
 
        // print the tokens
        for (String item : tokens) {
 
            System.out.println(item + " ");
        }
    }
 
    public static void main(String[] args)
    {
 
        String str = "Hello, how are you ?";
        printwords(str);
    }
}


Output

Hello 
how 
are 
you 

Time Complexity: O(N)

New Approach:

  • Defines a function named removeNonAlphabetic which takes a string argument str as input and returns a string.
  • The removeNonAlphabetic function uses the replaceAll method of the string class to replace all non-alphabetic characters in the input string with an empty string.
  • The regular expression “[^a-zA-Z]” is used to match all characters that are not English alphabetical letters (both uppercase and lowercase).
  • The main function of the code initializes a string str with a sample string “Hello, how are you?”.
  • The main function then calls the removeNonAlphabetic function with str as input and assigns the returned string to a variable named result.
  • Finally, the main function prints the value of the result string to the console, which should be the original string with all non-alphabetic characters removed.

Below is the implementation of the above approach: 

Java




import java.util.Scanner;
 
public class Main {
 
    // Function to remove non-alphabetic characters
    static String removeNonAlphabetic(String str) {
 
        // Use regular expression to match all non-alphabetic characters and replace with empty string
        String result = str.replaceAll("[^a-zA-Z]", "");
 
        return result; // Return the resulting string
    }
 
    public static void main(String[] args) {
 
        String str = "Hello, how are you ?"; // Initialize a sample string
        String result = removeNonAlphabetic(str); // Call the removeNonAlphabetic function with input string
        System.out.println(result); // Print the resulting string with non-alphabetic characters removed
    }
}


Output

Hellohowareyou

In this approach, we use the replaceAll() method to replace all non-alphabetic characters with an empty string. The regular expression “[^a-zA-Z]” matches any character that is not an English alphabetical letter (both uppercase and lowercase).

The resulting string only contains alphabetic characters.

Time Complexity:

  • The replaceAll method in the removeNonAlphabetic function uses regular expressions to replace non-alphabetic characters with an empty string.
  • The time complexity of regular expression matching depends on the size of the input string and the complexity of the regular expression used.
  • In this case, the regular expression “[^a-zA-Z]” matches all non-alphabetic characters, and the replaceAll method replaces them with an empty string in a single pass.
  • Therefore, the time complexity of the removeNonAlphabetic function is O(n), where n is the length of the input string.
  • The main function only calls the removeNonAlphabetic function once, so its time complexity is also O(n).

Auxiliary Space:

  • The space complexity of the removeNonAlphabetic function depends on the size of the input string and the size of the resulting string after removing non-alphabetic characters.
  • In this case, the replaceAll method creates a new string that is the same size as the input string or smaller if non-alphabetic characters are removed.
  • Therefore, the space complexity of the removeNonAlphabetic function is O(n), where n is the length of the input string.
    The main function only stores a single string variable, so its space complexity is also O(n).


Last Updated : 24 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads