*-*-*-*-*-*IMPORTANT*-*-*-*-*-*main

boolean i=line1.("RE");
sopln(i)

main
boolean i="sidd.nyati...".matches("^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z09-]+(\\.[A-Za-z0-9-]+)*(\\.[A-Za-z]{2,})$";
sopln(i);

*-*-*-*-**-*-*--*-*-*-*-*-*-*-*-*upprtcase
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
String str = "this is a java test";
System.out.println(str);
StringBuffer stringbf = new StringBuffer();
Matcher m = Pattern.compile("([a-z])([a-z]*)",
Pattern.CASE_INSENSITIVE).matcher(str);
while (m.find()) {
m.appendReplacement(stringbf,
m.group(1).toUpperCase() + m.group(2).toLowerCase());
}
System.out.println(m.appendTail(stringbf).toString());
}
}

DATE
public class Main {
public static void main(String[] argv) {
boolean isDate = false;
String date1 = "8-05-1988";
String date2 = "08/04/1987" ;
String datePattern = "\\d{1,2}-\\d{1,2}-\\d{4}";
isDate = date1.matches(datePattern);
System.out.println("Date :"+ date1+": matches with
the this date Pattern:"+datePattern+"Ans:"+isDate);
isDate = date2.matches(datePattern);
System.out.println("Date :"+ date2+": matches with
the this date Pattern:"+datePattern+"Ans:"+isDate);
}
}
EmailValidator.java
**********************************************************************
public class Main {

public static void main(String[] args) {

String EMAIL_REGEX = "^[\\w-_\\.+]*[\\w-_\\.]\\
@([\\w]+\\.)+[\\w]+[\\w]$";
String email1 = "user@domain.com";
Boolean b = email1.matches(EMAIL_REGEX);
System.out.println("is e-mail: "+email1+" :Valid = " + b);
String email2 = "user^domain.co.in";
b = email2.matches(EMAIL_REGEX);
System.out.println("is e-mail: "+email2
+" :Valid = " + b);
}
}
*********************************************************************
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class EmailValidator {
public static void main(String[] args) {
try {
String mydomain = "javahungry@blogspot.com";
String emailregex = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9-]+)*(\\.[A-Za-z]{2,})$";
Boolean b = mydomain.matches(emailregex);
if (b == false) {
System.out.println("Email Address is Invalid");
}else if(b == true){
System.out.println("Email Address is Valid");
}
}
catch (Exception e) {
e.printStackTrace();
System.out.println(e.getMessage());
}
}
}
******************************************************************************
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();
}
}
*************************************************
validate password using regular expression
*****************************************
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();
}
}
********************************************
package com.java2novice.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MyPasswordValidate {
private static Pattern pswNamePtrn =
Pattern.compile("((?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,15})");
public static boolean validatePassword(String userName){
Matcher mtch = pswNamePtrn.matcher(userName);
if(mtch.matches()){

return true;
}
return false;
}
public static void main(String a[]){
System.out.println("Is 'java2novice' a valid password? "
+validatePassword("java2novice"));
System.out.println("Is 'gabbarsingh' a valid password? "
+validatePassword("gabbarsingh"));
System.out.println("Is 'Java2NOVICE$' a valid password? "
+validatePassword("Java2NOVICE$"));
System.out.println("Is '234aBc#' a valid password? "
+validatePassword("234aBc#"));
}
}
*****************************************
password validator
package com.howtodoinjava.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PasswordValidator
{
private static PasswordValidator INSTANCE = new PasswordValidator();
private static String pattern = null;
/**
* No one can make a direct instance
* */
private PasswordValidator()
{
//do nothing
}
/**
* Force the user to build a validator using this way only
* */
public static PasswordValidator buildValidator( boolean forceSpecialChar,
boolean forceCapitalLetter,
boolean forceNumber,
int minLength,
int maxLength)
{
StringBuilder patternBuilder = new StringBuilder("((?=.*[a-z])");
if (forceSpecialChar)
{
patternBuilder.append("(?=.*[@#$%])");
}
if (forceCapitalLetter)
{
patternBuilder.append("(?=.*[A-Z])");
}
if (forceNumber)
{
patternBuilder.append("(?=.*d)");

}
patternBuilder.append(".{" + minLength + "," + maxLength + "})");
pattern = patternBuilder.toString();
return INSTANCE;
}
/**
* Here we will validate the password
* */
public static boolean validatePassword(final String password)
{
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(password);
return m.matches();
}
}
*********************************************************
DOB
***********************
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DateValidator{
private Pattern pattern;
private Matcher matcher;
private static final String DATE_PATTERN =
"(0?[1-9]|[12][0-9]|3[01])/(0?[1-9]|1[012])/((19|20)\\d\\d)";
public DateValidator(){
pattern = Pattern.compile(DATE_PATTERN);
}
/**
* Validate date format with regular expression
* @param date date address for validation
* @return true valid date fromat, false invalid date format
*/
public boolean validate(final String date){
matcher = pattern.matcher(date);
if(matcher.matches()){
matcher.reset();
if(matcher.find()){
String day = matcher.group(1);
String month = matcher.group(2);
int year = Integer.parseInt(matcher.group(3));
if (day.equals("31") &&
(month.equals("4") || month .equals("6") || month.equals("9")
||
month.equals("11") || month.equals("04") || month .equals("06"
) ||

month.equals("09"))) {
return false; // only 1,3,5,7,8,10,12 has 31 days
} else if (month.equals("2") || month.equals("02")) {
//leap year
if(year % 4==0){
if(day.equals("30") || day.equals("31")){
return false;
}else{
return true;
}
}else{
if(day.equals("29")||day.equals("30")||day.equals("31")
){
return false;
}else{
return true;
}
}
}else{
return true;
}
}else{
return false;
}
}else{
return false;
}
}
}
***********************************************
package com.java2novice.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MyDateFormat {
private static Pattern dateFrmtPtrn =
Pattern.compile("(0?[1-9]|[12][0-9]|3[01])/(0?[1-9]|1[012])/((19|20)
\\d\\d)");
public static boolean validateDateFormat(String userName){
Matcher mtch = dateFrmtPtrn.matcher(userName);
if(mtch.matches()){
return true;
}
return false;
}
public static void main(String a[]){
System.out.println("Is '03/04/2012' a valid date format? "
+validateDateFormat("03/04/2012"));
System.out.println("Is '12/23/2012' a valid date format? "
+validateDateFormat("12/23/2012"));
System.out.println("Is '12/12/12' a valid date format? "
+validateDateFormat("12/12/12"));
System.out.println("Is '3/4/2012' a valid date format? "
+validateDateFormat("3/4/2012"));
}

}
****************
PHONE NUMBER
List phoneNumbers = new ArrayList();
phoneNumbers.add("+123.123456x4444");
phoneNumbers.add("+12.1234x11");
phoneNumbers.add("+1.123456789012x123456789");
String regex = "^\\+[0-9]{1,3}\\.[0-9]{4,14}(?:x.+)?$";
Pattern pattern = Pattern.compile(regex);
for(String email : phoneNumbers)
{
Matcher matcher = pattern.matcher(email);
System.out.println(email +" : "+ matcher.matches());
}******************************.
NAME
public class MainClass
{
public static void main( String[] args )
{
System.out.println(validateFirstName("Tom"));
System.out.println(validateLastName("Tom"));
}
// validate first name
public static boolean validateFirstName( String firstName )
{
return firstName.matches( "[A-Z][a-zA-Z]*" );
} // end method validateFirstName
// validate last name
public static boolean validateLastName( String lastName )
{
return lastName.matches( "[a-zA-z]+([ '-][a-zA-Z]+)*" );
} // end method validateLastName
}
one strign
with the help of matcher.start() method of regex.Matcher class.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String args[]) {
Pattern p = Pattern.compile("j(ava)");
String candidateString = "This is a java program.
This is another java program.";
Matcher matcher = p.matcher(candidateString);
int nextIndex = matcher.start(1);
System.out.println(candidateString);
System.out.println("The index for java is:"
+ nextIndex);
}
}

************************
matcher patter
phn number
public class MatchPhoneNumber {
public static void main(String args[]) {
isPhoneValid("1-999-585-4009");
isPhoneValid("999-585-4009");
isPhoneValid("1-585-4009");
isPhoneValid("585-4009");
isPhoneValid("1.999-585-4009");
isPhoneValid("999 585-4009");
isPhoneValid("1 585 4009");
isPhoneValid("111-Java2s");
}
public static boolean isPhoneValid(String phone) {
boolean retval = false;
String phoneNumberPattern =
"(\\d-)?(\\d{3}-)?\\d{3}-\\d{4}";
retval = phone.matches(phoneNumberPattern);
String msg = "NO MATCH: pattern:" + phone
+ "\r\n regex: " + phoneNumberPattern;
if (retval) {
msg = " MATCH: pattern:" + phone
+ "\r\n regex: " + phoneNumberPattern;
}
System.out.println(msg + "\r\n");
return retval;
}
}