Java Regular Expressions – Single World Replacement Example /Tutorial

This tutorial will show you a code that I wrote which does a single word replacement on a string using Pattern and Matcher. The example is straightforward. Please review the comments in the code below. I have placed useful comments at various statements in the code.

package com.kushal.regularexpressions;

 * @author Kushal Paudyal
 * Last Modified On 2009-SEPT-16
 * Using Regular Expressions To Replace
 * A Single Word From The String.
import java.util.regex.*;

public class ReplaceSingleWord {
	static String originalString = "Google is Good. "
			+ "Google is Innovative. "
			+ "We think Google is the technology of the era";

	static String replaceWhat = "Google";

	static String replaceWith = "Sanjaal";

	public static void main(String[] args) throws Exception {

		System.out.println("...Before Replacement: n" + originalString + "n");

		 * Create a pattern to match Google.
		 * Pattern.compile () compiles the given regular
		 * expression into a pattern
		Pattern p = Pattern.compile(replaceWhat);

		// Create a matcher with an input string
		 * Creating a matcher with the original input string.
		Matcher m = p.matcher(originalString);

		StringBuffer sb = new StringBuffer();

		System.out.println("...Replacing '" + replaceWhat + "' with '"
				+ replaceWith + "'.n");

		 * Try to find the next subsequence of the input sequence
		 * which patches the pattern.
		boolean result = m.find();

		 * Looping through to create a new string
		 * with replacement applied.
		while (result) {
			m.appendReplacement(sb, replaceWith);
			result = m.find();

		 * Add the last segment of input to the new String
		 * appendTail () method Implements a terminal append-and-replace step.
		 * This method reads characters from the input sequence,
		 * starting at the append position, and appends them to
		 * the given string buffer. It is intended to be invoked
		 * after one or more invocations of the appendReplacement
		 * appendReplacement method in order to copy the
		 * remainder of the input sequence.
		 * Parameters:
		 * sb --> The target string buffer
		 * Returns:
		 * The target string buffer
		System.out.println("...After Replacement:n" + sb.toString());


Output of this program:
…Before Replacement:
Google is Good. Google is Innovative. We think Google is the technology of the era

…Replacing ‘Google’ with ‘Sanjaal’.

…After Replacement:
Sanjaal is Good. Sanjaal is Innovative. We think Sanjaal is the technology of the era

Java Regular Expressions (Theory, Classes and Syntax)

In computing, regular expressions provide a concise and flexible means for identifying strings of text of interest, such as particular characters, words, or patterns of characters. A regular expression (often shortened to regex or regexp) is written in a formal language that can be interpreted by a regular expression processor, a program that either serves as a parser generator or examines text and identifies parts that match the provided specification.

Regular expressions are used by many text editors, utilities, and programming languages to search and manipulate text based on patterns. For example, Perl, Ruby and Tcl have a powerful regular expression engine built directly into their syntax. Several utilities provided by Unix distributions – including the editor ed and the filter grep – were the first to popularize the concept of regular expressions.

As an example of the syntax, the regular expression bex can be used to search for all instances of the string “ex” that occur after “word boundaries” (signified by the b). In laymen’s terms, bex will find the matching string “ex” in two possible locations,

  • At the beginning of words, and
  • Between two characters in a string, where one is a word character and the other is not a word character.

Thus, in the string “Texts for experts,” bex matches the “ex” in “experts” but not in “Texts” (because the “ex” occurs inside a word and not immediately after a word boundary).

Many modern computing systems provide wildcard characters in matching filenames from a file system. This is a core capability of many command-line shells and is also known as globbing. Wildcards differ from regular expressions in generally only expressing very limited forms of alternatives.

The java.util.regex package primarily consists of three classes: Pattern, Matcher, and PatternSyntaxException.

  • A Pattern object is a compiled representation of a regular expression. The Pattern class provides no public constructors. To create a pattern, you must first invoke one of its public static compile methods, which will then return a Pattern object. These methods accept a regular expression as the first argument; the first few lessons of this trail will teach you the required syntax.
  • A Matcher object is the engine that interprets the pattern and performs match operations against an input string. Like the Pattern class, Matcher defines no public constructors. You obtain a Matcher object by invoking the matcher method on a Pattern object.
  • A PatternSyntaxException object is an unchecked exception that indicates a syntax error in a regular expression pattern.

x     The character x
\     The backslash character
n     The character with octal value 0n (0 <= n <= 7)
nn     The character with octal value 0nn (0 <= n <= 7)
mnn     The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7)
xhh     The character with hexadecimal value 0xhh
uhhhh     The character with hexadecimal value 0xhhhh
t     The tab character (‘u0009’)
n     The newline (line feed) character (‘u000A’)
r     The carriage-return character (‘u000D’)
f     The form-feed character (‘u000C’)
a     The alert (bell) character (‘u0007’)
e     The escape character (‘u001B’)
cx     The control character corresponding to x

Character classes
[abc]     a, b, or c (simple class)
[^abc]     Any character except a, b, or c (negation)
[a-zA-Z]     a through z or A through Z, inclusive (range)
[a-d[m-p]]     a through d, or m through p: [a-dm-p] (union)
[a-z&&[def]]     d, e, or f (intersection)
[a-z&&[^bc]]     a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]]     a through z, and not m through p: [a-lq-z](subtraction)

Predefined character classes
.       Any character (may or may not match line terminators)
d     A digit: [0-9]
D     A non-digit: [^0-9]
s     A whitespace character: [ tnx0Bfr]
S     A non-whitespace character: [^s]
w     A word character: [a-zA-Z_0-9]
W     A non-word character: [^w]

POSIX character classes (US-ASCII only)
p{Lower}     A lower-case alphabetic character: [a-z]
p{Upper}     An upper-case alphabetic character:[A-Z]
p{ASCII}     All ASCII:[x00-x7F]
p{Alpha}     An alphabetic character:[p{Lower}p{Upper}]
p{Digit}     A decimal digit: [0-9]
p{Alnum}     An alphanumeric character:[p{Alpha}p{Digit}]
p{Punct}     Punctuation: One of !”#$%&'()*+,-./:;<=>?@[]^_`{|}~
p{Graph}     A visible character: [p{Alnum}p{Punct}]
p{Print}     A printable character: [p{Graph}]
p{Blank}     A space or a tab: [ t]
p{Cntrl}     A control character: [x00-x1Fx7F]
p{XDigit}     A hexadecimal digit: [0-9a-fA-F]
p{Space}     A whitespace character: [ tnx0Bfr]

Classes for Unicode blocks and categories
p{InGreek}     A character in the Greek block (simple block)
p{Lu}     An uppercase letter (simple category)
p{Sc}     A currency symbol
P{InGreek}     Any character except one in the Greek block (negation)
[p{L}&&[^p{Lu}]]      Any letter except an uppercase letter (subtraction)

Boundary matchers
^     The beginning of a line
$     The end of a line
b     A word boundary
B     A non-word boundary
A     The beginning of the input
G     The end of the previous match
Z     The end of the input but for the final terminator, if any
z     The end of the input

Greedy quantifiers
X?     X, once or not at all
X*     X, zero or more times
X+     X, one or more times
X{n}     X, exactly n times
X{n,}     X, at least n times
X{n,m}     X, at least n but not more than m times

Reluctant quantifiers
X??     X, once or not at all
X*?     X, zero or more times
X+?     X, one or more times
X{n}?     X, exactly n times
X{n,}?     X, at least n times
X{n,m}?     X, at least n but not more than m times

Possessive quantifiers
X?+     X, once or not at all
X*+     X, zero or more times
X++     X, one or more times
X{n}+     X, exactly n times
X{n,}+     X, at least n times
X{n,m}+     X, at least n but not more than m times

Logical operators
XY     X followed by Y
X|Y     Either X or Y
(X)     X, as a capturing group

Back references
n     Whatever the nth capturing group matched

    Nothing, but quotes the following character
Q     Nothing, but quotes all characters until E
E     Nothing, but ends quoting started by Q

Special constructs (non-capturing)
(?:X)     X, as a non-capturing group
(?idmsux-idmsux)      Nothing, but turns match flags on – off
(?idmsux-idmsux:X)       X, as a non-capturing group with the given flags on – off
(?=X)     X, via zero-width positive lookahead
(?!X)     X, via zero-width negative lookahead
(?<=X)     X, via zero-width positive lookbehind
(?<!X)     X, via zero-width negative lookbehind
(?>X)     X, as an independent, non-capturing group

This article is based on Wikipedia and Java Patterns page