Guava CharMatcher.removeFrom() method in Java

In this post, we will learn how to use the CharMatcher.removeFrom() method in Java, which is a simple and convenient way to remove certain characters from a string. We will also see the benefits of using this method compared to other methods, and how it compares with other ways to achieve the same in Java.

You might have encountered the need to remove certain characters from a string, based on some criteria. For example, you might want to remove all whitespace characters, all digits, all punctuation marks, or all non-ASCII characters from a string. You might have used some custom methods or regular expressions to perform such removals. However, these methods can be tedious, error-prone, and hard to maintain. Moreover, they might not handle all the possible cases or edge cases correctly. Fortunately, there is a better way to remove certain characters from a string in Java: the Guava CharMatcher.removeFrom() method.

1. Overview of `CharMatcher.removeFrom()` method

The CharMatcher.removeFrom() method is an instance method that takes a string as an argument and returns a new string with all matching characters removed. The method uses a CharMatcher instance to determine which characters to remove. A CharMatcher is an immutable object that defines a set of characters and provides various methods to match them. The syntax of the removeFrom() method is as follows:

1	public String removeFrom(CharSequence sequence)

Here, sequence is the string to remove characters from. The method returns a new string with all matching characters removed.

To use the removeFrom() method, you need to create or obtain a CharMatcher instance first. You can use the factory methods of the CharMatcher class, or create your own custom CharMatcher using its fluent API. Once you have a CharMatcher instance, you can use it to call the removeFrom() method on any string. For example:

import com.google.common.base.CharMatcher;

class Main {

public static void main(String[] args) {

String input = "Hello User1!";

// remove all whitespace characters

CharMatcher whitespace = CharMatcher.whitespace();

String result = whitespace.removeFrom(input);

System.out.println(result); // "HelloUser1!"

// remove all digit characters

CharMatcher digit = CharMatcher.digit();

result = digit.removeFrom(input);

System.out.println(result); // "Hello User!"

// remove all vowels

CharMatcher anyOf = CharMatcher.anyOf("aeiou");

result = anyOf.removeFrom(input);

System.out.println(result); // "Hll Usr1!"

}

Download Code

You can use the methods of the CharMatcher class to create complex or custom matchers using logical operators such as and(), or(), negate(), etc. For example:

import com.google.common.base.CharMatcher;

class Main {

public static void main(String[] args) {

String input = "Hello World!";

// matches any whitespace and lowercase character

CharMatcher matcher = CharMatcher.whitespace().or(CharMatcher.inRange('a', 'z'));

String result = matcher.removeFrom(input); // remove all matching characters

System.out.println(result); // "HW!"

}

Download Code

2. Comparing with Other Ways in Java

There are other ways to remove certain characters from a string in Java, besides the CharMatcher.removeFrom() method. Here are some of them:

Using custom methods or regular expressions. You can write your own methods to perform such removals. However, these methods can be tedious, error-prone, and hard to maintain. Moreover, they might not handle all the possible cases or edge cases correctly.
Using the String.replaceAll() or String.replace() methods from the Java String class. These methods take a regular expression or a literal string as an argument and replace all occurrences of it with another string. You can use them to remove certain characters by replacing them with an empty string. For example:

class Main {

public static void main(String[] args) {

String input = "Hello World!";

// remove all whitespace characters using regex

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

System.out.println(result); // "HelloWorld!"

// remove all 'o' characters using literal string

result = input.replace("o", "");

System.out.println(result); // "Hell Wrld!"

}

Download Code

3. Benefits of `CharMatcher.removeFrom()` method

There are several benefits of using the removeFrom(CharSequence) method over above alternatives. Some of them are:

It is more readable and concise than regular expressions or loops. You can easily see what kind of characters you want to remove by looking at the CharMatcher instance.
It is more efficient than regular expressions or loops. It avoids creating unnecessary objects and performs faster operations on primitive types.
It is more flexible and customizable than regular expressions or loops. You can create your own CharMatchers by combining existing ones or implementing your own logic.
It is more consistent and reliable than regular expressions or loops. It can handle different sets of characters such as whitespace, digits, letters, punctuation marks, ASCII, Unicode, etc.

That’s all about CharMatcher.removeFrom() method in Java. For more information about this method, you can check out the Guava official documentation or its GitHub repository.

Guava CharMatcher.removeFrom() method in Java

1. Overview of CharMatcher.removeFrom() method

2. Comparing with Other Ways in Java

3. Benefits of CharMatcher.removeFrom() method

Share this:

1. Overview of `CharMatcher.removeFrom()` method

3. Benefits of `CharMatcher.removeFrom()` method