Type-1: 

Let's create a Java method to remove all the spaces from a given string, along with a detailed explanation of how it works:


public class SpaceRemover { 
public static void main(String[] args) { 
String inputString = "Hello, World! How are you?"; 
String stringWithoutSpaces = removeSpaces(inputString);
 System.out.println("Original String: " + inputString); 
 System.out.println("String without spaces: " + stringWithoutSpaces); 
 } 
public static String removeSpaces(String input) { 
// Create a StringBuilder to store the characters of the input string without spaces

        StringBuilder result = new StringBuilder();
// Iterate through each character in the input string 
for (char ch : input.toCharArray()) {
// Check if the character is not a space (using the Character.isSpaceChar() method) 
if (!Character.isSpaceChar(ch)) {
// If the character is not a space, append it to the result StringBuilder
                result.append(ch); 
 } 
 } 
// Convert the result StringBuilder back to a string and return it 
return result.toString(); 
 } 
}

Explanation:

  1. We start with the main method, where we declare and initialize the inputString variable with the string from which we want to remove spaces. In this example, the inputString is set to "Hello, World! How are you?".
  2. We call the removeSpaces method, passing the inputString as an argument, to obtain the modified string without spaces.
  3. In the removeSpaces method, we create a StringBuilder called result. A StringBuilder is used to efficiently concatenate strings without creating new objects, which makes it more efficient than using the + operator on strings.
  4. We then iterate through each character in the input string using a for-each loop with the help of the toCharArray() method. This method converts the input string into a character array, allowing us to access individual characters easily.
  5. Inside the loop, we check if the current character (ch) is not a space using the Character.isSpaceChar() method. If the character is not a space, it means it's a non-space character that we want to keep in the result.
  6. If the character is not a space, we append it to the result StringBuilder using the append() method.
  7. The loop continues until we process all characters in the input string.
  8. After the loop, the result StringBuilder contains all non-space characters from the input string, effectively removing all spaces.
  9. Finally, we convert the result StringBuilder back to a string using the toString() method and return the modified string without spaces.
  10. The modified string is then printed in the main method.


By using this approach with a StringBuilder, we efficiently remove all spaces from the given string, resulting in a new string without any spaces. This method is straightforward and performs well, even for large strings.

Type-2:

Another way to remove all spaces from a given string is by using regular expressions. 

We can replace all occurrences of spaces with an empty string, effectively removing them from the original string. 

Here's the Java method using regular expressions:


public class SpaceRemover { 
public static void main(String[] args) { 
String inputString = "Hello, World! How are you?"; 
String stringWithoutSpaces = removeSpaces(inputString);
 System.out.println("Original String: " + inputString);
 System.out.println("String without spaces: " + stringWithoutSpaces); 
 } 
public static String removeSpaces(String input) { 
// Use regular expression to replace all spaces with an empty string

        String result = input.replaceAll("\\s", ""); 
return result; 
 }
 }

Explanation:

  1. The code structure and the declaration of the main method are similar to the previous implementation.
  2. We call the removeSpaces method, passing the inputString as an argument, to obtain the modified string without spaces.
  3. In the removeSpaces method, we use the replaceAll() method to perform a regular expression-based replacement. The first argument of replaceAll() is the regular expression pattern to match, and the second argument is the replacement string.
  4. In the regular expression pattern, \\s matches any whitespace character, including spaces, tabs, and line breaks.
  5. By specifying an empty string ("") as the replacement, we effectively remove all occurrences of spaces in the input string.
  6. The result of the replaceAll() method is assigned to the result variable.
  7. Finally, we return the modified string (result) without spaces.


By using regular expressions, this approach simplifies the code to a single line for removing spaces from the given string. Regular expressions provide a powerful and concise way to perform string manipulations like this one. This method is equally efficient as the previous one and handles spaces and other whitespace characters uniformly.


Type-3:

Another way to remove all spaces from a given string is by using a simple loop and a StringBuilder. 

We can iterate through each character in the input string and append non-space characters to the StringBuilder.

 This approach avoids using regular expressions and provides a straightforward implementation.

Let's create a Java method using this approach:


public class SpaceRemover { 
public static void main(String[] args) { 
String inputString = "Hello, World! How are you?"; 
String stringWithoutSpaces = removeSpaces(inputString);
 System.out.println("Original String: " + inputString);
 System.out.println("String without spaces: " + stringWithoutSpaces);
 } 
public static String removeSpaces(String input) {
// Create a StringBuilder to store the characters of the modified string
        StringBuilder result = new StringBuilder(); 
// Iterate through each character in the input string 
for (int i = 0; i < input.length(); i++)
 { 
char ch = input.charAt(i); 
// Check if the character is not a space 
if (ch != ' ') { 
// If the character is not a space, append it to the result StringBuilder
                result.append(ch);
 } 
 }

        // Convert the result StringBuilder back to a string and return it

        return result.toString();
    }
}

Explanation:

  1. The code structure and the declaration of the main method remain the same as before.
  2. We call the removeSpaces method, passing the inputString as an argument, to obtain the modified string without spaces.
  3. In the removeSpaces method, we create a StringBuilder called result, similar to the previous implementations.
  4. We then use a standard for loop to iterate through each character in the input string. We use the charAt() method to retrieve the character at the current index i.
  5. Inside the loop, we check if the current character (ch) is not a space by comparing it with the space character ' '.
  6. If the character is not a space, we append it to the result StringBuilder using the append() method.
  7. The loop continues until we process all characters in the input string.
  8. After the loop, the result StringBuilder contains all non-space characters from the input string, effectively removing all spaces.
  9. Finally, we convert the result StringBuilder back to a string using the toString() method and return the modified string without spaces.


This approach provides a simple and efficient way to remove all spaces from the given string without the need for regular expressions or complex string manipulations. It works well for both short and long strings and is easy to understand and maintain.