JavaCore tutorials

Java regular expression
1. How to validate username with regular expression
Remember:
Username Regular Expression Pattern
^[a-z0-9_-]{3,15}$
Description
^ # Start of the line
[a-z0-9_-] # Match characters and symbols in the list, a-z, 0-9, underscore, hyphen
{3,15} # Length at least 3 characters and maximum length of 15
$ # End of the line
Whole combination is means, 3 to 15 characters with any lower case character, digit or special
symbol “_-” only. This is common username pattern that’s widely use in different websites.
Example:
UsernameValidator.java
package org.quangthao.validateUser;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class UsernameValidator {
private Pattern pattern; //Khuân mẫu
private Matcher matcher; //Khớp(phù hợp)
private static final String USERNAME_PATTERN="^[a-z0-9_-]{3,15}$";
public UsernameValidator(){
pattern=Pattern.compile(USERNAME_PATTERN);
}
public boolean validate(final String username){
matcher=pattern.matcher(username);
return matcher.matches();
}
}
TestUsernameValidator.java
package org.quangthao.validateUser;

public class TestUsernameValidator {
private UsernameValidator usernameValidator;
public TestUsernameValidator(){
usernameValidator=new UsernameValidator();
}
public Object[] ValidUsernameProvider(){
return new Object[]{"mkyong34", "mkyong_2002","mkyong-
2002" ,"mk3-4_yong"};
}
public Object[] InvalidUsernameProvider(){
return new Object[]{"mk","mk@yong","mkyong123456789_-"};
}
public UsernameValidator getUsernameValidator() {
return usernameValidator;
}
public void setUsernameValidator(UsernameValidator usernameValidator) {
this.usernameValidator = usernameValidator;
}
public static void main(String[] args){
TestUsernameValidator test=new TestUsernameValidator();
boolean valid;
Object objectValid[]=test.ValidUsernameProvider();
Object objectInvalid[]=test.InvalidUsernameProvider();
for(int i=0;i<objectValid.length;i++){
valid=test.getUsernameValidator().validate(String.valueOf(objectValid[i]));
System.out.println(objectValid[i]+":"+valid);
}
for(int i=0;i<objectInvalid.length;i++){
valid=test.getUsernameValidator().validate(String.valueOf(objectInvalid[i]));
System.out.println(objectInvalid[i]+":"+valid);

}
}
}
Result:
mkyong34:true
mkyong_2002:true
mkyong-2002:true
mk3-4_yong:true
mk:false
mk@yong:false
mkyong123456789_-:false
Reference:
How to validate username with regular
expression
Posted on November 6, 2009 , Last modified : October 11, 2012
By mkyong
Username Regular Expression Pattern
^[a-z0-9_-]{3,15}$
Description
^ # Start of the line
[a-z0-9_-] # Match characters and symbols in the list, a-z, 0-9,
underscore, hyphen
{3,15} # Length at least 3 characters and maximum length of 15
$ # End of the line
Whole combination is means, 3 to 15 characters with any lower case character, digit or special
symbol “_-” only. This is common username pattern that’s widely use in different websites.
1. Java Regular Expression Example
UsernameValidator.java
package com.mkyong.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class UsernameValidator{

private Pattern pattern;
private Matcher matcher;

private static final String USERNAME_PATTERN = "^[a-z0-9_-]{3,15}$";

public UsernameValidator(){
pattern = Pattern.compile(USERNAME_PATTERN);
}

/**
* Validate username with regular expression
* @param username username for validation
* @return true valid username, false invalid username
*/
public boolean validate(final String username){

matcher = pattern.matcher(username);
return matcher.matches();

}
}
2. Username that match:
1. mkyong34
2. mkyong_2002
3. mkyong-2002

4. mk3-4_yong
3. Username that doesn’t match:
1. mk (too short, min 3 characters)
2. mk@yong (“@” character is not allow)
3. mkyong123456789_- (too long, max characters of 15)
4. Unit Test – UsernameValidator
Using testNG to perform unit test.
UsernameValidatorTest.java
package com.mkyong.regex;

import org.testng.Assert;
import org.testng.annotations.*;

/**
* Username validator Testing
* @author mkyong
*
*/
public class UsernameValidatorTest {

private UsernameValidator usernameValidator;

@BeforeClass
public void initData(){
usernameValidator = new UsernameValidator();
}

@DataProvider
public Object[][] ValidUsernameProvider() {
return new Object[][]{

{new String[] {
"mkyong34", "mkyong_2002","mkyong-2002" ,"mk3-4_yong"
}}
};
}

@DataProvider
public Object[][] InvalidUsernameProvider() {
return new Object[][]{
{new String[] {
"mk","mk@yong","mkyong123456789_-"
}}
};
}

@Test(dataProvider = "ValidUsernameProvider")
public void ValidUsernameTest(String[] Username) {

for(String temp : Username){
boolean valid = usernameValidator.validate(temp);
System.out.println("Username is valid : " + temp + " , " +
valid);
Assert.assertEquals(true, valid);
}

}

@Test(dataProvider = "InvalidUsernameProvider",
dependsOnMethods="ValidUsernameTest")
public void InValidUsernameTest(String[] Username) {

for(String temp : Username){
boolean valid = usernameValidator.validate(temp);
System.out.println("username is valid : " + temp + " , " +
valid);
Assert.assertEquals(false, valid);
}

}
}
5. Unit Test – Result
Username is valid : mkyong34 , true
Username is valid : mkyong_2002 , true
Username is valid : mkyong-2002 , true
Username is valid : mk3-4_yong , true
username is valid : mk , false
username is valid : mk@yong , false
username is valid : mkyong123456789_- , false
PASSED: ValidUsernameTest([Ljava.lang.String;@1d4c61c)
PASSED: InValidUsernameTest([Ljava.lang.String;@116471f)

===============================================
com.mkyong.regexusernameValidatorTest
Tests run: 2, Failures: 0, Skips: 0
===============================================


===============================================
mkyong
Total tests run: 2, Failures: 0, Skips: 0

===============================================
2. How to validate password with regular expression
Remember:
Password Regular Expression Pattern
((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})
Description
( # Start of group
(?=.*\d) # must contains one digit from 0-9
(?=.*[a-z]) # must contains one lowercase characters
(?=.*[A-Z]) # must contains one uppercase characters
(?=.*[@#$%]) # must contains one special symbols in the list "@#$%"
. # match anything with previous condition checking
{6,20} # length at least 6 characters and maximum of 20
) # End of group
?= – means apply the assertion condition, meaningless by itself, always work with other
combination
Whole combination is means, 6 to 20 characters string with at least one digit, one upper case
letter, one lower case letter and one special symbol (“@#$%”). This regular expression pattern is
very useful to implement a strong and complex password.
Example:
PasswordValidator.java
package org.quangthao.passwordvalidate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PasswordValidator {
private Pattern pattern;
private Matcher matcher;
private static final String USERNAME_PATTERN="((?=.*\\d)(?=.*[a-z])(?
=.*[A-Z])(?=.*[@#$%]).{6,20})";
public PasswordValidator(){

pattern=Pattern.compile(USERNAME_PATTERN);
}
public boolean validate(final String username){
matcher=pattern.matcher(username);
return matcher.matches();
}
}
TestPasswordValidator.java
package org.quangthao.passwordvalidate;
import org.quangthao.validateUser.TestUsernameValidator;
public class TestPasswordValidator {
private PasswordValidator passwordvalidator;
public TestPasswordValidator(){
passwordvalidator=new PasswordValidator();
}
public Object[] ValidPasswordProvider(){
return new Object[]{"mkyong1A@", "mkYOn12$"};
}
public Object[] InvalidPasswordProvider(){
return new Object[]{"mY1A@","mkyong12@","mkyoNg12*","mkyonG$
$","MKYONG12$"};
}
public PasswordValidator getPasswordvalidator() {
return passwordvalidator;
}
public void setPasswordvalidator(PasswordValidator passwordvalidator) {
this.passwordvalidator = passwordvalidator;
}
public static void main(String[] args){
TestPasswordValidator test=new TestPasswordValidator();

boolean valid;
Object objectValid[]=test.ValidPasswordProvider();
Object objectInvalid[]=test.InvalidPasswordProvider();
for(int i=0;i<objectValid.length;i++){
valid=test.getPasswordvalidator().validate(String.valueOf(objectValid[i]));
System.out.println(objectValid[i]+":"+valid);
}
for(int i=0;i<objectInvalid.length;i++){
valid=test.getPasswordvalidator().validate(String.valueOf(objectInvalid[i]));
System.out.println(objectInvalid[i]+":"+valid);
}
}
}
Result:
mkyong1A@:true
mkYOn12$:true
mY1A@:false
mkyong12@:false
mkyoNg12*:false
mkyonG$$:false
MKYONG12$:false
Reference:
How to validate password with regular
expression
Posted on November 6, 2009 , Last modified : October 11, 2012
By mkyong
Password Regular Expression Pattern
((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})
Description
( # Start of group

(?=.*\d) # must contains one digit from 0-9
(?=.*[a-z]) # must contains one lowercase characters
(?=.*[A-Z]) # must contains one uppercase characters
(?=.*[@#$%]) # must contains one special symbols in the list "@#$%"
. # match anything with previous condition checking
{6,20} # length at least 6 characters and maximum of 20
) # End of group
?= – means apply the assertion condition, meaningless by itself, always work with other
combination
Whole combination is means, 6 to 20 characters string with at least one digit, one upper case
letter, one lower case letter and one special symbol (“@#$%”). This regular expression pattern is
very useful to implement a strong and complex password.
P.S The grouping formula order is doesn’t matter.
1. Java Regular Expression Example
PasswordValidator.java
package com.mkyong.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PasswordValidator{

private Pattern pattern;
private Matcher matcher;

private static final String PASSWORD_PATTERN =
"((?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})";

public PasswordValidator(){
pattern = Pattern.compile(PASSWORD_PATTERN);

}

/**
* Validate password with regular expression
* @param password password for validation
* @return true valid password, false invalid password
*/
public boolean validate(final String password){

matcher = pattern.matcher(password);
return matcher.matches();

}
}
2. Password that match:
1. mkyong1A@
2. mkYOn12$
3. Password that doesn’t match:
1. mY1A@ , too short, minimum 6 characters
2. mkyong12@ , uppercase characters is required
3. mkyoNg12* , special symbol “*” is not allow here
4. mkyonG$$, digit is required
5. MKYONG12$ , lower case character is required
4. Unit Test – PasswordValidator
Unit test with TestNG.
PasswordValidatorTest.java
package com.mkyong.regex;

import org.testng.Assert;
import org.testng.annotations.*;

/**
* Password validator Testing
* @author mkyong
*
*/
public class PasswordValidatorTest {

private PasswordValidator passwordValidator;

@BeforeClass
public void initData(){
passwordValidator = new PasswordValidator();
}

@DataProvider
public Object[][] ValidPasswordProvider() {
return new Object[][]{
{new String[] {
"mkyong1A@", "mkYOn12$",
}}
};
}

@DataProvider
public Object[][] InvalidPasswordProvider() {
return new Object[][]{
{new String[] {
"mY1A@","mkyong12@","mkyoNg12*",
"mkyonG$$","MKYONG12$"

}}
};
}

@Test(dataProvider = "ValidPasswordProvider")
public void ValidPasswordTest(String[] password) {

for(String temp : password){
boolean valid = passwordValidator.validate(temp);
System.out.println("Password is valid : " + temp + " , " +
valid);
Assert.assertEquals(true, valid);
}

}

@Test(dataProvider = "InvalidPasswordProvider",
dependsOnMethods="ValidPasswordTest")
public void InValidPasswordTest(String[] password) {

for(String temp : password){
boolean valid = passwordValidator.validate(temp);
System.out.println("Password is valid : " + temp + " , " +
valid);
Assert.assertEquals(false, valid);
}
}
}
5. Unit Test – Result
Password is valid : mkyong1A@ , true

Password is valid : mkYOn12$ , true
Password is valid : mY1A@ , false
Password is valid : mkyong12@ , false
Password is valid : mkyoNg12* , false
Password is valid : mkyonG$$ , false
Password is valid : MKYONG12$ , false
PASSED: ValidPasswordTest([Ljava.lang.String;@1d4c61c)
PASSED: InValidPasswordTest([Ljava.lang.String;@116471f)

===============================================
com.mkyong.regex.PasswordValidatorTest
Tests run: 2, Failures: 0, Skips: 0
===============================================


===============================================
mkyong
Total tests run: 2, Failures: 0, Skips: 0
===============================================
3.How to validate Hex color code with regular expression.
Remenber:
Hexadecimal Color Code Regular Expression Pattern
^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
Description
^ #start of the line
# # must constains a "#" symbols
( # start of group #1
[A-Fa-f0-9]{6} # any strings in the list, with length of 6
| # or
[A-Fa-f0-9]{3} # any strings in the list, with length of 3

) # end of group #1
$ #end of the lin0065
Whole combination is means, string must start with a “#” symbol , follow by a letter from “a” to
“f”, “A” to “Z” or a digit from “0″ to 9″ with exactly 6 or 3 length. This regular expression
pattern is very useful for the Hexadecimal web colors code checking.
Example:
HexColorValidator.java
package org.quangthao.hexcolor;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class HexColorValidator {
private Pattern pattern;
private Matcher matcher;
private static final String HEX_PATTERN="^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]
{3})$";
public HexColorValidator(){
pattern=Pattern.compile(HEX_PATTERN);
}
public boolean validate(final String hex){
matcher=pattern.matcher(hex);
return matcher.matches();
}
}
TestHexColorValidator.java
package org.quangthao.hexcolor;
import org.quangthao.passwordvalidate.TestPasswordValidator;
public class TestHexColorValidator {
private HexColorValidator hexColorValidator;
public TestHexColorValidator(){
hexColorValidator=new HexColorValidator();

}
public Object[] ValidHexColorProvider(){
return new Object[]{"#1f1f1F", "#AFAFAF","#1AFFa1","#222fff",
"#F00"};
}
public Object[] InvalidHexColorProvider(){
return new Object[]{"mY1A@","mkyong12@","mkyoNg12*","mkyonG$
$","MKYONG12$"};
}
public HexColorValidator getHexColorValidator() {
return hexColorValidator;
}
public void setHexColorValidator(HexColorValidator hexColorValidator) {
this.hexColorValidator = hexColorValidator;
}
public static void main(String[] args){
TestHexColorValidator test=new TestHexColorValidator();
boolean valid;
Object objectValid[]=test.ValidHexColorProvider();
Object objectInvalid[]=test.InvalidHexColorProvider();
for(int i=0;i<objectValid.length;i++){
valid=test.getHexColorValidator().validate(String.valueOf(objectValid[i]));
System.out.println(objectValid[i]+":"+valid);
}
for(int i=0;i<objectInvalid.length;i++){
valid=test.getHexColorValidator().validate(String.valueOf(objectInvalid[i]));
System.out.println(objectInvalid[i]+":"+valid);
}
}
}

Result:
#1f1f1F:true
#AFAFAF:true
#1AFFa1:true
#222fff:true
#F00:true
mY1A@:false
mkyong12@:false
mkyoNg12*:false
mkyonG$$:false
MKYONG12$:false
Reference:
How to validate Hex color code with regular
expression
Posted on October 23, 2009 , Last modified : August 30, 2012
By mkyong
Hexadecimal Color Code Regular Expression Pattern
^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
Description
^ #start of the line
# # must constains a "#" symbols
( # start of group #1
[A-Fa-f0-9]{6} # any strings in the list, with length of 6
| # or
[A-Fa-f0-9]{3} # any strings in the list, with length of 3
) # end of group #1
$ #end of the line
Whole combination is means, string must start with a “#” symbol , follow by a letter from “a” to
“f”, “A” to “Z” or a digit from “0″ to 9″ with exactly 6 or 3 length. This regular expression
pattern is very useful for the Hexadecimal web colors code checking.

Java Regular Expression Example
package com.mkyong.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HexValidator{

private Pattern pattern;
private Matcher matcher;

private static final String HEX_PATTERN = "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]
{3})$";

public HexValidator(){
pattern = Pattern.compile(HEX_PATTERN);
}

/**
* Validate hex with regular expression
* @param hex hex for validation
* @return true valid hex, false invalid hex
*/
public boolean validate(final String hex){

matcher = pattern.matcher(hex);
return matcher.matches();

}
}

Hex code that match:
1. “#1f1f1F”, “#AFAFAF”,”#1AFFa1″,”#222fff”, “#F00″, “#F00″
Hex code that doesn’t match:
1. “123456″ – must start with a “#” symbol
2. “#afafah” – “h” is not allow, valid letter from “a” to “f”
3. “#123abce” – either 6 length or 3 length
4. “aFaE3f” – must start with a “#” symbol, either 6 length or 3 length
5. “F00″ – must start with a “#” symbol
6. “#afaf” – either 6 length or 3 length
7. “#F0h” – “h” is not allow, valid letter from “a” to “f”
Unit Test – HexValidator
package com.mkyong.regex;

import org.testng.Assert;
import org.testng.annotations.*;

/**
* Hex validator Testing
* @author mkyong
*
*/
public class HexValidatorTest {

private HexValidator hexValidator;

@BeforeClass
public void initData(){
hexValidator = new HexValidator();
}

@DataProvider
public Object[][] ValidHexProvider() {
return new Object[][]{
{new String[] {
"#1f1f1F", "#AFAFAF","#1AFFa1","#222fff",
"#F00"
}}
};
}

@DataProvider
public Object[][] InvalidHexProvider() {
return new Object[][]{
{new String[] {
"123456","#afafah","#123abce","aFaE3f",
"F00","#afaf", "#F0h"
}}
};
}

@Test(dataProvider = "ValidHexProvider")
public void ValidHexTest(String[] hex) {

for(String temp : hex){
boolean valid = hexValidator.validate(temp);
System.out.println("Hex is valid : " + temp + " , " +
valid);
Assert.assertEquals(true, valid);
}

}

@Test(dataProvider = "InvalidHexProvider",
dependsOnMethods="ValidHexTest")
public void InValidHexTest(String[] hex) {

for(String temp : hex){
boolean valid = hexValidator.validate(temp);
System.out.println("Hex is valid : " + temp + " , " +
valid);
Assert.assertEquals(false, valid);
}

}
}
Unit Test – Result
Hex is valid : #1f1f1F , true
Hex is valid : #AFAFAF , true
Hex is valid : #1AFFa1 , true
Hex is valid : #222fff , true
Hex is valid : #F00 , true
Hex is valid : 123456 , false
Hex is valid : #afafah , false
Hex is valid : #123abce , false
Hex is valid : aFaE3f , false
Hex is valid : F00 , false
Hex is valid : #afaf , false
Hex is valid : #F0h , false
PASSED: ValidHexTest([Ljava.lang.String;@1a626f)
PASSED: InValidHexTest([Ljava.lang.String;@e5855a)

===============================================
com.mkyong.regex.HexValidatorTest
Tests run: 2, Failures: 0, Skips: 0
===============================================


===============================================
mkyong
Total tests run: 2, Failures: 0, Skips: 0
===============================================
Reference
/>4.How to validate email address with regular expression.
Remember:
Email Regular Expression Pattern
^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*
@[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$;
Description
^ #start of the line
[_A-Za-z0-9-\\+]+ # must start with string in the bracket [ ], must
contains one or more (+)
( # start of group #1
\\.[_A-Za-z0-9-]+ # follow by a dot "." and string in the bracket [
], must contains one or more (+)
)* # end of group #1, this group is optional (*)
@ # must contains a "@" symbol
[A-Za-z0-9-]+ # follow by string in the bracket [ ], must
contains one or more (+)
( # start of group #2 - first level TLD checking
\\.[A-Za-z0-9]+ # follow by a dot "." and string in the

bracket [ ], must contains one or more (+)
)* # end of group #2, this group is optional (*)
( # start of group #3 - second level TLD checking
\\.[A-Za-z]{2,} # follow by a dot "." and string in the
bracket [ ], with minimum length of 2
) # end of group #3
$ #end of the line
The combination means, email address must start with “_A-Za-z0-9-\\+” , optional follow by “.
[_A-Za-z0-9-]“, and end with a “@” symbol. The email’s domain name must start with “A-Za-
z0-9-”, follow by first level Tld (.com, .net) “.[A-Za-z0-9]” and optional follow by a second level
Tld (.com.au, .com.my) “\\.[A-Za-z]{2,}”, where second level Tld must start with a dot “.” and
length must equal or more than 2 characters.
Example:
EmailValidator.java
package org.quangthao.email;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class EmailValidator {
private Pattern pattern;
private Matcher matcher;
private static final String EMAIL_PATTERN="^[_A-Za-z0-9-\\+]+(\\.[_A-
Za-z0-9-]+)*@"+ "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
public EmailValidator(){
pattern=Pattern.compile(EMAIL_PATTERN);
}
public boolean validate(final String email){
matcher=pattern.matcher(email);
return matcher.matches();
}
}

TestEmailValidator.java
package org.quangthao.email;
import org.quangthao.hexcolor.HexColorValidator;
import org.quangthao.hexcolor.TestHexColorValidator;
public class TestEmailValidator {
private EmailValidator emailValidator;
public TestEmailValidator(){
emailValidator=new EmailValidator();
}
public Object[] ValidEmailProvider(){
return new Object[]{ "",
"", "",
"", "",
"", "",
"", "",
"" };
}
public Object[] InvalidEmailProvider(){
return new Object[]{ "mkyong", "mkyong@.com.my",
"", "mkyong123@.com",
"mkyong123@.com.com",
"", "mkyong()*@gmail.com", "mkyong@
%*.com",
"mkyong ", "",
"mkyong@", "" } ;
}
public EmailValidator getEmailValidator() {
return emailValidator;
}
public void setEmailValidator(EmailValidator emailValidator) {

this.emailValidator = emailValidator;
}
public static void main(String[] args){
TestEmailValidator test=new TestEmailValidator();
boolean valid;
Object objectValid[]=test.ValidEmailProvider();
Object objectInvalid[]=test.InvalidEmailProvider();
for(int i=0;i<objectValid.length;i++){
valid=test.getEmailValidator().validate(String.valueOf(objectValid[i]));
System.out.println(objectValid[i]+":"+valid);
}
for(int i=0;i<objectInvalid.length;i++){
valid=test.getEmailValidator().validate(String.valueOf(objectInvalid[i]));
System.out.println(objectInvalid[i]+":"+valid);
}
}
}
Result:
:true
:true
:true
:true
:true
:true
:true
:true
:true
:true
mkyong:false
mkyong@.com.my:false

:false
mkyong123@.com:false
mkyong123@.com.com:false
:false
mkyong()*@gmail.com:false
mkyong@%*.com:false
mkyong :false
:false
mkyong@:false
:false
Reference:
How to validate email address with regular
expression
Posted on October 31, 2009 , Last modified : October 9, 2012
By mkyong
Email Regular Expression Pattern
^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*
@[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$;
Description
^ #start of the line
[_A-Za-z0-9-\\+]+ # must start with string in the bracket [ ], must
contains one or more (+)
( # start of group #1
\\.[_A-Za-z0-9-]+ # follow by a dot "." and string in the bracket [
], must contains one or more (+)
)* # end of group #1, this group is optional (*)
@ # must contains a "@" symbol
[A-Za-z0-9-]+ # follow by string in the bracket [ ], must
contains one or more (+)
( # start of group #2 - first level TLD checking

\\.[A-Za-z0-9]+ # follow by a dot "." and string in the
bracket [ ], must contains one or more (+)
)* # end of group #2, this group is optional (*)
( # start of group #3 - second level TLD checking
\\.[A-Za-z]{2,} # follow by a dot "." and string in the
bracket [ ], with minimum length of 2
) # end of group #3
$ #end of the line
The combination means, email address must start with “_A-Za-z0-9-\\+” , optional follow by “.
[_A-Za-z0-9-]“, and end with a “@” symbol. The email’s domain name must start with “A-Za-
z0-9-”, follow by first level Tld (.com, .net) “.[A-Za-z0-9]” and optional follow by a second level
Tld (.com.au, .com.my) “\\.[A-Za-z]{2,}”, where second level Tld must start with a dot “.” and
length must equal or more than 2 characters.
1. Java Regular Expression Example
Here’s a Java example to show you how to use regex to validate email address.
EmailValidator.java
package com.mkyong.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class EmailValidator {

private Pattern pattern;
private Matcher matcher;

private static final String EMAIL_PATTERN =
"^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
+ "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";

public EmailValidator() {
pattern = Pattern.compile(EMAIL_PATTERN);
}

/**
* Validate hex with regular expression
*
* @param hex
* hex for validation
* @return true valid hex, false invalid hex
*/
public boolean validate(final String hex) {

matcher = pattern.matcher(hex);
return matcher.matches();

}
}
2. Valid Emails
1. , ,
2. , ,
3. ,
4. ,
3. Invalid Emails
1. mkyong – must contains “@” symbol
2. mkyong@.com.my – tld can not start with dot “.”
3. – “.a” is not a valid tld, last tld must contains at least two characters
4. mkyong123@.com – tld can not start with dot “.”
5. mkyong123@.com.com – tld can not start with dot “.”
6. – email’s first character can not start with dot “.”

7. mkyong()*@gmail.com – email’s is only allow character, digit, underscore and dash
8. mkyong@%*.com – email’s tld is only allow character and digit
9. mkyong – double dots “.” are not allow
10. – email’s last character can not end with dot “.”
11. mkyong@ – double “@” is not allow
12. -email’s tld which has two characters can not contains digit
4. Unit Test
Here’s a unit test using testNG.
EmailValidatorTest.java
package com.mkyong.regex;

import org.testng.Assert;
import org.testng.annotations.*;

/**
* Email validator Testing
*
* @author mkyong
*
*/
public class EmailValidatorTest {

private EmailValidator emailValidator;

@BeforeClass
public void initData() {
emailValidator = new EmailValidator();
}

@DataProvider

public Object[][] ValidEmailProvider() {
return new Object[][] { { new String[] { "",
"", "",
"", "",
"", "",
"", "",
"" } } };
}

@DataProvider
public Object[][] InvalidEmailProvider() {
return new Object[][] { { new String[] { "mkyong",
"mkyong@.com.my",
"", "mkyong123@.com",
"mkyong123@.com.com",
"", "mkyong()*@gmail.com", "mkyong@
%*.com",
"mkyong ", "",
"mkyong@", "" } } };
}

@Test(dataProvider = "ValidEmailProvider")
public void ValidEmailTest(String[] Email) {

for (String temp : Email) {
boolean valid = emailValidator.validate(temp);
System.out.println("Email is valid : " + temp + " , " +
valid);
Assert.assertEquals(valid, true);
}

}

@Test(dataProvider = "InvalidEmailProvider", dependsOnMethods =
"ValidEmailTest")
public void InValidEmailTest(String[] Email) {

for (String temp : Email) {
boolean valid = emailValidator.validate(temp);
System.out.println("Email is valid : " + temp + " , " +
valid);
Assert.assertEquals(valid, false);
}
}
}
Here’s the unit test result.
Email is valid : , true
Email is valid : , true
Email is valid : , true
Email is valid : , true
Email is valid : , true
Email is valid : , true
Email is valid : , true
Email is valid : , true
Email is valid : , true
Email is valid : , true
Email is valid : mkyong , false
Email is valid : mkyong@.com.my , false
Email is valid : , false
Email is valid : mkyong123@.com , false

Email is valid : mkyong123@.com.com , false
Email is valid : , false
Email is valid : mkyong()*@gmail.com , false
Email is valid : mkyong@%*.com , false
Email is valid : mkyong , false
Email is valid : , false
Email is valid : mkyong@ , false
Email is valid : , false
PASSED: ValidEmailTest([Ljava.lang.String;@15f48262)
PASSED: InValidEmailTest([Ljava.lang.String;@789934d4)

===============================================
Default test
Tests run: 2, Failures: 0, Skips: 0
===============================================
References
1.
2.
5.How to validate image file extension with regular expression.
Remember:
Image File Extension Regular Expression Pattern
([^\s]+(\.(?i)(jpg|png|gif|bmp))$)
Description
( #Start of the group #1
[^\s]+ # must contains one or more anything (except white
space)
( # start of the group #2
\. # follow by a dot "."
(?i) # ignore the case sensive checking for the
following characters

( # start of the group #3
jpg # contains characters "jpg"