Chapter 6.2: Using Regular Expressions with String.matches() - Examples

4.1. Overview

Strings in Java have built-in support for regular expressions. Strings have three built-in methods for regular expressions, i.e., matches(), split()), replace().

These methods are not optimized for performance. We will later use classes which are optimized for performance.

Table 4. 

Method	Description
s.matches("regex")	Evaluates if "regex" matches s. Returns only true if the WHOLE string can be matched.
s.split("regex")	Creates an array with substrings of s divided at occurrence of "regex". "regex" is not included in the result.
s.replace("regex"), "replacement"	Replaces "regex" with "replacement

Create for the following example the Java project de.vogella.regex.test.

package de.vogella.regex.test;

public class RegexTestStrings {

  public static final String EXAMPLE_TEST = "This is my small example "

      + "string which I'm going to " + "use for pattern matching.";

  public static void main(String[] args) {

    System.out.println(EXAMPLE_TEST.matches("\\w.*"));

    String[] splitString = (EXAMPLE_TEST.split("\\s+"));

    System.out.println(splitString.length);// should be 14

    for (String string : splitString) {

      System.out.println(string);

    }

    // replace all whitespace with tabs

    System.out.println(EXAMPLE_TEST.replaceAll("\\s+", "\t"));

  }

} 

4.2. Examples

The following class gives several examples for the usage of regular expressions with strings. See the comment for the purpose.

If you want to test these examples, create for the Java project de.vogella.regex.string.

package de.vogella.regex.string;

public class StringMatcher {

  // returns true if the string matches exactly "true"

  public boolean isTrue(String s){

    return s.matches("true");

  }

  // returns true if the string matches exactly "true" or "True"

  public boolean isTrueVersion2(String s){

    return s.matches("[tT]rue");

  }

  // returns true if the string matches exactly "true" or "True"

  // or "yes" or "Yes"

  public boolean isTrueOrYes(String s){

    return s.matches("[tT]rue|[yY]es");

  }

  // returns true if the string contains exactly "true"

  public boolean containsTrue(String s){

    return s.matches(".*true.*");

  }

  // returns true if the string contains of three letters

  public boolean isThreeLetters(String s){

    return s.matches("[a-zA-Z]{3}");

    // simpler from for

//    return s.matches("[a-Z][a-Z][a-Z]");

  }

  // returns true if the string does not have a number at the beginning

  public boolean isNoNumberAtBeginning(String s){

    return s.matches("^[^\\d].*");

  }

  // returns true if the string contains a arbitrary number of characters except b

  public boolean isIntersection(String s){

    return s.matches("([\\w&&[^b]])*");

  }

  // returns true if the string contains a number less then 300

  public boolean isLessThenThreeHundret(String s){

    return s.matches("[^0-9]*[12]?[0-9]{1,2}[^0-9]*");

  }

} 

And a small JUnit Test to validates the examples.

package de.vogella.regex.string;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

public class StringMatcherTest {

  private StringMatcher m;

  @Before

  public void setup(){

    m = new StringMatcher();

  }

  @Test

  public void testIsTrue() {

    assertTrue(m.isTrue("true"));

    assertFalse(m.isTrue("true2"));

    assertFalse(m.isTrue("True"));

  }

  @Test

  public void testIsTrueVersion2() {

    assertTrue(m.isTrueVersion2("true"));

    assertFalse(m.isTrueVersion2("true2"));

    assertTrue(m.isTrueVersion2("True"));;

  }

  @Test

  public void testIsTrueOrYes() {

    assertTrue(m.isTrueOrYes("true"));

    assertTrue(m.isTrueOrYes("yes"));

    assertTrue(m.isTrueOrYes("Yes"));

    assertFalse(m.isTrueOrYes("no"));

  }

  @Test

  public void testContainsTrue() {

    assertTrue(m.containsTrue("thetruewithin"));

  }

  @Test

  public void testIsThreeLetters() {

    assertTrue(m.isThreeLetters("abc"));

    assertFalse(m.isThreeLetters("abcd"));

  }

  @Test

  public void testisNoNumberAtBeginning() {

    assertTrue(m.isNoNumberAtBeginning("abc"));

    assertFalse(m.isNoNumberAtBeginning("1abcd"));

    assertTrue(m.isNoNumberAtBeginning("a1bcd"));

    assertTrue(m.isNoNumberAtBeginning("asdfdsf"));

  }

  @Test

  public void testisIntersection() {

    assertTrue(m.isIntersection("1"));

    assertFalse(m.isIntersection("abcksdfkdskfsdfdsf"));

    assertTrue(m.isIntersection("skdskfjsmcnxmvjwque484242"));

  }

  @Test

  public void testLessThenThreeHundred() {

    assertTrue(m.isLessThenThreeHundred("288"));

    assertFalse(m.isLessThenThreeHundred("3288"));

    assertFalse(m.isLessThenThreeHundred("328 8"));

    assertTrue(m.isLessThenThreeHundred("1"));

    assertTrue(m.isLessThenThreeHundred("99"));

    assertFalse(m.isLessThenThreeHundred("300"));

  }

}