JAVA EE: November 2017

How to create a regex that accepts alphanumeric characters and length is 4 | Java Regex

Click here to watch in Youtube :
https://www.youtube.com/watch?v=aGo-W_vIfx0&list=UUhwKlOVR041tngjerWxVccw

RegexDemo.java

import java.util.regex.Pattern;

/**
 *
 * Create a regular expression that accepts alpha numeric characters only. Its
 * length must be 4 characters long only.
 *
 */

public class RegexDemo
{
    public static void main(String[] args)
    {
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("[a-zA-Z0-9]{4}", "Juli"));//true
        System.out.println(Pattern.matches("[a-zA-Z0-9]{4}", "Ju22"));//true
        System.out.println(Pattern.matches("[a-zA-Z0-9]{4}", "Peter"));//false (more than 4 char)
        System.out.println(Pattern.matches("[a-zA-Z0-9]{4}", "J$22"));//false ($ is not matched)
    }

}

Output

true
true
false
false

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/RegexDemo_alphanumeric_length_4.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/RegexDemo_alphanumeric_length_4

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/950c9f162cb72194a90be45ab9293fca2b84f41c/BasicJava/RegexDemo_alphanumeric_length_4/?at=master

See also:

How to use word and non-word Regex meta-characters | Java Regex

Click here to watch in Youtube :
https://www.youtube.com/watch?v=MOyAW-QNKgE&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

How to use word and non-word Regex meta-characters | Java Regex

RegexDemo1.java

import java.util.regex.Pattern;

/**
 * 
 * \w = Any word character, short for [a-zA-Z_0-9]
 *
 */

public class RegexDemo1
{
    public static void main(String[] args)
    {
        System.out.println("metacharacters w");
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("\\w", "a"));//true
        System.out.println(Pattern.matches("\\w", "9"));//true
        System.out.println(Pattern.matches("\\w", "_"));//true
        System.out.println(Pattern.matches("\\w", "a9"));//false
        
        System.out.println("----------------------------------");
        
        System.out.println("metacharacters w with quantifier....");  
        System.out.println(Pattern.matches("\\w*", "peter_99"));//true
        System.out.println(Pattern.matches("\\w*", "peter_99@"));//false
    }

}

Output

metacharacters w
true
true
true
false
----------------------------------
metacharacters w with quantifier....
true
false

RegexDemo2.java

import java.util.regex.Pattern;

/**
 * 
 * \W = Any non-word character, short for [^\w]
 *
 */

public class RegexDemo2
{
    public static void main(String[] args)
    {
        System.out.println("metacharacters W");
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("\\W", "@"));//true
        System.out.println(Pattern.matches("\\W", "a"));//false
        System.out.println(Pattern.matches("\\W", "9"));//false
        System.out.println(Pattern.matches("\\W", "@@"));//false
        
        System.out.println("----------------------------------");
        
        System.out.println("metacharacters W with quantifier....");  
        System.out.println(Pattern.matches("\\W*", "@@"));//true
        System.out.println(Pattern.matches("\\W*", "@@peter"));//false
    }

}

Output

metacharacters W
true
false
false
false
----------------------------------
metacharacters W with quantifier....
true
false

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/RegexDemo_metachars_slash_w.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/RegexDemo_metachars_slash_w

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/950c9f162cb72194a90be45ab9293fca2b84f41c/BasicJava/RegexDemo_metachars_slash_w/?at=master

See also:

How to use whitespace and non-whitespace Regex meta-characters | Java Regex

Click here to watch in Youtube :
https://www.youtube.com/watch?v=2oAAmJ5MEJI&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

How to use whitespace and non-whitespace Regex meta-characters | Java Regex

RegexDemo1.java

import java.util.regex.Pattern;

/**
 * 
 * \s = Any whitespace character should come only one time, short for [\t\n\x0B\f\r]
 *
 */

public class RegexDemo1
{
    public static void main(String[] args)
    {
        System.out.println("metacharacters s");
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("\\s", " "));//true [Only one whitespace can come]
        System.out.println(Pattern.matches("\\s", "\t"));//true [Only one whitespace can come]
        System.out.println(Pattern.matches("\\s", "\n"));//true [Only one whitespace can come]
        System.out.println(Pattern.matches("\\s", "\f"));//true [Only one whitespace can come]
        System.out.println(Pattern.matches("\\s", "     "));//false [Only one whitespace can come, but more whitespaces]
        System.out.println(Pattern.matches("\\s", "\t\t"));//false [Only one whitespace can come, but more whitespaces]
        System.out.println(Pattern.matches("\\s", "ab"));//false [not a whitespace]
        
        System.out.println("----------------------------------");
        
        System.out.println("metacharacters s with quantifier....");  
        System.out.println(Pattern.matches("\\s*", "       "));//true [more than one whitespace can come]
        System.out.println(Pattern.matches("\\s*", "\r\r"));//true [more than one whitespace can come]
    }

}

Output

metacharacters s
true
true
true
true
false
false
false
----------------------------------
metacharacters s with quantifier....
true
true

RegexDemo2.java

import java.util.regex.Pattern;

/**
 * 
 * \S = Any non-whitespace character Should come only one time, short for [^\s]
 *
 */

public class RegexDemo2
{
    public static void main(String[] args)
    {
        System.out.println("metacharacters S");
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("\\S", "a"));//true 
        System.out.println(Pattern.matches("\\S", "ab"));//false 
        System.out.println(Pattern.matches("\\S", " "));//false 
        System.out.println(Pattern.matches("\\S", "\t"));//false
        System.out.println(Pattern.matches("\\S", "\n"));//false 
        System.out.println(Pattern.matches("\\S", "\f"));//false 
    
        
        System.out.println("----------------------------------");
        
        System.out.println("metacharacters S with quantifier....");  
        System.out.println(Pattern.matches("\\S*", "peter"));//true
    }

}

Output

metacharacters S
true
false
false
false
false
false
----------------------------------
metacharacters S with quantifier....
true

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/RegexDemo_metachars_slash_s.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/RegexDemo_metachars_slash_s

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/950c9f162cb72194a90be45ab9293fca2b84f41c/BasicJava/RegexDemo_metachars_slash_s/?at=master

See also:

Tuesday, 28 November 2017

How to use any character, digit and non-digit Regex meta-characters | Java Regex

Click here to watch in Youtube :
https://www.youtube.com/watch?v=poHWl0h97tM&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

How to use any character, digit and non-digit Regex meta-characters | Java Regex

RegexDemo1.java

import java.util.regex.Pattern;

/**
 * 
 * \d = Any digits, short of [0-9]
 *
 */

public class RegexDemo1
{
    public static void main(String[] args)
    {
        System.out.println("metacharacters d");
        
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        
        System.out.println(Pattern.matches("\\d", "9"));//true (digit and comes once)
        System.out.println(Pattern.matches("\\d", "dfg"));//false (non-digit)  
        System.out.println(Pattern.matches("\\d", "8888"));//false (digit but comes more than once)  
        System.out.println(Pattern.matches("\\d", "555abc"));//false (digit and char)  
        
        System.out.println("----------------------------------");
        
        System.out.println("metacharacters d with quantifier....");  
        System.out.println(Pattern.matches("\\d*", "56565"));//true (digit may come 0 or more times)
    }

}

Output

metacharacters d
true
false
false
false
----------------------------------
metacharacters d with quantifier....
true

RegexDemo2.java

import java.util.regex.Pattern;

/**
 * 
 * \D = Any non-digit, short for [^0-9]
 *
 */
public class RegexDemo2
{
    public static void main(String[] args)
    {
        System.out.println("metacharacters D..");  
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("\\D", "m"));//true (non-digit and comes once)
        System.out.println(Pattern.matches("\\D", "xds"));//false (non-digit but comes more than once)  
        System.out.println(Pattern.matches("\\D", "1"));//false (digit)  
        System.out.println(Pattern.matches("\\D", "8989"));//false (digit)  
        System.out.println(Pattern.matches("\\D", "121abc"));//false (digit and char)  
        
        System.out.println("----------------------------------");
        
        System.out.println("metacharacters D with quantifier....");  
        System.out.println(Pattern.matches("\\D*", "peter"));//true (non-digit and may come 0 or more times)  
          
    }

}

Output

metacharacters D..
true
false
false
false
false
----------------------------------
metacharacters D with quantifier....
true

RegexDemo3.java

import java.util.regex.Pattern;

/**
 * 
 *  . = Any character (may or may not match terminator)
 *
 */
public class RegexDemo3
{
    public static void main(String[] args)
    {
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches(".", "m"));//true [char and comes once]
        System.out.println(Pattern.matches(".", "8"));//true [char and comes once]
        System.out.println(Pattern.matches(".", "99"));//false [char but comes more than once]
        System.out.println(Pattern.matches(".", "uiui"));//false [char but comes more than once]
          
    }

}

Output

true
true
false
false

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/RegexDemo_metachar_d.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/RegexDemo_metachar_d

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/950c9f162cb72194a90be45ab9293fca2b84f41c/BasicJava/RegexDemo_metachar_d/?at=master

See also:

How to use Regex quantifiers - part 2 | Java Regex | Java Regular Expressions | Regex in java

Click here to watch in Youtube :
https://www.youtube.com/watch?v=BSuBDTSCV0A&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

How to use Regex quantifiers - part 2 | Java Regex | Java Regular Expressions | Regex in java

RegexDemo1.java

import java.util.regex.Pattern;


public class RegexDemo1
{
    public static void main(String[] args)
    {
        System.out.println("X{n} = X occurs n times only");  
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("a{3}", "aaa"));//true (a should come 3 times)
        System.out.println(Pattern.matches("a{3}", "aaaaaa"));//false (a should come 3 times)
        System.out.println(Pattern.matches("a{3}", "aa"));//false (a should come 3 times) 
        System.out.println(Pattern.matches("a{3}", "a"));//false (a should come 3 times)
        System.out.println(Pattern.matches("a{3}", "bbb"));//false (a should come 3 times)
    }

}

Output

X{n} = X occurs n times only
true
false
false
false
false

RegexDemo2.java

import java.util.regex.Pattern;

public class RegexDemo2
{
    public static void main(String[] args)
    {
        System.out.println("X{n,} = X occurs n or more times");  
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("a{3,}", "aaa"));//true (a can come 3 times or more)
        System.out.println(Pattern.matches("a{3,}", "aaaaaa"));//true (a can come 3 times or more)
        System.out.println(Pattern.matches("a{3,}", "aa"));//false (a can come 3 times or more) 
        System.out.println(Pattern.matches("a{3,}", "a"));//false (a can come 3 times or more)
        System.out.println(Pattern.matches("a{3,}", "bbb"));//false (a can come 3 times or more)
    }

}

Output

X{n,} = X occurs n or more times
true
true
false
false
false

RegexDemo3.java

import java.util.regex.Pattern;

public class RegexDemo3
{
    public static void main(String[] args)
    {
        System.out.println("X{y,z} = X occurs at least y times but less than or equal to z times");  
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("a{3,6}", "aaa"));//true (a can come 3 times or <= 6 times)
        System.out.println(Pattern.matches("a{3,6}", "aaaaaa"));//true (a can come 3 times or <= 6 times)
        System.out.println(Pattern.matches("a{3,6}", "aaaaaaaaaaa"));//false (a can come 3 times or <= 6 times)
        System.out.println(Pattern.matches("a{3,6}", "aa"));//false (a can come 3 times or <= 6 times)
        System.out.println(Pattern.matches("a{3,6}", "a"));//false (a can come 3 times or <= 6 times)
        System.out.println(Pattern.matches("a{3,6}", "bbb"));//false (a can come 3 times or <= 6 times)
    }

}

Output

X{y,z} = X occurs at least y times but less than or equal to z times
true
true
false
false
false
false

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/RegexDemo_Quantifier_number_of_times.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/RegexDemo_Quantifier_number_of_times

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/950c9f162cb72194a90be45ab9293fca2b84f41c/BasicJava/RegexDemo_Quantifier_number_of_times/?at=master

See also:

How to use Regex quantifiers - part 1 | Java Regex | Java Regular Expressions | Regex in java

Click here to watch in Youtube :
https://www.youtube.com/watch?v=EE5UQLcY934&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

How to use Regex quantifiers - part 1 | Java Regex | Java Regular Expressions | Regex in java

RegexDemo1.java

import java.util.regex.Pattern;


public class RegexDemo1
{
    public static void main(String[] args)
    {
        System.out.println("? quantifier = occurs once or not at all");  
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("[ab]?", "a"));//true (a or b comes one time) 
        System.out.println(Pattern.matches("[ab]?", "b"));//true (a or b comes one time)
        System.out.println(Pattern.matches("[ab]?", ""));//true (occurs once or not at all)
        System.out.println(Pattern.matches("[ab]?", "ab"));//false (a and b comes one time)
        System.out.println(Pattern.matches("[ab]?", "aaa"));//false (a comes more than one time)  
        System.out.println(Pattern.matches("[ab]?", "aabbb"));//false (a and b comes more than one time)  
    }

}

Output

? quantifier = occurs once or not at all
true
true
true
false
false
false

RegexDemo2.java

import java.util.regex.Pattern;

public class RegexDemo2
{
    public static void main(String[] args)
    {
        System.out.println("+ quantifier = occurs once or more times");  
        
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("[ab]+", "a"));//true (a or b once or more times)  
        System.out.println(Pattern.matches("[ab]+", "aaa"));//true (a comes more than one time)  
        System.out.println(Pattern.matches("[ab]+", "aabb"));//true (a and b comes more than once)  
        System.out.println(Pattern.matches("[ab]+", "aazzb"));//false (z is not matching pattern)  
    }

}

Output

+ quantifier = occurs once or more times
true
true
true
false

RegexDemo3.java

import java.util.regex.Pattern;

public class RegexDemo3
{
    public static void main(String[] args)
    {
        System.out.println("* quantifier = occurs zero or more times");  
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */
        System.out.println(Pattern.matches("[ab]*", ""));//true (a or b may come zero or more times)  
        System.out.println(Pattern.matches("[ab]*", "a"));//true (a or b may come zero or more times)
        System.out.println(Pattern.matches("[ab]*", "aaa"));//true (a or b may come zero or more times)
        System.out.println(Pattern.matches("[ab]*", "aaabbb"));//true (a or b may come zero or more times)
        System.out.println(Pattern.matches("[ab]*", "aaabbbx"));//false (x is not matching pattern) 
    }

}

Output

* quantifier = occurs zero or more times
true
true
true
true
false

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/RegexDemo_Quantifier_x_question.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/RegexDemo_Quantifier_x_question

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/950c9f162cb72194a90be45ab9293fca2b84f41c/BasicJava/RegexDemo_Quantifier_x_question/?at=master

See also:

How to use intersection and subtraction Regex character classes | Java Regex

Click here to watch in Youtube :
https://www.youtube.com/watch?v=A7KukERQTZI&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

How to use intersection and subtraction Regex character classes | Java Regex

RegexDemo1.java

import java.util.regex.Pattern;

/**
 * 
 * [a-z&&[def]] = d, e, or f (intersection)
 *
 */
public class RegexDemo1
{
    public static void main(String[] args)
    {
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */     
        System.out.println("[a-z&&[def]] matches d = " +   Pattern.matches("[a-z&&[def]]", "d"));
        System.out.println("[a-z&&[def]] matches e = " +   Pattern.matches("[a-z&&[def]]", "e"));
        System.out.println("[a-z&&[def]] matches f = " +   Pattern.matches("[a-z&&[def]]", "f"));
        System.out.println("[a-z&&[def]] matches z = " +   Pattern.matches("[a-z&&[def]]", "z"));
        System.out.println("[a-z&&[def]] matches def = " +   Pattern.matches("[a-z&&[def]]", "def"));
    }

}

Output

[a-z&&[def]] matches d = true
[a-z&&[def]] matches e = true
[a-z&&[def]] matches f = true
[a-z&&[def]] matches z = false
[a-z&&[def]] matches def = false

RegexDemo2.java

import java.util.regex.Pattern;

/**
 * 
 * [a-z&&[^bc]] = a through z, except for b and c
 *
 */
public class RegexDemo2
{
    public static void main(String[] args)
    {
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */     
        System.out.println("[a-z&&[^bc]] matches h = " +   Pattern.matches("[a-z&&[^bc]]", "h"));
        System.out.println("[a-z&&[^bc]] matches c = " +   Pattern.matches("[a-z&&[^bc]]", "c"));
        System.out.println("[a-z&&[^bc]] matches hh = " +   Pattern.matches("[a-z&&[^bc]]", "hh"));
    }

}

Output

[a-z&&[^bc]] matches h = true
[a-z&&[^bc]] matches c = false
[a-z&&[^bc]] matches hh = false

RegexDemo3.java

import java.util.regex.Pattern;

/**
 * 
 * [a-z&&[^m-p]] = a through z, and not m through p
 *
 */
public class RegexDemo3
{
    public static void main(String[] args)
    {
        /*
         * Parameters:
         * 
         * regex - The expression to be compiled
         * 
         * input - The character sequence to be matched
         * 
         * Returns:
         * 
         * whether or not the regular expression matches on the input
         * 
         */     
        System.out.println("[a-z&&[^m-p]] matches b = " +   Pattern.matches("[a-z&&[^m-p]]", "b"));
        System.out.println("[a-z&&[^m-p]] matches o = " +   Pattern.matches("[a-z&&[^m-p]]", "o"));
        System.out.println("[a-z&&[^m-p]] matches bb = " +   Pattern.matches("[a-z&&[^m-p]]", "bb"));
    }

}

Output

[a-z&&[^m-p]] matches b = true
[a-z&&[^m-p]] matches o = false
[a-z&&[^m-p]] matches bb = false

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/RegexDemo_char_class_intersection.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/RegexDemo_char_class_intersection

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/950c9f162cb72194a90be45ab9293fca2b84f41c/BasicJava/RegexDemo_char_class_intersection/?at=master

See also: