Java Regex: Your First Guide to Pattern Matching
Here’s the thing about regex in Java - it looks scary at first, but once you get the hang of a few basic operators, you’ll be amazed at how powerful it becomes. Trust me, six months from now you’ll be using regex to solve problems you didn’t even know you had.
Don’t worry about memorizing everything right away. The goal here is to understand what each operator does and see it in action. You’ll pick up the muscle memory with practice.
Why Regex Matters for Your Career
Before we dive into the operators, let me tell you why this stuff is huge for career advancement. Every company deals with data validation, log parsing, and text processing. When you can write a single line of regex that replaces twenty lines of string manipulation code, people notice. It’s one of those skills that separates beginners from developers who get things done.
The Basic Operators You Need to Know
Let’s start with the core operators. I’ll show you each one, then we’ll build up to real examples.
The Dot (.) - Any Character
The dot matches any single character except newline. Think of it as a wildcard.
1import java.util.regex.Pattern;
2import java.util.regex.Matcher;
3
4public class RegexBasics {
5 public static void main(String[] args) {
6 String pattern = "c.t";
7 String[] testStrings = {"cat", "cot", "cut", "cart", "ct"};
8
9 Pattern p = Pattern.compile(pattern);
10
11 for (String test : testStrings) {
12 Matcher m = p.matcher(test);
13 System.out.println(test + " matches c.t: " + m.matches());
14 }
15 }
16}Output:
cat matches c.t: true // c + a + t
cot matches c.t: true // c + o + t
cut matches c.t: true // c + u + t
cart matches c.t: false // too long
ct matches c.t: false // missing middle characterThe Plus (+) - One or More
The plus means “one or more of the preceding character.” This is where regex starts getting useful for real problems.
1public class PlusOperator {
2 public static void main(String[] args) {
3 // Match one or more digits
4 String pattern = "\\d+"; // \\d means digit, + means one or more
5 String[] testStrings = {"123", "7", "abc", "12abc", "a7b"};
6
7 Pattern p = Pattern.compile(pattern);
8
9 for (String test : testStrings) {
10 Matcher m = p.matcher(test);
11 if (m.find()) {
12 System.out.println("Found digits in '" + test + "': " + m.group());
13 } else {
14 System.out.println("No digits found in '" + test + "'");
15 }
16 }
17 }
18}Output:
Found digits in '123': 123
Found digits in '7': 7
No digits found in 'abc'
Found digits in '12abc': 12
Found digits in 'a7b': 7The Asterisk (*) - Zero or More
The asterisk is like the plus, but it also matches zero occurrences. Super useful for optional parts of patterns.
1public class StarOperator {
2 public static void main(String[] args) {
3 // Match "color" or "colour" (u is optional)
4 String pattern = "colou*r";
5 String[] testStrings = {"color", "colour", "colouur", "colored", "colour"};
6
7 Pattern p = Pattern.compile(pattern);
8
9 for (String test : testStrings) {
10 Matcher m = p.matcher(test);
11 if (m.find()) {
12 System.out.println("'" + test + "' contains: " + m.group());
13 } else {
14 System.out.println("'" + test + "' - no match");
15 }
16 }
17 }
18}Square Brackets [] - Character Sets
This is where regex gets really flexible. Square brackets let you specify a set of characters to match.
1public class CharacterSets {
2 public static void main(String[] args) {
3 // Different character set examples
4 String[] patterns = {
5 "[aeiou]", // Any vowel
6 "[a-z]", // Any lowercase letter
7 "[A-Z]", // Any uppercase letter
8 "[0-9]", // Any digit
9 "[a-zA-Z0-9]" // Any letter or digit
10 };
11
12 String testString = "Hello123";
13
14 for (String pattern : patterns) {
15 Pattern p = Pattern.compile(pattern);
16 Matcher m = p.matcher(testString);
17
18 System.out.print(pattern + " finds: ");
19 while (m.find()) {
20 System.out.print(m.group() + " ");
21 }
22 System.out.println();
23 }
24 }
25}Output:
[aeiou] finds: e o
[a-z] finds: e l l o
[A-Z] finds: H
[0-9] finds: 1 2 3
[a-zA-Z0-9] finds: H e l l o 1 2 3 The Caret (^) - Start of String
The caret means “beginning of the string.” Perfect for validation where you need to check if something starts with a specific pattern.
1public class StartAnchor {
2 public static void main(String[] args) {
3 // Check if string starts with "Hello"
4 String pattern = "^Hello";
5 String[] testStrings = {"Hello world", "Say Hello", "Hello", "hello"};
6
7 Pattern p = Pattern.compile(pattern);
8
9 for (String test : testStrings) {
10 Matcher m = p.matcher(test);
11 System.out.println("'" + test + "' starts with Hello: " + m.find());
12 }
13 }
14}The Dollar ($) - End of String
The dollar sign means “end of the string.” Combine it with caret for exact matches.
1public class EndAnchor {
2 public static void main(String[] args) {
3 // Check if string ends with ".com"
4 String pattern = "\\.com$"; // Need to escape the dot
5 String[] testStrings = {"google.com", "example.com.au", "site.com", "com"};
6
7 Pattern p = Pattern.compile(pattern);
8
9 for (String test : testStrings) {
10 Matcher m = p.matcher(test);
11 System.out.println("'" + test + "' ends with .com: " + m.find());
12 }
13 }
14}Specific Character Matches
Sometimes you just want to match exact text. This is the simplest form of regex:
1public class ExactMatches {
2 public static void main(String[] args) {
3 // Look for the word "cat" anywhere in the string
4 String pattern = "cat";
5 String[] testStrings = {"cat", "catch", "scattered", "Cat", "dog"};
6
7 Pattern p = Pattern.compile(pattern);
8
9 for (String test : testStrings) {
10 Matcher m = p.matcher(test);
11 if (m.find()) {
12 System.out.println("'" + test + "' contains 'cat'");
13 } else {
14 System.out.println("'" + test + "' does not contain 'cat'");
15 }
16 }
17 }
18}Escaping Special Characters
Here’s where beginners often get stuck. What if you actually want to search for a literal asterisk or dot? You need to escape them with backslashes.
1public class EscapingCharacters {
2 public static void main(String[] args) {
3 // Search for literal asterisk
4 String pattern1 = "\\*"; // Java string needs double backslash
5 String test1 = "Price: $5.99*";
6
7 Pattern p1 = Pattern.compile(pattern1);
8 Matcher m1 = p1.matcher(test1);
9
10 System.out.println("Found asterisk: " + m1.find());
11
12 // Search for literal dot
13 String pattern2 = "\\.";
14 String test2 = "website.com";
15
16 Pattern p2 = Pattern.compile(pattern2);
17 Matcher m2 = p2.matcher(test2);
18
19 System.out.println("Found dot: " + m2.find());
20
21 // Common characters that need escaping
22 String[] specialChars = {"\\.", "\\*", "\\+", "\\?", "\\^", "\\$", "\\[", "\\]", "\\(", "\\)"};
23 String testString = "Cost: $10.50 (tax not included)*";
24
25 System.out.println("\nSpecial characters found in: " + testString);
26 for (String pattern : specialChars) {
27 Pattern p = Pattern.compile(pattern);
28 Matcher m = p.matcher(testString);
29 if (m.find()) {
30 System.out.println("Found: " + pattern.substring(1)); // Remove the escape backslash for display
31 }
32 }
33 }
34}Real-World Example: Email Validation
Let’s put it all together with something you’ll actually use - basic email validation:
1public class EmailValidator {
2 public static void main(String[] args) {
3 // Simple email pattern: one or more chars, @, one or more chars, dot, 2-4 chars
4 String emailPattern = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}$";
5
6 String[] emails = {
7 "user@example.com",
8 "john.doe@company.org",
9 "invalid-email",
10 "user@.com",
11 "user@example.",
12 "valid.email+tag@domain.co.uk"
13 };
14
15 Pattern p = Pattern.compile(emailPattern);
16
17 System.out.println("Email validation results:");
18 for (String email : emails) {
19 Matcher m = p.matcher(email);
20 System.out.println(email + ": " + (m.matches() ? "VALID" : "INVALID"));
21 }
22 }
23}Let’s break down that email pattern:
^- Start of string[a-zA-Z0-9._%+-]+- One or more letters, digits, or common email characters@- Literal @ symbol[a-zA-Z0-9.-]+- One or more letters, digits, dots, or hyphens for domain\\.- Literal dot (escaped)[a-zA-Z]{2,4}- 2 to 4 letters for top-level domain$- End of string
Common Gotchas and Tips
Here are the mistakes I see beginners make all the time:
Double Backslashes in Java
Java strings use backslash for escaping, so to get one backslash to the regex engine, you need two in your Java string:
1String pattern = "\\d"; // This becomes \d in the regexGreedy vs. Non-Greedy Matching
The * and + operators are greedy - they match as much as possible:
1String text = "<div>content</div>";
2String greedyPattern = "<.*>"; // Matches the entire string
3String nonGreedyPattern = "<.*?>"; // Matches just <div>Case Sensitivity
Regex is case-sensitive by default. Use flags for case-insensitive matching:
1Pattern p = Pattern.compile("hello", Pattern.CASE_INSENSITIVE);What’s Next?
You now know the essential regex operators that’ll handle 80% of your pattern matching needs. The key is to start using them in real projects. Try writing patterns for:
- Phone number validation
- Parsing log files
- Cleaning up user input
- Finding specific patterns in configuration files
Remember, regex is one of those skills that compounds over time. Every pattern you write makes the next one easier. Don’t try to become a regex wizard overnight - just start using these basics, and you’ll naturally pick up more advanced techniques as you need them.
The best part? Once you learn regex in Java, the same patterns work in most other programming languages with minor syntax differences. It’s an investment that pays dividends across your entire career.