Java Regular Expressions

Java Regular Expressions, also known as Java Regex or Java Pattern, is a powerful tool that allows you to search for, manipulate, and validate strings based on a pattern. Regular expressions are a sequence of characters that define a search pattern. Java has built-in support for regular expressions through the java.util.regex package.

Here are some basic concepts to understand when working with Java regex:

1. Character classes: These are sets of characters that match a single character in the text. For example, the character class [abc] matches any one of the characters a, b, or c.

2. Quantifiers: These specify how many times a pattern should match. For example, the quantifier * means "zero or more times", and the quantifier + means "one or more times".

3. Anchors: These specify where a pattern should match in the text. For example, the anchor ^ matches the beginning of the text, and the anchor $ matches the end of the text.

4. Grouping: This allows you to group patterns together and apply quantifiers to them. For example, the pattern (ab)+ matches one or more occurrences of the characters "ab".

Here are some common regular expression patterns and their meanings:

1. . : Matches any character except newline.

2. * : Matches zero or more occurrences of the preceding character. For example, a* matches zero or more occurrences of the letter 'a'.

3. + : Matches one or more occurrences of the preceding character. For example, a+ matches one or more occurrences of the letter 'a'.

4. ? : Matches zero or one occurrence of the preceding character. For example, a? matches zero or one occurrence of the letter 'a'.

5. [] : Matches any character in the brackets. For example, [abc] matches any one of the characters 'a', 'b', or 'c'.

6. [a-z] : Matches any character from 'a' to 'z'.

7. [^] : Matches any character not in the brackets. For example, [^abc] matches any character except 'a', 'b', or 'c'.

8. \d : Matches any digit (0-9).

9. \w : Matches any word character (a-z, A-Z, 0-9, _).

10. \s : Matches any whitespace character (space, tab, newline).

11. ^ : Matches the start of the line.

12. $ : Matches the end of the line.

13. | : Matches either the expression before or after the pipe. For example, a|b matches either the letter 'a' or 'b'.

14. () : Groups expressions together. For example, (abc)+ matches one or more occurrences of the sequence 'abc'.

15. \\ : Escapes a special character. For example, to match a literal dot character, you need to escape it like this: \\..

import java.util.regex.*;

public class RegexExample {
    public static void main(String[] args) {
        String input = "The quick brown fox jumps over the lazy dog";
        Pattern pattern = Pattern.compile("\\b\\w{5}\\b");
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}

Regular expression generally used to manipulate text string such as finding and replacing text of given string etc. That is very useful mechanism which can search and replace particular text pattern in long text string.

//For Pattern and Matcher
import java.util.regex.*; 

public class Test {

  public static void main(String args[]) 
  { 
    //Create object to search Pattern
    Pattern pattern = Pattern.compile("Code"); 

    Matcher match = pattern.matcher("Java Code VS Python Code"); 
    
    //Display pattern location
    while(match.find()){
      System.out.println("Pattern Exist from " + 
        match.start() + " to " + (match.end()-1)); //View position
    } 
  } 
}

Pattern Exist from 5 to 8
Pattern Exist from 20 to 23

java.util.regex.Pattern Public Method

java.util.regex.Matcher public method

java.util.regex.PatternSyntaxException public method