Java Regular Expressions
(java regex!:) Tutorial with examples Part 2
  Java Regular Expressions
Now we are familiar with Pattern and Matcher 
class and the process of matching a regular 
expression against the text. Lets see what 
kind of various options we have to define a 
regular expression:

 #1 String Literals
Lets say you just want to search a particular 
String in the text for e.g. "abc" then we can 
simply write the code like this: Here text and 
regex both are same.

Pattern.matches("abc", "abc")

 #2 Character Classes
A character class matches a single character
in the input text against multiple allowed 
characters in the character class. For example 
[Ss]ololearn would match all the occurrences of 
String "sololearn" with either lower case or 
upper case "S". Few more examples:

Pattern.matches("[pqr]", "abcd"); // It would give false as no p,q or r in the text.
Pattern.matches("[pqr]", "r"); // Return true as r is found.
Pattern.matches("[pqr]", "pq"); // Return false as any one of them can be in text not both.
Here is the complete list of various character 
classes constructs:

[abc] // It would match with text if the text is having either one of them (a,b or c) and only once.
[^abc] // Any single character except a, b, or c (^ denote negation)
[a-zA-Z] // a through z, or A through Z, inclusive (range)
[a-d[m-p]] // a through d, or m through p: [a-dm-p] (union)
[a-z&&[def]] // Any one of them (d, e, or f)
[a-z&&[^bc]] // a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]] // a through z, and not m through p: [a-lq-z] (subtraction)
Predefined Character Classes – 
Metacharacters
These are like short codes which you can use 
while writing regex.

 Construct   Description

 . ->      Any character (may or may not match line terminators)

 \d ->     A digit: [0-9]
 
 \D ->     A non-digit: [^0-9]
 
 \s ->     A whitespace character: [ \t\n\x0B\f\r]
 
 \S ->     A non-whitespace character: [^\s]
 
 \w ->     A word character: [a-zA-Z_0-9]
 
 \W ->     A non-word character: [^\w]

For e.g.
Pattern.matches("\\d", "1"); // would return true
Pattern.matches("\\D", "z"); // return true
Pattern.matches(".p", "qp"); // return true, dot(.) represent any character
Boundary Matchers
 ^      Matches the beginning of a line.
 $      Matches then end of a line.
 \b     Matches a word boundary.
 \B     Matches a non-word boundary.
 \A     Matches the beginning of the input text.
 \G     Matches the end of the previous match
 \Z     Matches the end of the input text except the final terminator if any.
 \z     Matches the end of the input text.

For e.g.
Pattern.matches("^Hello$", "Hello"); // return true, Begins and ends with Hello
Pattern.matches("^Hello$", "Namaste! Hello") // return false, does not begin with Hello 
Pattern.matches("^Hello$", "Hello Namaste!") // return false, Does not end with Hello
Quantifiers
 Greedy    Reluctant    Possessive    Matches
 X?        X??          X?+           Matches X once, or not at all (0 or 1 time).
 X*        X*?          X*+           Matches X zero or more times.
 X+        X+?          X++           Matches X one or more times.
 X{n}      X{n}?        X{n}+         Matches X exactly n times.
 X{n,}     X{n,}?       X{n,}+        Matches X at least n times.
 X{n, m)   X{n, m)?     X{n, m)+      Matches X at least n time, but at most m times.

For examples:
import java.util.regex.*;

class RegexExample {
    public static void main(String[] args) {
    
        // It would return true if String matches exactly "solo"
        System.out.println(
            Pattern.matches("solo", "Solo")); // false
        /*
        * Returns true if the String matches exactly
        * "solo" or "Solo"
        */
        System.out.println(
            Pattern.matches("[Ss]olo", "Solo")); // true
        System.out.println(
            Pattern.matches("[Ss]olo", "Solo")); // true
        
        /*
        * Returns true if the String matches exactly "java"
        * or "Java" or "reg" or "Reg"
        */
        System.out.println(
            Pattern.matches("[jJ]ava|[rR]eg", "Java")); // true
        System.out.println(
            Pattern.matches("[jJ]avs|[rR]eg", "reg")); // true
        
        /*
        * Returns true if the String contains "star" at
        * any place
        */
        System.out.println(
            Pattern.matches(".*star.*", "javastarregex")); // true
        
        /*
        * Returns true if the String does not have a
        * number at the beginning
        */
        System.out.println(
            Pattern.matches("^[^\\d].*", "16June2018")); // false
        System.out.println(
            Pattern.matches("^[^\\d].*", "June162018")); // true
        
        // Returns true if the String contains of three letters
        System.out.println(
            Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "jSr")); // true
        System.out.println(
            Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "sJR")); // true
        System.out.println(
            Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "play")); // false
        
        // Returns true if the String contains 0 or more non-digits
        System.out.println(
            Pattern.matches("\\D*", "javareg")); // true
        System.out.println(
            Pattern.matches("\\D*", "star1606")); // false
        
        /*
        * Boundary Matchers example
        * ^ denotes start of the line
        * $ denotes end of the line
        */
        System.out.println(
            Pattern.matches("^This$", "This is SoloLearn")); // false
        System.out.println(
            Pattern.matches("^This$", "This")); // true
        System.out.println(
            Pattern.matches("^This$", "Is This SoloLearn")); // false
    }
}

 Regular Expression Question 1
/**
 * Create a regular expression that accepts
 * alpha numeric characters only.
 * Its length must be 6 characters long only.
  */
import java.util.regex.*;

class RegexQuestion1 {
    public static void main(String[] args) {
        // HappyCodings!:)
    }
}

// Solution_Question1

 Regular Expression Question 2
/**
 * Create a regular expression that
 * accepts 10 digit numeric characters
 * starting with 7, 8 or 9 only.
  */
import java.util.regex.*;

class RegexQuestion2 {
    public static void main(String[] args) {
        // HappyCodings!:)
    }
}

// Solution_Question2

Java_Regex_Finder_Example



    HappyLearning!:) Regex_cheat_sheet

         
(java regex!:)_Tutorial_with_examples_Part_1