Guava CharMatcher

1. Remove Special Characters from a String

Let’s start by removing all special characters from a String.

In the following example, we remove all characters that aren’t digit or letter using retainFrom():

@Test
public void whenRemoveSpecialCharacters_thenRemoved(){
    String input = "H*el.lo,}12";
    CharMatcher matcher = CharMatcher.javaLetterOrDigit();
    String result = matcher.retainFrom(input);

    assertEquals("Hello12", result);
}

2. Remove Non ASCII Characters From String

We can also use CharMatcher to remove non ASCII characters from a String as in the following example:

@Test
public void whenRemoveNonASCIIChars_thenRemoved() {
    String input = "あhello₤";

    String result = CharMatcher.ascii().retainFrom(input);
    assertEquals("hello", result);

    result = CharMatcher.inRange('0', 'z').retainFrom(input);
    assertEquals("hello", result);
}

3. Remove Characters Not in the Charset

Now – let’s see how to remove Characters that don’t belong to a given Charset. In the following example – we’ll remove characters that don’t belong to the “cp437” Charset:

@Test
public void whenRemoveCharsNotInCharset_thenRemoved() {
    Charset charset = Charset.forName("cp437");
    CharsetEncoder encoder = charset.newEncoder();

    Predicate<Character> inRange = new Predicate<Character>() {
        @Override
        public boolean apply(Character c) {
            return encoder.canEncode(c);
        }
    };

    String result = CharMatcher.forPredicate(inRange)
                               .retainFrom("helloは");
    assertEquals("hello", result);
}

Note: We used CharsetEncoder to create a Predicate that check if the given Character can be encoded to the given Charset.

4. Validate String

Next – let’s see how to validate a String using CharMatcher.

We can use matchesAllOf() to check if all characters match a condition. And we can make use of matchesNoneOf() to check if a condition doesn’t apply on any of the String characters.

In the following example, we check if our String is lowercase, contains at least one ‘e‘ character and doesn’t contain any digits:

@Test
public void whenValidateString_thenValid(){
    String input = "hello";

    boolean result = CharMatcher.javaLowerCase().matchesAllOf(input);
    assertTrue(result);

    result = CharMatcher.is('e').matchesAnyOf(input);
    assertTrue(result);

    result = CharMatcher.javaDigit().matchesNoneOf(input);
    assertTrue(result);
}

5. Trim String

Now – let’s see how trim a String using CharMatcher.

In the following example, we use trimLeading()trimTrailing and trimFrom() to trim our String:

@Test
public void whenTrimString_thenTrimmed() {
    String input = "---hello,,,";

    String result = CharMatcher.is('-').trimLeadingFrom(input);
    assertEquals("hello,,,", result);

    result = CharMatcher.is(',').trimTrailingFrom(input);
    assertEquals("---hello", result);

    result = CharMatcher.anyOf("-,").trimFrom(input);
    assertEquals("hello", result);
}

6. Collapse a String

Next – let’s see how to collapse a String using CharMatcher.

In the following example, we use collapseFrom() to replace consecutive spaces with ‘‘:

@Test
public void whenCollapseFromString_thenCollapsed() {
    String input = "       hel    lo      ";

    String result = CharMatcher.is(' ').collapseFrom(input, '-');
    assertEquals("-hel-lo-", result);

    result = CharMatcher.is(' ').trimAndCollapseFrom(input, '-');
    assertEquals("hel-lo", result);
}

7. Replace from String

We can use CharMatcher to replace specific characters from a String as in the following example:

@Test
public void whenReplaceFromString_thenReplaced() {
    String input = "apple-banana.";

    String result = CharMatcher.anyOf("-.").replaceFrom(input, '!');
    assertEquals("apple!banana!", result);

    result = CharMatcher.is('-').replaceFrom(input, " and ");
    assertEquals("apple and banana.", result);
}

8. Count Character Occurrences

Finally – let’s see how to count the occurrences of characters using CharMatcher.

In the following example, we count the commas and characters between ‘a‘:’h‘:

@Test
public void whenCountCharInString_thenCorrect() {
    String input = "a, c, z, 1, 2";

    int result = CharMatcher.is(',').countIn(input);
    assertEquals(4, result);

    result = CharMatcher.inRange('a', 'h').countIn(input);
    assertEquals(2, result);
}

9. Conclusion

In this article we illustrated some of the more useful APIs and real-world usage examples of using Guava for Strings.

The full source code is available over on GitHub.

Related posts:

Java Program to Check whether Directed Graph is Connected using DFS
Assert an Exception is Thrown in JUnit 4 and 5
Java Program to Implement the MD5 Algorithm
Request Method Not Supported (405) in Spring
Spring Cloud Connectors and Heroku
Java Program to Perform Right Rotation on a Binary Search Tree
StringBuilder vs StringBuffer in Java
Spring Boot: Customize the Jackson ObjectMapper
Spring Boot - Tomcat Port Number
Java Program to Implement Expression Tree
Java Program to Implement Jarvis Algorithm
Java Program to Perform Addition Operation Using Bitwise Operators
Java Program to Implement ArrayBlockingQueue API
A Guide to Apache Commons Collections CollectionUtils
Custom JUnit 4 Test Runners
RegEx for matching Date Pattern in Java
Performance Difference Between save() and saveAll() in Spring Data
Java Program to Implement ConcurrentLinkedQueue API
Autoboxing và Unboxing trong Java
Guide to Dynamic Tests in Junit 5
Java Program to Implement Repeated Squaring Algorithm
Java Program to Implement Ford–Fulkerson Algorithm
Injecting Prototype Beans into a Singleton Instance in Spring
HttpClient with SSL
Java Program to Apply DFS to Perform the Topological Sorting of a Directed Acyclic Graph
Spring Boot - Flyway Database
Guide to the Java Clock Class
Serialize Only Fields that meet a Custom Criteria with Jackson
Java Program to subtract two large numbers using Linked Lists
Java Program to Test Using DFS Whether a Directed Graph is Weakly Connected or Not
Show Hibernate/JPA SQL Statements from Spring Boot
Different Ways to Capture Java Heap Dumps