Java/Regular Expressions/Pattern
Содержание
- 1 A block of text to use as input to the regular expression matcher
- 2 Adding Comments to a Regular Expression
- 3 Allows you to easily try out regular expressions
- 4 Another pattern split
- 5 Compiling a Pattern with Multiple Flags
- 6 Find all matches
- 7 Finding Every Occurrence of the Letter A
- 8 Find the end point of the second "test"
- 9 Implement a pattern matcher for regular expressions
- 10 Match Duplicate Words
- 11 Matcher.end(): find the end point
- 12 Matcher.reset(CharSequence)
- 13 Matcher.reset: restart
- 14 Matcher.start(): Find the starting point
- 15 Matcher.start(int) Example
- 16 Matching Across Line Boundaries in a Regular Expression
- 17 Match one or more
- 18 PatternConvenience -- demonstrate java.util.regex.Pattern convenience routine
- 19 Pattern: flags
- 20 Pattern helper
- 21 Pattern Match
- 22 Pattern: Resetting
- 23 Pattern Split
- 24 Possessive Qualifier Example
- 25 Reg Exp Example
- 26 Regular expression and CharSequence
- 27 Regular expression search program
- 28 Regular expressions: start End
- 29 Setting Case Sensitivity in a Regular Expression
- 30 Show use of Pattern.CANON_EQ
- 31 Simple example of using Regular Expressions functionality in String class
- 32 Simple Negative Lookahead
- 33 Simple Pattern
- 34 Simple Positive Lookahead
- 35 Simple Positive Lookbehind
- 36 Tabs and newlines in the pattern are ignored as well
- 37 The inline modifier can also contain pattern characters using the form (?x:abc)
- 38 Use a character set
- 39 Use an inline modifier: a (?x: b)
- 40 Use an inline modifier: (?x)a [\\ ] b
- 41 Use an inline modifier: x)a \\s b
- 42 Use enclosing form
- 43 Using the find(int) Method
- 44 Using the find() Method from Matcher
- 45 Using the lookingAt Method
- 46 Validation Test With Pattern And Matcher
A block of text to use as input to the regular expression matcher
<source lang="java">
// : c12:TheReplacements.java // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.regex.Matcher; import java.util.regex.Pattern; /*
* ! Here"s a block of text to use as input to the regular expression matcher. * Note that we"ll first extract the block of text by looking for the special * delimiters, then process the extracted block. ! */
public class TheReplacements {
public static void main(String[] args) throws Exception {
String s = TextFile.read("TheReplacements.java");
// Match the specially-commented block of text above:
Matcher mInput = Pattern.rupile("/\\*!(.*)!\\*/", Pattern.DOTALL)
.matcher(s);
if (mInput.find())
s = mInput.group(1); // Captured by parentheses
// Replace two or more spaces with a single space:
s = s.replaceAll(" {2,}", " ");
// Replace one or more spaces at the beginning of each
// line with no spaces. Must enable MULTILINE mode:
s = s.replaceAll("(?m)^ +", "");
System.out.println(s);
s = s.replaceFirst("[aeiou]", "(VOWEL1)");
StringBuffer sbuf = new StringBuffer();
Pattern p = Pattern.rupile("[aeiou]");
Matcher m = p.matcher(s);
// Process the find information as you
// perform the replacements:
while (m.find())
m.appendReplacement(sbuf, m.group().toUpperCase());
// Put in the remainder of the text:
m.appendTail(sbuf);
System.out.println(sbuf);
}
} ///:~ class TextFile extends ArrayList {
// Tools to read and write files as single strings:
public static String read(String fileName) throws IOException {
StringBuffer sb = new StringBuffer();
BufferedReader in = new BufferedReader(new FileReader(fileName));
String s;
while ((s = in.readLine()) != null) {
sb.append(s);
sb.append("\n");
}
in.close();
return sb.toString();
}
public static void write(String fileName, String text) throws IOException {
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
fileName)));
out.print(text);
out.close();
}
public TextFile(String fileName) throws IOException {
super(Arrays.asList(read(fileName).split("\n")));
}
public void write(String fileName) throws IOException {
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
fileName)));
for (int i = 0; i < size(); i++)
out.println(get(i));
out.close();
}
// Simple test:
public static void main(String[] args) throws Exception {
String file = read("TextFile.java");
write("test.txt", file);
TextFile text = new TextFile("test.txt");
text.write("test2.txt");
}
} ///:~
</source>
Adding Comments to a Regular Expression
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
// Use COMMENTS but include a character class with a space
CharSequence inputStr = "a b";
String patternStr = "a b";
// Compile without comments
Pattern pattern = Pattern.rupile(patternStr);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
// Compile with comments
pattern = Pattern.rupile(patternStr, Pattern.ruMENTS);
matcher = pattern.matcher(inputStr);
matchFound = matcher.matches();
patternStr = "a [\\ ] b";
pattern = Pattern.rupile(patternStr, Pattern.ruMENTS);
matcher = pattern.matcher(inputStr);
matchFound = matcher.matches();
}
}
</source>
Allows you to easily try out regular expressions
<source lang="java">
// : c12:TestRegularExpression.java // Allows you to easly try out regular expressions. // {Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" } // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.regex.Matcher; import java.util.regex.Pattern; public class TestRegularExpression {
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("Usage:\n" + "java TestRegularExpression "
+ "characterSequence regularExpression+");
System.exit(0);
}
System.out.println("Input: \"" + args[0] + "\"");
for (int i = 1; i < args.length; i++) {
System.out.println("Regular expression: \"" + args[i] + "\"");
Pattern p = Pattern.rupile(args[i]);
Matcher m = p.matcher(args[0]);
while (m.find()) {
System.out.println("Match \"" + m.group() + "\" at positions "
+ m.start() + "-" + (m.end() - 1));
}
}
}
} ///:~
</source>
Another pattern split
<source lang="java">
import java.util.regex.Pattern; public class PatternSplit {
public static void main(String args[]) {
String statement = "I will not compromise. I will not "
+ "cooperate. There will be no concession, no conciliation, no "
+ "finding the middle ground, and no give and take.";
String tokens[] = null;
String splitPattern = "compromise|cooperate|concession|"
+ "conciliation|(finding the middle ground)|(give and take)";
Pattern p = Pattern.rupile(splitPattern);
tokens = p.split(statement);
System.out.println("REGEX PATTERN:\n" + splitPattern + "\n");
System.out.println("STATEMENT:\n" + statement + "\n");
System.out.println("TOKENS:");
for (int i = 0; i < tokens.length; i++) {
System.out.println(tokens[i]);
}
}
}
</source>
Compiling a Pattern with Multiple Flags
<source lang="java">
Multiple flags must be combined using the or operator (|). import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "Abc\ndef";
String patternStr = "abc$";
// Compile with multiline and case-insensitive enabled
Pattern pattern = Pattern.rupile(patternStr, Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.find();
}
}
</source>
Find all matches
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
Pattern pattern = Pattern.rupile("pattern");
Matcher matcher = pattern.matcher("infile.txt");
// Find all matches
while (matcher.find()) {
// Get the matching string
String match = matcher.group();
}
}
}
</source>
Finding Every Occurrence of the Letter A
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) throws Exception {
String candidate = "this is a test, A TEST.";
String regex = "\\ba\\w*\\b";
Pattern p = Pattern.rupile(regex);
Matcher m = p.matcher(candidate);
String val = null;
System.out.println("INPUT: " + candidate);
System.out.println("REGEX: " + regex + "\r\n");
while (m.find()) {
val = m.group();
System.out.println("MATCH: " + val);
}
if (val == null) {
System.out.println("NO MATCHES: ");
}
}
}
</source>
Find the end point of the second "test"
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
String candidateString = "This is a test. This is another test.";
Pattern p = Pattern.rupile("test");
Matcher matcher = p.matcher(candidateString);
matcher.find();
int nextIndex = matcher.end();
System.out.println(nextIndex);
}
}
</source>
Implement a pattern matcher for regular expressions
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.swing.JFormattedTextField; import javax.swing.JLabel; import javax.swing.text.DefaultFormatter; public class Main extends DefaultFormatter {
protected Matcher matcher;
public Main(Pattern regex) {
setOverwriteMode(false);
matcher = regex.matcher("");
}
public Object stringToValue(String string) throws java.text.ParseException {
if (string == null) return null;
matcher.reset(string);
if (! matcher.matches())
throw new java.text.ParseException("does not match regex", 0);
return super.stringToValue(string);
}
public static void main(String argv[]) {
Pattern evenLength = Pattern.rupile("(..)*");
JFormattedTextField ftf1 = new JFormattedTextField(new Main(evenLength));
JLabel lab2 = new JLabel("no vowels:");
Pattern noVowels = Pattern.rupile("[^aeiou]*",Pattern.CASE_INSENSITIVE);
Main noVowelFormatter = new Main(noVowels);
noVowelFormatter.setAllowsInvalid(false);
JFormattedTextField ftf2 = new JFormattedTextField(noVowelFormatter);
}
}
</source>
Match Duplicate Words
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) throws Exception {
String duplicatePattern = "\\b(\\w+) \\1\\b";
Pattern p = Pattern.rupile(duplicatePattern);
int matches = 0;
String phrase = "this is a test";
Matcher m = p.matcher(phrase);
String val = null;
while (m.find()) {
val = ":" + m.group() + ":";
System.out.println(val);
matches++;
}
}
}
</source>
Matcher.end(): find the end point
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
String candidateString = "This is a test. This is another test.";
Pattern p = Pattern.rupile("test");
Matcher matcher = p.matcher(candidateString);
matcher.find();
int endIndex = matcher.end();
System.out.println(candidateString);
System.out.println( endIndex);
}
}
</source>
Matcher.reset(CharSequence)
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
Pattern p = Pattern.rupile("\\d");
Matcher m1 = p.matcher("01234");
while (m1.find()) {
System.out.println("\t\t" + m1.group());
}
m1.reset("56789");
while (m1.find()) {
System.out.println("\t\t" + m1.group());
}
}
}
</source>
Matcher.reset: restart
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
Pattern p = Pattern.rupile("\\d");
Matcher m1 = p.matcher("01234");
while (m1.find()) {
System.out.println("\t\t" + m1.group());
}
m1.reset();
System.out.println("After resetting the Matcher");
while (m1.find()) {
System.out.println("\t\t" + m1.group());
}
}
}
</source>
Matcher.start(): Find the starting point
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
String candidateString = "This is a test. This is another test";
Pattern p = Pattern.rupile("test");
Matcher matcher = p.matcher(candidateString);
// Find the starting point of the first "test"
matcher.find();
int startIndex = matcher.start();
System.out.println(candidateString);
System.out.println(startIndex);
// Find the starting point of the second "test"
matcher.find();
int nextIndex = matcher.start();
System.out.println(candidateString);
System.out.println(nextIndex);
}
}
</source>
Matcher.start(int) Example
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
Pattern p = Pattern.rupile("t(est)");
String candidateString = "This is a test. This is another test";
Matcher matcher = p.matcher(candidateString);
matcher.find();
int startIndex = matcher.start(0);
System.out.println(candidateString);
System.out.println(startIndex);
}
}
</source>
Matching Across Line Boundaries in a Regular Expression
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "abc\ndef";
String patternStr = ".*c.+d.*";
Pattern pattern = Pattern.rupile(patternStr, Pattern.DOTALL);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
matchFound = pattern.matches(".*c.+d.*", "abc\r\ndef");
matchFound = pattern.matches("(?s).*c.+d.*", "abc\r\ndef");
}
}
</source>
Match one or more
<source lang="java">
import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
String regex = "ad*";
String input = "add";
boolean isMatch = Pattern.matches(regex, input);
System.out.println(isMatch);// return true
}
}
</source>
PatternConvenience -- demonstrate java.util.regex.Pattern convenience routine
<source lang="java">
/*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002. * All rights reserved. Software written by Ian F. Darwin and others. * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS"" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s, * pioneering role in inventing and promulgating (and standardizing) the Java * language and environment is gratefully acknowledged. * * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for * inventing predecessor languages C and C++ is also gratefully acknowledged. */
import java.util.regex.*; /**
* PatternConvenience -- demonstrate java.util.regex.Pattern convenience routine * @author Ian F. Darwin * @version $Id: PatternConvenience.java,v 1.1 2003/05/09 19:25:50 ian Exp $ */
public class PatternConvenience {
public static void main(String[] argv) {
String pattern = ".*Q[^u]\\d+\\..*";
String line = "Order QT300. Now!";
if (Pattern.matches(pattern, line)) {
System.out.println(line + " matches \"" + pattern + "\"");
} else {
System.out.println("NO MATCH");
}
}
}
</source>
Pattern: flags
<source lang="java">
// : c12:ReFlags.java // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.regex.Matcher; import java.util.regex.Pattern; public class ReFlags {
public static void main(String[] args) {
Pattern p = Pattern.rupile("^java", Pattern.CASE_INSENSITIVE
| Pattern.MULTILINE);
Matcher m = p.matcher("java has regex\nJava has regex\n"
+ "JAVA has pretty good regular expressions\n"
+ "Regular expressions are in Java");
while (m.find())
System.out.println(m.group());
}
} ///:~
</source>
Pattern helper
<source lang="java">
/*
* Static String formatting and query routines. * Copyright (C) 2001-2005 Stephen Ostermiller * http://ostermiller.org/contact.pl?regarding=Java+Utilities * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * See COPYING.TXT for details. */
import java.util.HashMap; import java.util.regex.Pattern; /**
* Utilities for String formatting, manipulation, and queries. * More information about this class is available from . * * @author Stephen Ostermiller http://ostermiller.org/contact.pl?regarding=Java+Utilities * @since ostermillerutils 1.00.00 */
public class StringHelper {
/**
* Build a regular expression that is each of the terms or"d together.
*
* @param terms a list of search terms.
* @param sb place to build the regular expression.
* @throws IllegalArgumentException if the length of terms is zero.
*
* @since ostermillerutils 1.02.25
*/
private static void buildFindAnyPattern(String[] terms, StringBuffer sb){
if (terms.length == 0) throw new IllegalArgumentException("There must be at least one term to find.");
sb.append("(?:");
for (int i=0; i<terms.length; i++){
if (i>0) sb.append("|");
sb.append("(?:");
sb.append(escapeRegularExpressionLiteral(terms[i]));
sb.append(")");
}
sb.append(")");
}
/**
* Compile a pattern that can will match a string if the string
* contains any of the given terms.
*
* Usage:
* boolean b = getContainsAnyPattern(terms).matcher(s).matches();
* <p>
* If multiple strings are matched against the same set of terms,
* it is more efficient to reuse the pattern returned by this function.
*
* @param terms Array of search strings.
* @return Compiled pattern that can be used to match a string to see if it contains any of the terms.
*
* @since ostermillerutils 1.02.25
*/
public static Pattern getContainsAnyPattern(String[] terms){
StringBuffer sb = new StringBuffer();
sb.append("(?s).*");
buildFindAnyPattern(terms, sb);
sb.append(".*");
return Pattern.rupile(sb.toString());
}
/**
* Compile a pattern that can will match a string if the string
* equals any of the given terms.
* <p>
* Usage:
* boolean b = getEqualsAnyPattern(terms).matcher(s).matches();
* <p>
* If multiple strings are matched against the same set of terms,
* it is more efficient to reuse the pattern returned by this function.
*
* @param terms Array of search strings.
* @return Compiled pattern that can be used to match a string to see if it equals any of the terms.
*
* @since ostermillerutils 1.02.25
*/
public static Pattern getEqualsAnyPattern(String[] terms){
StringBuffer sb = new StringBuffer();
sb.append("(?s)\\A");
buildFindAnyPattern(terms, sb);
sb.append("\\z");
return Pattern.rupile(sb.toString());
}
/**
* Compile a pattern that can will match a string if the string
* starts with any of the given terms.
* <p>
* Usage:
* boolean b = getStartsWithAnyPattern(terms).matcher(s).matches();
* <p>
* If multiple strings are matched against the same set of terms,
* it is more efficient to reuse the pattern returned by this function.
*
* @param terms Array of search strings.
* @return Compiled pattern that can be used to match a string to see if it starts with any of the terms.
*
* @since ostermillerutils 1.02.25
*/
public static Pattern getStartsWithAnyPattern(String[] terms){
StringBuffer sb = new StringBuffer();
sb.append("(?s)\\A");
buildFindAnyPattern(terms, sb);
sb.append(".*");
return Pattern.rupile(sb.toString());
}
/**
* Compile a pattern that can will match a string if the string
* ends with any of the given terms.
* <p>
* Usage:
* boolean b = getEndsWithAnyPattern(terms).matcher(s).matches();
* <p>
* If multiple strings are matched against the same set of terms,
* it is more efficient to reuse the pattern returned by this function.
*
* @param terms Array of search strings.
* @return Compiled pattern that can be used to match a string to see if it ends with any of the terms.
*
* @since ostermillerutils 1.02.25
*/
public static Pattern getEndsWithAnyPattern(String[] terms){
StringBuffer sb = new StringBuffer();
sb.append("(?s).*");
buildFindAnyPattern(terms, sb);
sb.append("\\z");
return Pattern.rupile(sb.toString());
}
/**
* Compile a pattern that can will match a string if the string
* contains any of the given terms.
* <p>
* Case is ignored when matching using Unicode case rules.
* <p>
* Usage:
* boolean b = getContainsAnyPattern(terms).matcher(s).matches();
* <p>
* If multiple strings are matched against the same set of terms,
* it is more efficient to reuse the pattern returned by this function.
*
* @param terms Array of search strings.
* @return Compiled pattern that can be used to match a string to see if it contains any of the terms.
*
* @since ostermillerutils 1.02.25
*/
public static Pattern getContainsAnyIgnoreCasePattern(String[] terms){
StringBuffer sb = new StringBuffer();
sb.append("(?i)(?u)(?s).*");
buildFindAnyPattern(terms, sb);
sb.append(".*");
return Pattern.rupile(sb.toString());
}
/**
* Compile a pattern that can will match a string if the string
* equals any of the given terms.
* <p>
* Case is ignored when matching using Unicode case rules.
* <p>
* Usage:
* boolean b = getEqualsAnyPattern(terms).matcher(s).matches();
* <p>
* If multiple strings are matched against the same set of terms,
* it is more efficient to reuse the pattern returned by this function.
*
* @param terms Array of search strings.
* @return Compiled pattern that can be used to match a string to see if it equals any of the terms.
*
* @since ostermillerutils 1.02.25
*/
public static Pattern getEqualsAnyIgnoreCasePattern(String[] terms){
StringBuffer sb = new StringBuffer();
sb.append("(?i)(?u)(?s)\\A");
buildFindAnyPattern(terms, sb);
sb.append("\\z");
return Pattern.rupile(sb.toString());
}
/**
* Compile a pattern that can will match a string if the string
* starts with any of the given terms.
* <p>
* Case is ignored when matching using Unicode case rules.
* <p>
* Usage:
* boolean b = getStartsWithAnyPattern(terms).matcher(s).matches();
* <p>
* If multiple strings are matched against the same set of terms,
* it is more efficient to reuse the pattern returned by this function.
*
* @param terms Array of search strings.
* @return Compiled pattern that can be used to match a string to see if it starts with any of the terms.
*
* @since ostermillerutils 1.02.25
*/
public static Pattern getStartsWithAnyIgnoreCasePattern(String[] terms){
StringBuffer sb = new StringBuffer();
sb.append("(?i)(?u)(?s)\\A");
buildFindAnyPattern(terms, sb);
sb.append(".*");
return Pattern.rupile(sb.toString());
}
/**
* Compile a pattern that can will match a string if the string
* ends with any of the given terms.
* <p>
* Case is ignored when matching using Unicode case rules.
* <p>
* Usage:
* boolean b = getEndsWithAnyPattern(terms).matcher(s).matches();
* <p>
* If multiple strings are matched against the same set of terms,
* it is more efficient to reuse the pattern returned by this function.
*
* @param terms Array of search strings.
* @return Compiled pattern that can be used to match a string to see if it ends with any of the terms.
*
* @since ostermillerutils 1.02.25
*/
public static Pattern getEndsWithAnyIgnoreCasePattern(String[] terms){
StringBuffer sb = new StringBuffer();
sb.append("(?i)(?u)(?s).*");
buildFindAnyPattern(terms, sb);
sb.append("\\z");
return Pattern.rupile(sb.toString());
}
/**
* Tests to see if the given string contains any of the given terms.
* <p>
* This implementation is more efficient than the brute force approach
* of testing the string against each of the terms. It instead compiles
* a single regular expression that can test all the terms at once, and
* uses that expression against the string.
* <p>
* This is a convenience method. If multiple strings are tested against
* the same set of terms, it is more efficient not to compile the regular
* expression multiple times.
* @see #getContainsAnyPattern(String[])
*
* @param s String that may contain any of the given terms.
* @param terms list of substrings that may be contained in the given string.
* @return true iff one of the terms is a substring of the given string.
*
* @since ostermillerutils 1.02.25
*/
public static boolean containsAny(String s, String[] terms){
return getContainsAnyPattern(terms).matcher(s).matches();
}
/**
* Tests to see if the given string equals any of the given terms.
* <p>
* This implementation is more efficient than the brute force approach
* of testing the string against each of the terms. It instead compiles
* a single regular expression that can test all the terms at once, and
* uses that expression against the string.
* <p>
* This is a convenience method. If multiple strings are tested against
* the same set of terms, it is more efficient not to compile the regular
* expression multiple times.
* @see #getEqualsAnyPattern(String[])
*
* @param s String that may equal any of the given terms.
* @param terms list of strings that may equal the given string.
* @return true iff one of the terms is equal to the given string.
*
* @since ostermillerutils 1.02.25
*/
public static boolean equalsAny(String s, String[] terms){
return getEqualsAnyPattern(terms).matcher(s).matches();
}
/**
* Tests to see if the given string starts with any of the given terms.
* <p>
* This implementation is more efficient than the brute force approach
* of testing the string against each of the terms. It instead compiles
* a single regular expression that can test all the terms at once, and
* uses that expression against the string.
* <p>
* This is a convenience method. If multiple strings are tested against
* the same set of terms, it is more efficient not to compile the regular
* expression multiple times.
* @see #getStartsWithAnyPattern(String[])
*
* @param s String that may start with any of the given terms.
* @param terms list of strings that may start with the given string.
* @return true iff the given string starts with one of the given terms.
*
* @since ostermillerutils 1.02.25
*/
public static boolean startsWithAny(String s, String[] terms){
return getStartsWithAnyPattern(terms).matcher(s).matches();
}
/**
* Tests to see if the given string ends with any of the given terms.
* <p>
* This implementation is more efficient than the brute force approach
* of testing the string against each of the terms. It instead compiles
* a single regular expression that can test all the terms at once, and
* uses that expression against the string.
* <p>
* This is a convenience method. If multiple strings are tested against
* the same set of terms, it is more efficient not to compile the regular
* expression multiple times.
* @see #getEndsWithAnyPattern(String[])
*
* @param s String that may end with any of the given terms.
* @param terms list of strings that may end with the given string.
* @return true iff the given string ends with one of the given terms.
*
* @since ostermillerutils 1.02.25
*/
public static boolean endsWithAny(String s, String[] terms){
return getEndsWithAnyPattern(terms).matcher(s).matches();
}
/**
* Tests to see if the given string contains any of the given terms.
* <p>
* Case is ignored when matching using Unicode case rules.
* <p>
* This implementation is more efficient than the brute force approach
* of testing the string against each of the terms. It instead compiles
* a single regular expression that can test all the terms at once, and
* uses that expression against the string.
* <p>
* This is a convenience method. If multiple strings are tested against
* the same set of terms, it is more efficient not to compile the regular
* expression multiple times.
* @see #getContainsAnyIgnoreCasePattern(String[])
*
* @param s String that may contain any of the given terms.
* @param terms list of substrings that may be contained in the given string.
* @return true iff one of the terms is a substring of the given string.
*
* @since ostermillerutils 1.02.25
*/
public static boolean containsAnyIgnoreCase(String s, String[] terms){
return getContainsAnyIgnoreCasePattern(terms).matcher(s).matches();
}
/**
* Tests to see if the given string equals any of the given terms.
* <p>
* Case is ignored when matching using Unicode case rules.
* <p>
* This implementation is more efficient than the brute force approach
* of testing the string against each of the terms. It instead compiles
* a single regular expression that can test all the terms at once, and
* uses that expression against the string.
* <p>
* This is a convenience method. If multiple strings are tested against
* the same set of terms, it is more efficient not to compile the regular
* expression multiple times.
* @see #getEqualsAnyIgnoreCasePattern(String[])
*
* @param s String that may equal any of the given terms.
* @param terms list of strings that may equal the given string.
* @return true iff one of the terms is equal to the given string.
*
* @since ostermillerutils 1.02.25
*/
public static boolean equalsAnyIgnoreCase(String s, String[] terms){
return getEqualsAnyIgnoreCasePattern(terms).matcher(s).matches();
}
/**
* Tests to see if the given string starts with any of the given terms.
* <p>
* Case is ignored when matching using Unicode case rules.
* <p>
* This implementation is more efficient than the brute force approach
* of testing the string against each of the terms. It instead compiles
* a single regular expression that can test all the terms at once, and
* uses that expression against the string.
* <p>
* This is a convenience method. If multiple strings are tested against
* the same set of terms, it is more efficient not to compile the regular
* expression multiple times.
* @see #getStartsWithAnyIgnoreCasePattern(String[])
*
* @param s String that may start with any of the given terms.
* @param terms list of strings that may start with the given string.
* @return true iff the given string starts with one of the given terms.
*
* @since ostermillerutils 1.02.25
*/
public static boolean startsWithAnyIgnoreCase(String s, String[] terms){
return getStartsWithAnyIgnoreCasePattern(terms).matcher(s).matches();
}
/**
* Tests to see if the given string ends with any of the given terms.
* <p>
* Case is ignored when matching using Unicode case rules.
* <p>
* This implementation is more efficient than the brute force approach
* of testing the string against each of the terms. It instead compiles
* a single regular expression that can test all the terms at once, and
* uses that expression against the string.
* <p>
* This is a convenience method. If multiple strings are tested against
* the same set of terms, it is more efficient not to compile the regular
* expression multiple times.
* @see #getEndsWithAnyIgnoreCasePattern(String[])
*
* @param s String that may end with any of the given terms.
* @param terms list of strings that may end with the given string.
* @return true iff the given string ends with one of the given terms.
*
* @since ostermillerutils 1.02.25
*/
public static boolean endsWithAnyIgnoreCase(String s, String[] terms){
return getEndsWithAnyIgnoreCasePattern(terms).matcher(s).matches();
}
/**
* Escapes characters that have special meaning to
* regular expressions
*
* @param s String to be escaped
* @return escaped String
* @throws NullPointerException if s is null.
*
* @since ostermillerutils 1.02.25
*/
public static String escapeRegularExpressionLiteral(String s){
// According to the documentation in the Pattern class:
//
// The backslash character ("\") serves to introduce escaped constructs,
// as defined in the table above, as well as to quote characters that
// otherwise would be interpreted as unescaped constructs. Thus the
// expression \\ matches a single backslash and \{ matches a left brace.
//
// It is an error to use a backslash prior to any alphabetic character
// that does not denote an escaped construct; these are reserved for future
// extensions to the regular-expression language. A backslash may be used
// prior to a non-alphabetic character regardless of whether that character
// is part of an unescaped construct.
//
// As a result, escape everything except [0-9a-zA-Z]
int length = s.length();
int newLength = length;
// first check for characters that might
// be dangerous and calculate a length
// of the string that has escapes.
for (int i=0; i<length; i++){
char c = s.charAt(i);
if (!((c>="0" && c<="9") || (c>="A" && c<="Z") || (c>="a" && c<="z"))){
newLength += 1;
}
}
if (length == newLength){
// nothing to escape in the string
return s;
}
StringBuffer sb = new StringBuffer(newLength);
for (int i=0; i<length; i++){
char c = s.charAt(i);
if (!((c>="0" && c<="9") || (c>="A" && c<="Z") || (c>="a" && c<="z"))){
sb.append("\\");
}
sb.append(c);
}
return sb.toString();
}
}
</source>
Pattern Match
<source lang="java">
import java.util.regex.Pattern; public class PatternMatchesTest {
public static void main(String args[]) {
String regex = "ad*";
String input = "add";
boolean isMatch = Pattern.matches(regex, input);
System.out.println(isMatch);//return true
}
}
</source>
Pattern: Resetting
<source lang="java">
// : c12:Resetting.java // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.regex.Matcher; import java.util.regex.Pattern; public class Resetting {
public static void main(String[] args) throws Exception {
Matcher m = Pattern.rupile("[frb][aiu][gx]").matcher(
"fix the rug with bags");
while (m.find())
System.out.println(m.group());
m.reset("fix the rig with rags");
while (m.find())
System.out.println(m.group());
}
} ///:~
</source>
Pattern Split
<source lang="java">
import java.util.regex.Pattern; public class PatternSplitExample {
public static void main(String args[]) {
Pattern p = Pattern.rupile(" ");
String tmp = "this is the String I want to split up";
String[] tokens = p.split(tmp);
for (int i = 0; i < tokens.length; i++) {
System.out.println(tokens[i]);
}
}
}
</source>
Possessive Qualifier Example
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
String regex = "(\\w++)(\\d\\d)(\\w+)";
Pattern pattern = Pattern.rupile(regex);
String candidate = "X99 test 55";
Matcher matcher = pattern.matcher(candidate);
if (matcher.find()) {
System.out.println("GROUP 0:" + matcher.group(0));
System.out.println("GROUP 1:" + matcher.group(1));
System.out.println("GROUP 2:" + matcher.group(2));
System.out.println("GROUP 3:" + matcher.group(3));
} else {
System.out.println("NO MATCHES");
}
}
}
</source>
Reg Exp Example
<source lang="java">
import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegExpExample {
public static void main(String args[]) {
String fileName = "RETestSource.java";
String unadornedClassRE = "^\\s*class (\\w+)";
String doubleIdentifierRE = "\\b(\\w+)\\s+\\1\\b";
Pattern classPattern = Pattern.rupile(unadornedClassRE);
Pattern doublePattern = Pattern.rupile(doubleIdentifierRE);
Matcher classMatcher, doubleMatcher;
int lineNumber = 0;
try {
BufferedReader br = new BufferedReader(new FileReader(fileName));
String line;
while ((line = br.readLine()) != null) {
lineNumber++;
classMatcher = classPattern.matcher(line);
doubleMatcher = doublePattern.matcher(line);
if (classMatcher.find()) {
System.out.println("The class [" + classMatcher.group(1)
+ "] is not public");
}
while (doubleMatcher.find()) {
System.out.println("The word \"" + doubleMatcher.group(1)
+ "\" occurs twice at position "
+ doubleMatcher.start() + " on line " + lineNumber);
}
}
} catch (IOException ioe) {
System.out.println("IOException: " + ioe);
ioe.printStackTrace();
}
}
}
</source>
Regular expression and CharSequence
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] args) {
String patternStr = "b";
Pattern pattern = Pattern.rupile(patternStr);
CharSequence inputStr = "a b c b";
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.find();
System.out.println(matchFound);
String match = matcher.group();
System.out.println(match);
int start = matcher.start();
int end = matcher.end();
System.out.println(start);
System.out.println(end);
matchFound = matcher.find();
}
}
</source>
Regular expression search program
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] args) {
String patternStr = "b";
Pattern pattern = Pattern.rupile(patternStr);
CharSequence inputStr = "a b c b";
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.find();
System.out.println(matchFound);
String match = matcher.group();
int start = matcher.start();
int end = matcher.end();
System.out.println(start);
System.out.println(end);
matchFound = matcher.find();
}
}
</source>
Regular expressions: start End
<source lang="java">
// : c12:StartEnd.java // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.regex.Matcher; import java.util.regex.Pattern; public class StartEnd {
public static void main(String[] args) {
String[] input = new String[] { "Java has regular expressions in 1.4",
"regular expressions now expressing in Java",
"Java represses oracular expressions" };
Pattern p1 = Pattern.rupile("re\\w*"), p2 = Pattern.rupile("Java.*");
for (int i = 0; i < input.length; i++) {
System.out.println("input " + i + ": " + input[i]);
Matcher m1 = p1.matcher(input[i]), m2 = p2.matcher(input[i]);
while (m1.find())
System.out.println("m1.find() "" + m1.group() + "" start = "
+ m1.start() + " end = " + m1.end());
while (m2.find())
System.out.println("m2.find() "" + m2.group() + "" start = "
+ m2.start() + " end = " + m2.end());
if (m1.lookingAt()) // No reset() necessary
System.out.println("m1.lookingAt() start = " + m1.start()
+ " end = " + m1.end());
if (m2.lookingAt())
System.out.println("m2.lookingAt() start = " + m2.start()
+ " end = " + m2.end());
if (m1.matches()) // No reset() necessary
System.out.println("m1.matches() start = " + m1.start()
+ " end = " + m1.end());
if (m2.matches())
System.out.println("m2.matches() start = " + m2.start()
+ " end = " + m2.end());
}
}
} ///:~
</source>
Setting Case Sensitivity in a Regular Expression
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "Abc";
String patternStr = "abc";
// Compile with case-insensitivity
Pattern pattern = Pattern.rupile(patternStr, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
// Use an inline modifier
matchFound = pattern.matches("abc", "aBc");
matchFound = pattern.matches("(?i)abc", "aBc");
matchFound = pattern.matches("a(?i)bc", "aBc");
}
}
</source>
Show use of Pattern.CANON_EQ
<source lang="java">
/*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002. * All rights reserved. Software written by Ian F. Darwin and others. * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS"" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s, * pioneering role in inventing and promulgating (and standardizing) the Java * language and environment is gratefully acknowledged. * * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for * inventing predecessor languages C and C++ is also gratefully acknowledged. */
import java.util.regex.Pattern; /**
* CanonEqDemo - show use of Pattern.CANON_EQ, by comparing varous ways of * entering the Spanish word for "equal" and see if they are considered equal by * the RE-matching engine. * * @version $Id: CanonEqDemo.java,v 1.3 2004/03/21 20:06:20 ian Exp $ */
public class CanonEqDemo {
public static void main(String[] args) {
String pattStr = "\u00e9gal"; // Zgal
String[] input = { "\u00e9gal", // Zgal - this one had better match :-)
"e\u0301gal", // e + "Combining acute accent"
"e\u02cagal", // e + "modifier letter acute accent"
"e"gal", // e + single quote
"e\u00b4gal", // e + Latin-1 "acute"
};
Pattern pattern = Pattern.rupile(pattStr, Pattern.CANON_EQ);
for (int i = 0; i < input.length; i++) {
if (pattern.matcher(input[i]).matches()) {
System.out.println(pattStr + " matches input " + input[i]);
} else {
System.out.println(pattStr + " does not match input "
+ input[i]);
}
}
}
}
</source>
Simple example of using Regular Expressions functionality in String class
<source lang="java">
/*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002. * All rights reserved. Software written by Ian F. Darwin and others. * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS"" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s, * pioneering role in inventing and promulgating (and standardizing) the Java * language and environment is gratefully acknowledged. * * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for * inventing predecessor languages C and C++ is also gratefully acknowledged. */
/**
* Simple example of using RE functionality in String class. * @author Ian F. Darwin, http://www.darwinsys.ru/ * @version $Id: REString.java,v 1.4 2004/02/23 02:37:34 ian Exp $ */
public class REString {
public static void main(String[] argv) {
String pattern = "^Q[^u]\\d+\\..*";
String input = "QA777. is the next flight. It is on time.";
boolean found = input.matches(pattern);
System.out.println(""" + pattern + """ +
(found ? " matches " : " doesn"t match "") + input + """);
}
}
</source>
Simple Negative Lookahead
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) throws Exception {
String regex = "test (?!Test)[A-Z]\\w+";
Pattern pattern = Pattern.rupile(regex);
String candidate = "this is a test ";
Matcher matcher = pattern.matcher(candidate);
String tmp = null;
while (matcher.find()) {
tmp = matcher.group();
System.out.println("MATCH:" + tmp);
}
}
}
</source>
Simple Pattern
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class PatternMethodExample {
public static void main(String args[]) {
reusePatternMethodExample();
}
public static void reusePatternMethodExample() {
Pattern p = Pattern.rupile("\\d");
Matcher matcher = p.matcher("5");
boolean isOk = matcher.matches();
System.out.println("original pattern matches " + isOk);
String tmp = p.pattern();
Pattern p2 = Pattern.rupile(tmp);
matcher = p.matcher("5");
isOk = matcher.matches();
System.out.println("second pattern matches " + isOk);
}
}
</source>
Simple Positive Lookahead
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
String regex = "(?=^255).*";
Pattern pattern = Pattern.rupile(regex);
String candidate = "255.0.0.1";
Matcher matcher = pattern.matcher(candidate);
String ip = "not found";
if (matcher.find())
ip = matcher.group();
String msg = "ip: " + ip;
System.out.println(msg);
}
}
</source>
Simple Positive Lookbehind
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) throws Exception {
String regex = "(?<=http://)\\S+";
Pattern pattern = Pattern.rupile(regex);
String candidate = "http://www.a.ru.";
Matcher matcher = pattern.matcher(candidate);
while (matcher.find()) {
String msg = ":" + matcher.group() + ":";
System.out.println(msg);
}
}
}
</source>
Tabs and newlines in the pattern are ignored as well
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "a b";
String patternStr = "a b";
// Compile without comments
Pattern pattern = Pattern.rupile(patternStr);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
// Compile with comments
pattern = Pattern.rupile(patternStr, Pattern.ruMENTS);
matcher = pattern.matcher(inputStr);
matchFound = matcher.matches();
matchFound = pattern.matches("(?x)a \t\n \\s b", inputStr);
}
}
</source>
The inline modifier can also contain pattern characters using the form (?x:abc)
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "a b";
String patternStr = "a b";
// Compile without comments
Pattern pattern = Pattern.rupile(patternStr);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
// Compile with comments
pattern = Pattern.rupile(patternStr, Pattern.ruMENTS);
matcher = pattern.matcher(inputStr);
matchFound = matcher.matches(); // false
// Use an inline modifier
matchFound = pattern.matches("a b", inputStr);
matchFound = pattern.matches("(?x)a b", inputStr);
}
}
</source>
Use a character set
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "Abc";
String patternStr = "abc";
// Compile with case-insensitivity
Pattern pattern = Pattern.rupile(patternStr, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
matchFound = pattern.matches("[a-c]+", "aBc");
matchFound = pattern.matches("(?i)[a-c]+", "aBc");
}
}
</source>
Use an inline modifier: a (?x: b)
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "a b";
String patternStr = "a b";
// Compile without comments
Pattern pattern = Pattern.rupile(patternStr);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
// Compile with comments
pattern = Pattern.rupile(patternStr, Pattern.ruMENTS);
matcher = pattern.matcher(inputStr);
matchFound = matcher.matches(); // false
// Use an inline modifier
matchFound = pattern.matches("a (?x: b )", inputStr);
}
}
</source>
Use an inline modifier: (?x)a [\\ ] b
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "a b";
String patternStr = "a b";
// Compile without comments
Pattern pattern = Pattern.rupile(patternStr);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
// Compile with comments
pattern = Pattern.rupile(patternStr, Pattern.ruMENTS);
matcher = pattern.matcher(inputStr);
matchFound = matcher.matches(); // false
// Use an inline modifier
matchFound = pattern.matches("(?x)a [\\ ] b", inputStr);
}
}
</source>
Use an inline modifier: x)a \\s b
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "a b";
String patternStr = "a b";
// Compile without comments
Pattern pattern = Pattern.rupile(patternStr);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
// Compile with comments
pattern = Pattern.rupile(patternStr, Pattern.ruMENTS);
matcher = pattern.matcher(inputStr);
matchFound = matcher.matches(); // false
// Use an inline modifier
matchFound = pattern.matches("(?x)a \\s b", inputStr);
}
}
</source>
Use enclosing form
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String[] argv) throws Exception {
CharSequence inputStr = "Abc";
String patternStr = "abc";
// Compile with case-insensitivity
Pattern pattern = Pattern.rupile(patternStr, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();
matchFound = pattern.matches("((?i)a)bc", "aBc");
matchFound = pattern.matches("(?i:a)bc", "aBc");
matchFound = pattern.matches("a((?i)b)c", "aBc");
matchFound = pattern.matches("a(?i:b)c", "aBc");
}
}
</source>
Using the find(int) Method
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
Pattern p = Pattern.rupile("test", Pattern.CASE_INSENSITIVE);
String candidateString = "Test.";
Matcher matcher = p.matcher(candidateString);
matcher.find(0);
System.out.println(matcher.group());
}
}
</source>
Using the find() Method from Matcher
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
Pattern p = Pattern.rupile("Java");
String candidateString = "Java Java Java.";
Matcher matcher = p.matcher(candidateString);
while (matcher.find()) {
System.out.println(matcher.group());
}
}
}
</source>
Using the lookingAt Method
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) {
Pattern p = Pattern.rupile("test");
Matcher matcher = p.matcher("this is a test");
// display the output for the candidate
System.out.println(matcher.lookingAt());
}
}
</source>
Validation Test With Pattern And Matcher
<source lang="java">
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {
public static void main(String args[]) throws Exception {
Pattern p = Pattern.rupile("Java \\d");
String candidate = "this is a Java test";
Matcher m = p.matcher(candidate);
System.out.println("result=" + m.find());
}
}
</source>
