move regex module from existing module to core-java-regex module
This commit is contained in:
amit.pandey
8
core-java-modules/core-java-regex/README.md
Normal file
8
core-java-modules/core-java-regex/README.md
Normal file
@@ -0,0 +1,8 @@
|
||||
=========
|
||||
|
||||
## Core Java 8 Cookbooks and Examples
|
||||
|
||||
### Relevant Articles:
|
||||
- [An Overview of Regular Expressions Performance in Java](https://www.baeldung.com/java-regex-performance)
|
||||
- [A Guide To Java Regular Expressions API](http://www.baeldung.com/regular-expressions-java)
|
||||
- [Guide to Escaping Characters in Java RegExps](http://www.baeldung.com/java-regexp-escape-char)
|
||||
40
core-java-modules/core-java-regex/pom.xml
Normal file
40
core-java-modules/core-java-regex/pom.xml
Normal file
@@ -0,0 +1,40 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<artifactId>core-java-regex</artifactId>
|
||||
<version>0.1.0-SNAPSHOT</version>
|
||||
<name>core-java-regex</name>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<parent>
|
||||
<groupId>com.baeldung</groupId>
|
||||
<artifactId>parent-java</artifactId>
|
||||
<version>0.0.1-SNAPSHOT</version>
|
||||
<relativePath>../../parent-java</relativePath>
|
||||
</parent>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.openjdk.jmh</groupId>
|
||||
<artifactId>jmh-core</artifactId>
|
||||
<version>${jmh-core.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.openjdk.jmh</groupId>
|
||||
<artifactId>jmh-generator-annprocess</artifactId>
|
||||
<version>${jmh-core.version}</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
<finalName>core-java-regex</finalName>
|
||||
<resources>
|
||||
<resource>
|
||||
<directory>src/main/resources</directory>
|
||||
<filtering>true</filtering>
|
||||
</resource>
|
||||
</resources>
|
||||
</build>
|
||||
|
||||
</project>
|
||||
@@ -0,0 +1,92 @@
|
||||
package com.baeldung.patternreuse;
|
||||
|
||||
import org.openjdk.jmh.annotations.*;
|
||||
import org.openjdk.jmh.infra.Blackhole;
|
||||
import org.openjdk.jmh.runner.RunnerException;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
@BenchmarkMode(Mode.AverageTime)
|
||||
@OutputTimeUnit(TimeUnit.MILLISECONDS)
|
||||
@Fork(value = 1, warmups = 1)
|
||||
@Warmup(iterations = 5)
|
||||
@State(Scope.Benchmark)
|
||||
public class PatternPerformanceComparison {
|
||||
|
||||
private static final String PATTERN = "\\d*[02468]";
|
||||
private static List<String> values;
|
||||
|
||||
private static Matcher matcherFromPreCompiledPattern;
|
||||
private static Pattern preCompiledPattern;
|
||||
|
||||
public static void main(String[] args) throws IOException, RunnerException {
|
||||
org.openjdk.jmh.Main.main(args);
|
||||
}
|
||||
|
||||
@Benchmark
|
||||
public void matcherFromPreCompiledPatternResetMatches(Blackhole bh) {
|
||||
//With pre-compiled pattern and reusing the matcher
|
||||
// 1 Pattern object created
|
||||
// 1 Matcher objects created
|
||||
for (String value : values) {
|
||||
bh.consume(matcherFromPreCompiledPattern.reset(value).matches());
|
||||
}
|
||||
}
|
||||
|
||||
@Benchmark
|
||||
public void preCompiledPatternMatcherMatches(Blackhole bh) {
|
||||
// With pre-compiled pattern
|
||||
// 1 Pattern object created
|
||||
// 5_000_000 Matcher objects created
|
||||
for (String value : values) {
|
||||
bh.consume(preCompiledPattern.matcher(value).matches());
|
||||
}
|
||||
}
|
||||
|
||||
@Benchmark
|
||||
public void patternCompileMatcherMatches(Blackhole bh) {
|
||||
// Above approach "Pattern.matches(PATTERN, value)" makes this internally
|
||||
// 5_000_000 Pattern objects created
|
||||
// 5_000_000 Matcher objects created
|
||||
for (String value : values) {
|
||||
bh.consume(Pattern.compile(PATTERN).matcher(value).matches());
|
||||
}
|
||||
}
|
||||
|
||||
@Benchmark
|
||||
public void patternMatches(Blackhole bh) {
|
||||
// Above approach "value.matches(PATTERN)" makes this internally
|
||||
// 5_000_000 Pattern objects created
|
||||
// 5_000_000 Matcher objects created
|
||||
for (String value : values) {
|
||||
bh.consume(Pattern.matches(PATTERN, value));
|
||||
}
|
||||
}
|
||||
|
||||
@Benchmark
|
||||
public void stringMatchs(Blackhole bh) {
|
||||
// 5_000_000 Pattern objects created
|
||||
// 5_000_000 Matcher objects created
|
||||
Instant start = Instant.now();
|
||||
for (String value : values) {
|
||||
bh.consume(value.matches(PATTERN));
|
||||
}
|
||||
}
|
||||
|
||||
@Setup()
|
||||
public void setUp() {
|
||||
preCompiledPattern = Pattern.compile(PATTERN);
|
||||
matcherFromPreCompiledPattern = preCompiledPattern.matcher("");
|
||||
|
||||
values = new ArrayList<>();
|
||||
for (int x = 1; x <= 5_000_000; x++) {
|
||||
values.add(String.valueOf(x));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<configuration>
|
||||
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
|
||||
<encoder>
|
||||
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
|
||||
</pattern>
|
||||
</encoder>
|
||||
</appender>
|
||||
|
||||
<root level="INFO">
|
||||
<appender-ref ref="STDOUT" />
|
||||
</root>
|
||||
</configuration>
|
||||
@@ -0,0 +1,63 @@
|
||||
package com.baeldung.patternreuse;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class PatternUnitTest {
|
||||
|
||||
private static final Pattern FIRST_LAST_NAME_PRE_COMPILED_PATTERN = Pattern.compile("[a-zA-Z]{3,} [a-zA-Z]{3,}");
|
||||
private static final Pattern SPLIT_PRE_COMPILED_PATTERN = Pattern.compile("__");
|
||||
|
||||
@Test
|
||||
public void givenPreCompiledPattern_whenCallMatcher_thenReturnAMatcherToMatches() {
|
||||
Matcher matcherName1 = FIRST_LAST_NAME_PRE_COMPILED_PATTERN.matcher("Fabio Silva");
|
||||
Matcher matcherName2 = FIRST_LAST_NAME_PRE_COMPILED_PATTERN.matcher("Mr. Silva");
|
||||
|
||||
boolean matchesName1 = matcherName1.matches();
|
||||
boolean matchesName2 = matcherName2.matches();
|
||||
|
||||
assertTrue(matchesName1);
|
||||
assertFalse(matchesName2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenPreCompiledPattern_whenCallAsPredicate_thenReturnPredicateToFindPatternInTheList() {
|
||||
List<String> namesToValidate = Arrays.asList("Fabio Silva", "Mr. Silva");
|
||||
Predicate<String> patternsAsPredicate = FIRST_LAST_NAME_PRE_COMPILED_PATTERN.asPredicate();
|
||||
|
||||
List<String> validNames = namesToValidate.stream()
|
||||
.filter(patternsAsPredicate)
|
||||
.collect(Collectors.toList());
|
||||
|
||||
assertEquals(1, validNames.size());
|
||||
assertTrue(validNames.contains("Fabio Silva"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenPreCompiledPattern_whenCallSplit_thenReturnArrayWithValuesSplitByThePattern() {
|
||||
String[] textSplit = SPLIT_PRE_COMPILED_PATTERN.split("My_Name__is__Fabio_Silva");
|
||||
|
||||
assertEquals("My_Name", textSplit[0]);
|
||||
assertEquals("is", textSplit[1]);
|
||||
assertEquals("Fabio_Silva", textSplit[2]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenPreCompiledPattern_whenCallSplitAsStream_thenReturnArraySplitByThePattern() {
|
||||
Stream<String> textSplitAsStream = SPLIT_PRE_COMPILED_PATTERN.splitAsStream("My_Name__is__Fabio_Silva");
|
||||
String[] textSplit = textSplitAsStream.toArray(String[]::new);
|
||||
|
||||
assertEquals("My_Name", textSplit[0]);
|
||||
assertEquals("is", textSplit[1]);
|
||||
assertEquals("Fabio_Silva", textSplit[2]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,501 @@
|
||||
package com.baeldung.regex;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
public class RegexUnitTest {
|
||||
private static Pattern pattern;
|
||||
private static Matcher matcher;
|
||||
|
||||
@Test
|
||||
public void givenText_whenSimpleRegexMatches_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("foo");
|
||||
Matcher matcher = pattern.matcher("foo");
|
||||
assertTrue(matcher.find());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenText_whenSimpleRegexMatchesTwice_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("foo");
|
||||
Matcher matcher = pattern.matcher("foofoo");
|
||||
int matches = 0;
|
||||
while (matcher.find())
|
||||
matches++;
|
||||
assertEquals(matches, 2);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenText_whenMatchesWithDotMetach_thenCorrect() {
|
||||
int matches = runTest(".", "foo");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRepeatedText_whenMatchesOnceWithDotMetach_thenCorrect() {
|
||||
int matches = runTest("foo.", "foofoo");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenORSet_whenMatchesAny_thenCorrect() {
|
||||
int matches = runTest("[abc]", "b");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenORSet_whenMatchesAnyAndAll_thenCorrect() {
|
||||
int matches = runTest("[abc]", "cab");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenORSet_whenMatchesAllCombinations_thenCorrect() {
|
||||
int matches = runTest("[bcr]at", "bat cat rat");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNORSet_whenMatchesNon_thenCorrect() {
|
||||
int matches = runTest("[^abc]", "g");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNORSet_whenMatchesAllExceptElements_thenCorrect() {
|
||||
int matches = runTest("[^bcr]at", "sat mat eat");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUpperCaseRange_whenMatchesUpperCase_thenCorrect() {
|
||||
int matches = runTest("[A-Z]", "Two Uppercase alphabets 34 overall");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenLowerCaseRange_whenMatchesLowerCase_thenCorrect() {
|
||||
int matches = runTest("[a-z]", "Two Uppercase alphabets 34 overall");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 26);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenBothLowerAndUpperCaseRange_whenMatchesAllLetters_thenCorrect() {
|
||||
int matches = runTest("[a-zA-Z]", "Two Uppercase alphabets 34 overall");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 28);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNumberRange_whenMatchesAccurately_thenCorrect() {
|
||||
int matches = runTest("[1-5]", "Two Uppercase alphabets 34 overall");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNumberRange_whenMatchesAccurately_thenCorrect2() {
|
||||
int matches = runTest("[30-35]", "Two Uppercase alphabets 34 overall");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTwoSets_whenMatchesUnion_thenCorrect() {
|
||||
int matches = runTest("[1-3[7-9]]", "123456789");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 6);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTwoSets_whenMatchesIntersection_thenCorrect() {
|
||||
int matches = runTest("[1-6&&[3-9]]", "123456789");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 4);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSetWithSubtraction_whenMatchesAccurately_thenCorrect() {
|
||||
int matches = runTest("[0-9&&[^2468]]", "123456789");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 5);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenDigits_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\d", "123");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNonDigits_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\D", "a6c");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenWhiteSpace_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\s", "a c");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNonWhiteSpace_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\S", "a c");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenWordCharacter_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\w", "hi!");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNonWordCharacter_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\W", "hi!");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenZeroOrOneQuantifier_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\a?", "hi");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenZeroOrOneQuantifier_whenMatches_thenCorrect2() {
|
||||
int matches = runTest("\\a{0,1}", "hi");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenZeroOrManyQuantifier_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\a*", "hi");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenZeroOrManyQuantifier_whenMatches_thenCorrect2() {
|
||||
int matches = runTest("\\a{0,}", "hi");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenOneOrManyQuantifier_whenMatches_thenCorrect() {
|
||||
int matches = runTest("\\a+", "hi");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenOneOrManyQuantifier_whenMatches_thenCorrect2() {
|
||||
int matches = runTest("\\a{1,}", "hi");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenBraceQuantifier_whenMatches_thenCorrect() {
|
||||
int matches = runTest("a{3}", "aaaaaa");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenBraceQuantifier_whenFailsToMatch_thenCorrect() {
|
||||
int matches = runTest("a{3}", "aa");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenBraceQuantifierWithRange_whenMatches_thenCorrect() {
|
||||
int matches = runTest("a{2,3}", "aaaa");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenBraceQuantifierWithRange_whenMatchesLazily_thenCorrect() {
|
||||
int matches = runTest("a{2,3}?", "aaaa");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCapturingGroup_whenMatches_thenCorrect() {
|
||||
int matches = runTest("(\\d\\d)", "12");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCapturingGroup_whenMatches_thenCorrect2() {
|
||||
int matches = runTest("(\\d\\d)", "1212");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCapturingGroup_whenMatches_thenCorrect3() {
|
||||
int matches = runTest("(\\d\\d)(\\d\\d)", "1212");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCapturingGroup_whenMatchesWithBackReference_thenCorrect() {
|
||||
int matches = runTest("(\\d\\d)\\1", "1212");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCapturingGroup_whenMatchesWithBackReference_thenCorrect2() {
|
||||
int matches = runTest("(\\d\\d)\\1\\1\\1", "12121212");
|
||||
assertTrue(matches > 0);
|
||||
assertEquals(matches, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCapturingGroupAndWrongInput_whenMatchFailsWithBackReference_thenCorrect() {
|
||||
int matches = runTest("(\\d\\d)\\1", "1213");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenText_whenMatchesAtBeginning_thenCorrect() {
|
||||
int matches = runTest("^dog", "dogs are friendly");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTextAndWrongInput_whenMatchFailsAtBeginning_thenCorrect() {
|
||||
int matches = runTest("^dog", "are dogs are friendly?");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenText_whenMatchesAtEnd_thenCorrect() {
|
||||
int matches = runTest("dog$", "Man's best friend is a dog");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTextAndWrongInput_whenMatchFailsAtEnd_thenCorrect() {
|
||||
int matches = runTest("dog$", "is a dog man's best friend?");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenText_whenMatchesAtWordBoundary_thenCorrect() {
|
||||
int matches = runTest("\\bdog\\b", "a dog is friendly");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenText_whenMatchesAtWordBoundary_thenCorrect2() {
|
||||
int matches = runTest("\\bdog\\b", "dog is man's best friend");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenWrongText_whenMatchFailsAtWordBoundary_thenCorrect() {
|
||||
int matches = runTest("\\bdog\\b", "snoop dogg is a rapper");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenText_whenMatchesAtWordAndNonBoundary_thenCorrect() {
|
||||
int matches = runTest("\\bdog\\B", "snoop dogg is a rapper");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithoutCanonEq_whenMatchFailsOnEquivalentUnicode_thenCorrect() {
|
||||
int matches = runTest("\u00E9", "\u0065\u0301");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithCanonEq_whenMatchesOnEquivalentUnicode_thenCorrect() {
|
||||
int matches = runTest("\u00E9", "\u0065\u0301", Pattern.CANON_EQ);
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithDefaultMatcher_whenMatchFailsOnDifferentCases_thenCorrect() {
|
||||
int matches = runTest("dog", "This is a Dog");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() {
|
||||
int matches = runTest("dog", "This is a Dog", Pattern.CASE_INSENSITIVE);
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithEmbeddedCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() {
|
||||
int matches = runTest("(?i)dog", "This is a Dog");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithComments_whenMatchFailsWithoutFlag_thenCorrect() {
|
||||
int matches = runTest("dog$ #check for word dog at end of text", "This is a dog");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithComments_whenMatchesWithFlag_thenCorrect() {
|
||||
int matches = runTest("dog$ #check for word dog at end of text", "This is a dog", Pattern.COMMENTS);
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithComments_whenMatchesWithEmbeddedFlag_thenCorrect() {
|
||||
int matches = runTest("(?x)dog$ #check for word dog at end of text", "This is a dog");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithLineTerminator_whenMatchFails_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("(.*)");
|
||||
Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line");
|
||||
matcher.find();
|
||||
assertEquals("this is a text", matcher.group(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithLineTerminator_whenMatchesWithDotall_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("(.*)", Pattern.DOTALL);
|
||||
Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line");
|
||||
matcher.find();
|
||||
assertEquals("this is a text" + System.getProperty("line.separator") + " continued on another line", matcher.group(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithLineTerminator_whenMatchesWithEmbeddedDotall_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("(?s)(.*)");
|
||||
Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line");
|
||||
matcher.find();
|
||||
assertEquals("this is a text" + System.getProperty("line.separator") + " continued on another line", matcher.group(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegex_whenMatchesWithoutLiteralFlag_thenCorrect() {
|
||||
int matches = runTest("(.*)", "text");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegex_whenMatchFailsWithLiteralFlag_thenCorrect() {
|
||||
int matches = runTest("(.*)", "text", Pattern.LITERAL);
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegex_whenMatchesWithLiteralFlag_thenCorrect() {
|
||||
int matches = runTest("(.*)", "text(.*)", Pattern.LITERAL);
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegex_whenMatchFailsWithoutMultilineFlag_thenCorrect() {
|
||||
int matches = runTest("dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox");
|
||||
assertFalse(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegex_whenMatchesWithMultilineFlag_thenCorrect() {
|
||||
int matches = runTest("dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox", Pattern.MULTILINE);
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegex_whenMatchesWithEmbeddedMultilineFlag_thenCorrect() {
|
||||
int matches = runTest("(?m)dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox");
|
||||
assertTrue(matches > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMatch_whenGetsIndices_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("dog");
|
||||
Matcher matcher = pattern.matcher("This dog is mine");
|
||||
matcher.find();
|
||||
assertEquals(5, matcher.start());
|
||||
assertEquals(8, matcher.end());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenStudyMethodsWork_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("dog");
|
||||
Matcher matcher = pattern.matcher("dogs are friendly");
|
||||
assertTrue(matcher.lookingAt());
|
||||
assertFalse(matcher.matches());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenMatchesStudyMethodWorks_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("dog");
|
||||
Matcher matcher = pattern.matcher("dog");
|
||||
assertTrue(matcher.matches());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenReplaceFirstWorks_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("dog");
|
||||
Matcher matcher = pattern.matcher("dogs are domestic animals, dogs are friendly");
|
||||
String newStr = matcher.replaceFirst("cat");
|
||||
assertEquals("cats are domestic animals, dogs are friendly", newStr);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenReplaceAllWorks_thenCorrect() {
|
||||
Pattern pattern = Pattern.compile("dog");
|
||||
Matcher matcher = pattern.matcher("dogs are domestic animals, dogs are friendly");
|
||||
String newStr = matcher.replaceAll("cat");
|
||||
assertEquals("cats are domestic animals, cats are friendly", newStr);
|
||||
|
||||
}
|
||||
|
||||
public synchronized static int runTest(String regex, String text) {
|
||||
pattern = Pattern.compile(regex);
|
||||
matcher = pattern.matcher(text);
|
||||
int matches = 0;
|
||||
while (matcher.find())
|
||||
matches++;
|
||||
return matches;
|
||||
}
|
||||
|
||||
public synchronized static int runTest(String regex, String text, int flags) {
|
||||
pattern = Pattern.compile(regex, flags);
|
||||
matcher = pattern.matcher(text);
|
||||
int matches = 0;
|
||||
while (matcher.find())
|
||||
matches++;
|
||||
return matches;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package com.baeldung.regex.matcher;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class MatcherUnitTest {
|
||||
|
||||
@Test
|
||||
public void whenFindFourDigitWorks_thenCorrect() {
|
||||
Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d");
|
||||
Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020");
|
||||
|
||||
assertTrue(m.find());
|
||||
assertEquals(8, m.start());
|
||||
assertEquals("2019", m.group());
|
||||
assertEquals(12, m.end());
|
||||
|
||||
assertTrue(m.find());
|
||||
assertEquals(25, m.start());
|
||||
assertEquals("2020", m.group());
|
||||
assertEquals(29, m.end());
|
||||
|
||||
assertFalse(m.find());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenStartIndex_whenFindFourDigitWorks_thenCorrect() {
|
||||
Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d");
|
||||
Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020");
|
||||
|
||||
assertTrue(m.find(20));
|
||||
assertEquals(25, m.start());
|
||||
assertEquals("2020", m.group());
|
||||
assertEquals(29, m.end());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenMatchFourDigitWorks_thenFail() {
|
||||
Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d");
|
||||
Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020");
|
||||
assertFalse(m.matches());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenMatchFourDigitWorks_thenCorrect() {
|
||||
Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d");
|
||||
Matcher m = stringPattern.matcher("2019");
|
||||
|
||||
assertTrue(m.matches());
|
||||
assertEquals(0, m.start());
|
||||
assertEquals("2019", m.group());
|
||||
assertEquals(4, m.end());
|
||||
|
||||
assertTrue(m.matches());// matches will always return the same return
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
package com.baeldung.regexp;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static org.hamcrest.CoreMatchers.equalTo;
|
||||
import static org.hamcrest.CoreMatchers.not;
|
||||
import static org.junit.Assert.assertThat;
|
||||
|
||||
public class EscapingCharsUnitTest {
|
||||
@Test
|
||||
public void givenRegexWithDot_whenMatchingStr_thenMatches() {
|
||||
String strInput = "foof";
|
||||
String strRegex = "foo.";
|
||||
|
||||
assertEquals(true, strInput.matches(strRegex));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithDotEsc_whenMatchingStr_thenNotMatching() {
|
||||
String strInput = "foof";
|
||||
String strRegex = "foo\\.";
|
||||
|
||||
assertEquals(false, strInput.matches(strRegex));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithPipeEscaped_whenSplitStr_thenSplits() {
|
||||
String strInput = "foo|bar|hello|world";
|
||||
String strRegex = "\\Q|\\E";
|
||||
|
||||
assertEquals(4, strInput.split(strRegex).length);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithPipeEscQuoteMeth_whenSplitStr_thenSplits() {
|
||||
String strInput = "foo|bar|hello|world";
|
||||
String strRegex = "|";
|
||||
|
||||
assertEquals(4, strInput.split(Pattern.quote(strRegex)).length);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithDollar_whenReplacing_thenNotReplace() {
|
||||
String strInput = "I gave $50 to my brother."
|
||||
+ "He bought candy for $35. Now he has $15 left.";
|
||||
String strRegex = "$";
|
||||
String strReplacement = "£";
|
||||
String output = "I gave £50 to my brother."
|
||||
+ "He bought candy for £35. Now he has £15 left.";
|
||||
Pattern p = Pattern.compile(strRegex);
|
||||
Matcher m = p.matcher(strInput);
|
||||
|
||||
assertThat(output, not(equalTo(m.replaceAll(strReplacement))));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRegexWithDollarEsc_whenReplacing_thenReplace() {
|
||||
String strInput = "I gave $50 to my brother."
|
||||
+ "He bought candy for $35. Now he has $15 left.";
|
||||
String strRegex = "\\$";
|
||||
String strReplacement = "£";
|
||||
String output = "I gave £50 to my brother."
|
||||
+ "He bought candy for £35. Now he has £15 left.";
|
||||
Pattern p = Pattern.compile(strRegex);
|
||||
Matcher m = p.matcher(strInput);
|
||||
|
||||
assertEquals(output, m.replaceAll(strReplacement));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
package com.baeldung.regexp.optmization;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
public class OptimizedMatcherManualTest {
|
||||
|
||||
private String action;
|
||||
|
||||
private List<String> items;
|
||||
|
||||
private class TimeWrapper {
|
||||
private long time;
|
||||
private long mstimePreCompiled;
|
||||
private long mstimeNotPreCompiled;
|
||||
}
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
Random random = new Random();
|
||||
items = new ArrayList<String>();
|
||||
long average = 0;
|
||||
|
||||
for (int i = 0; i < 100000; ++i) {
|
||||
StringBuilder s = new StringBuilder();
|
||||
int characters = random.nextInt(7) + 1;
|
||||
for (int k = 0; k < characters; ++ k) {
|
||||
char c = (char)(random.nextInt('Z' - 'A') + 'A');
|
||||
int rep = random.nextInt(95) + 5;
|
||||
for (int j = 0; j < rep; ++ j)
|
||||
s.append(c);
|
||||
average += rep;
|
||||
}
|
||||
items.add(s.toString());
|
||||
}
|
||||
|
||||
average /= 100000;
|
||||
System.out.println("generated data, average length: " + average);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void givenANotPreCompiledAndAPreCompiledPatternA_whenMatcheItems_thenPreCompiledFasterThanNotPreCompiled() {
|
||||
TimeWrapper timeObj = new TimeWrapper();
|
||||
testPatterns("A*", timeObj);
|
||||
assertTrue(timeObj.mstimePreCompiled < timeObj.mstimeNotPreCompiled);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenANotPreCompiledAndAPreCompiledPatternABC_whenMatcheItems_thenPreCompiledFasterThanNotPreCompiled() {
|
||||
TimeWrapper timeObj = new TimeWrapper();
|
||||
testPatterns("A*B*C*", timeObj);
|
||||
assertTrue(timeObj.mstimePreCompiled < timeObj.mstimeNotPreCompiled);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenANotPreCompiledAndAPreCompiledPatternECWF_whenMatcheItems_thenPreCompiledFasterThanNotPreCompiled() {
|
||||
TimeWrapper timeObj = new TimeWrapper();
|
||||
testPatterns("E*C*W*F*", timeObj);
|
||||
assertTrue(timeObj.mstimePreCompiled < timeObj.mstimeNotPreCompiled);
|
||||
}
|
||||
|
||||
private void testPatterns(String regex, TimeWrapper timeObj) {
|
||||
timeObj.time = System.nanoTime();
|
||||
int matched = 0;
|
||||
int unmatched = 0;
|
||||
|
||||
for (String item : this.items) {
|
||||
if (item.matches(regex)) {
|
||||
++matched;
|
||||
}
|
||||
else {
|
||||
++unmatched;
|
||||
}
|
||||
}
|
||||
|
||||
this.action = "uncompiled: regex=" + regex + " matched=" + matched + " unmatched=" + unmatched;
|
||||
|
||||
timeObj.mstimeNotPreCompiled = (System.nanoTime() - timeObj.time) / 1000000;
|
||||
System.out.println(this.action + ": " + timeObj.mstimeNotPreCompiled + "ms");
|
||||
|
||||
timeObj.time = System.nanoTime();
|
||||
|
||||
Matcher matcher = Pattern.compile(regex).matcher("");
|
||||
matched = 0;
|
||||
unmatched = 0;
|
||||
|
||||
for (String item : this.items) {
|
||||
if (matcher.reset(item).matches()) {
|
||||
++matched;
|
||||
}
|
||||
else {
|
||||
++unmatched;
|
||||
}
|
||||
}
|
||||
|
||||
this.action = "compiled: regex=" + regex + " matched=" + matched + " unmatched=" + unmatched;
|
||||
|
||||
timeObj.mstimePreCompiled = (System.nanoTime() - timeObj.time) / 1000000;
|
||||
System.out.println(this.action + ": " + timeObj.mstimePreCompiled + "ms");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user