你应该知道的10种java正则表达式
2013-10-18 13:42
459 查看
原文：
http://www.mkyong.com/regular-expressions/10-java-regular-expression-examples-you-should-know/
正则表达式是一种编程艺术，它难以调式，学习和掌握。但是它的强大的功能仍然吸引着开发者来使用它。
这里我将示范10种常用的正则表达式，希望对你有所帮助，喜欢它。
1：用户名的正则表达式校验
正则表达式：长度为3到15，可以包含小写字母，数字，及字符"-",字符"_"
^[a-z0-9_-]{3,15}$
说明：
^ # 行的开始
[a-z0-9_-] # 匹配字符a-z,数字0-9，以及符号下划线 "_" 横线 "-"
{3,15} # 长度最短为3，最长为15
$ #结束行
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 返回true校验成功，false失败
*/
public boolean validate(final String username){
matcher = pattern.matcher(username);
return matcher.matches();
}
}
原文
http://www.mkyong.com/regular-expressions/how-to-validate-username-with-regular-expression/
2：密码校验
正则表达式：长度为6到20，至少包含一个数字，一个小写字母，一个大写字母， 及"@#$%" 中的一个特殊字符
((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})
说明：
( # 群组开始
(?=.*\d) # 必需包含0-9中的一个数字
(?=.*[a-z]) # 至少包含一个小写字母
(?=.*[A-Z]) # 至少包含一个大学字母
(?=.*[@#$%]) # 至少包含特殊字符 "@#$%" 中的一个
. # 匹配任何前面的校验的
{6,20} # 最短6，最长20
) # 群组结束
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();
}
}
原文
http://www.mkyong.com/regular-expressions/how-to-validate-password-with-regular-expression/
3：十六进制颜色代码正则表达式
正则表达式：以#字符开始，包含中括号[A-Fa-f0-9]中的6个或3个
^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
说明：
^ #行的开始
# # 必需有#字符
( # 群组开始
[A-Fa-f0-9]{6} # 中括号[A-Fa-f0-9]中的6个
| # ..或者
[A-Fa-f0-9]{3} # 中括号[A-Fa-f0-9]中的3个
) # 群组结束
$ #行的结束
java代码示例：
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();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-hex-color-code-with-regular-expression/
4：Email的正则表达式
表达式：
^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+
(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$
说明
^ #行的开始
[_A-Za-z0-9-]+ # 至少包含中括号 [_A-Za-z0-9-]的一个
( # 第一个群组（小括号）开始
\\.[_A-Za-z0-9-]+ # 在点符号后面，至少包含[_A-Za-z0-9-]中的一个
)* # 第一个群组结束，这个群组是可选的
@ # "@" 符号必需有
[A-Za-z0-9]+ # 至少包含[_A-Za-z0-9]中的一个（注意没有符号"-"了）
( # 第二个群组开始，第一次TLD校验
\\.[A-Za-z0-9]+ # 在点符号后面，至少包含[_A-Za-z0-9-]中的一个
)* # 第二个群组结束，这个群组是可选的
( # 第三个群组开始，第二次TLD校验
\\.[A-Za-z]{2,} # 在点符号后面，至少包含[_A-Za-z0-9-]中的两个
) # 第三个群组结束
$ #结束行
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();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-email-address-with-regular-expression/
5：图片文件正则表达式校验
表达式：
([^\s]+(\.(?i)(jpg|png|gif|bmp))$)
说明：
( # 第一个群组开始
[^\s]+ # 至少包含一个除空格键以外的字母，数字，符号等
( # 第二个群组开始
\. # 点号"."
(?i) # 忽略大小写检查
( # 第三个群组开始
jpg # 包含字符 "jpg" 或"png" 或 "gif" 或 "bmp"
| #
png #
| #
gif #
| #
bmp #
) # 第三个群组开始
) # 第二个群组开始
$ #
) #第一个群组开始
java 代码：
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ImageValidator{
private Pattern pattern;
private Matcher matcher;
private static final String IMAGE_PATTERN =
"([^\\s]+(\\.(?i)(jpg|png|gif|bmp))$)";
public ImageValidator(){
pattern = Pattern.compile(IMAGE_PATTERN);
}
/**
* Validate image with regular expression
* @param image image for validation
* @return true valid image, false invalid image
*/
public boolean validate(final String image){
matcher = pattern.matcher(image);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-val ebf0
idate-image-file-extension-with-regular-expression/
6：IP地址匹配
表达式：
^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.
([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$
说明：
^ #行开始
( # 第一个群组开始
[01]?\\d\\d? # 可以包含1到2位数字，如果出现3位数字，必需是以0或1开始的
# 例如： ([0-9], [0-9][0-9],[0-1][0-9][0-9])
| # ...或
2[0-4]\\d # 以2开始，紧接着[0-4]，并以[0-9]任何数字结束。如：(2[0-4][0-9])
| # ...或
25[0-5] # 以25开始，以[0-5]结束的。如：(25[0-5])
) # 第一歌群组结束
\. # 接着点号"."
.... # 重复上面的3次
$ #结束行
java代码
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class IPAddressValidator{
private Pattern pattern;
private Matcher matcher;
private static final String IPADDRESS_PATTERN =
"^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";
public IPAddressValidator(){
pattern = Pattern.compile(IPADDRESS_PATTERN);
}
/**
* Validate ip address with regular expression
* @param ip ip address for validation
* @return true valid ip address, false invalid ip address
*/
public boolean validate(final String ip){
matcher = pattern.matcher(ip);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-ip-address-with-regular-expression/
7：时间格式化正则表达式
1):12小时制时间格式化
表达式：
(1[012]|[1-9]):[0-5][0-9](\\s)?(?i)(am|pm)
说明：
( #第一个群组开始
1[012] # 以10,11,12 开始
| # 或
[1-9] # 以[1-9]开始
) #第一个群组结束
: # 冒号 ":"
[0-5][0-9] # 跟[0-5][0-9]数字 ，即从00到59
(\\s)? # 空格可选的
(?i) # 忽略大小写检查
(am|pm) # 跟am或pm
java代码
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Time12HoursValidator{
private Pattern pattern;
private Matcher matcher;
private static final String TIME12HOURS_PATTERN =
"(1[012]|[1-9]):[0-5][0-9](\\s)?(?i)(am|pm)";
public Time12HoursValidator(){
pattern = Pattern.compile(TIME12HOURS_PATTERN);
}
/**
* Validate time in 12 hours format with regular expression
* @param time time address for validation
* @return true valid time fromat, false invalid time format
*/
public boolean validate(final String time){
matcher = pattern.matcher(time);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-time-in-12-hours-format-with-regular-expression/
2）24小时制
表达式
([01]?[0-9]|2[0-3]):[0-5][0-9]
说明：
( #第一个群组开始
[01]?[0-9] # 以 0-9,1-9,00-09,10-19开始
| # 或
2[0-3] # 以 20-23开始
) #第一个群组结束
: # 后接冒号":"
[0-5][0-9] # 后跟[0-5][0-9]，即从00到59
java代码
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Time24HoursValidator{
private Pattern pattern;
private Matcher matcher;
private static final String TIME24HOURS_PATTERN =
"([01]?[0-9]|2[0-3]):[0-5][0-9]";
public Time24HoursValidator(){
pattern = Pattern.compile(TIME24HOURS_PATTERN);
}
/**
* Validate time in 24 hours format with regular expression
* @param time time address for validation
* @return true valid time fromat, false invalid time format
*/
public boolean validate(final String time){
matcher = pattern.matcher(time);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-time-in-24-hours-format-with-regular-expression/
8：格式化日期（(dd/mm/yyyy）正则表达式
表达式：
(0?[1-9]|[12][0-9]|3[01])/(0?[1-9]|1[012])/((19|20)\\d\\d)
说明：
( #第一个群组
0?[1-9] # 01-09 或 1-9
| # ..或
[12][0-9] # 10-19 或 20-29
| # ..或
3[01] # 30, 31
) #第一个群组结束
/ # 跟分隔符"/"
( # 第二个群组开始
0?[1-9] # 01-09 或 1-9
| # ..或
1[012] # 10,11,12
) # 第二个群组结束
/ # 跟分隔符"/"
( # 第三个群组开始
(19|20)\\d\\d # 19[0-9][0-9] 或 20[0-9][0-9]
) # 第三个群组结束
java代码
package com.mkyong.regex;
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;
}
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-date-with-regular-expression/
9：HTML标签校验
表达式：
<("[^"]*"|'[^']*'|[^'">])*>
说明：
< #以标签"<"开始
( # 第一个群组开始
"[^"]*" # 容许一个字符串在双引号中，如： - "string"
| # ..或
'[^']*' # 字符串可以在单引号中，如： - 'string'
| # ..或
[^'">] # 不能只有一个单引号，一个双引号，或反尖括号，
) # 第一个群组结束
* # 可选
> #以 ">"结束
HTML标签是以"<"开始，后面跟 双引号括着的字符，或单引号括着的字符，但不能只包含
单独的单引号，单独的双引号，或尖括号。最后以">"结束
java代码
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class HTMLTagValidator{
private Pattern pattern;
private Matcher matcher;
private static final String HTML_TAG_PATTERN = "<(\"[^\"]*\"|'[^']*'|[^'\">])*>";
public HTMLTagValidator(){
pattern = Pattern.compile(HTML_TAG_PATTERN);
}
/**
* Validate html tag with regular expression
* @param tag html tag for validation
* @return true valid html tag, false invalid html tag
*/
public boolean validate(final String tag){
matcher = pattern.matcher(tag);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-html-tag-with-regular-expression/
10：抽取HTML标签中的链接
1)抽取<a>标签
(?i)<a([^>]+)>(.+?)</a>
说明
( #第一个群组开始
?i # 忽略所有得大小写检查
) #第一个群组结束
<a # 以 "<a" 开始 start with "<a"
( # 第二个群组开始 start of group #2
[^>]+ # 除">"的任何内容，并且至少一个字符 anything except (">"), at least one character
) # 第二个群组结束
> # 跟 ">"
(.+?) # 匹配任何内容
</a> # 以 "</a>"j结束
2)抽取标签中的链接
\s*(?i)href\s*=\s*(\"([^"]*\")|'[^']*'|([^'">\s]+));
说明
\s* # 可以以空格符开始 can start with whitespace
(?i) # 忽略所有的大小写检查 all checking are case insensive
href # 跟"href" 单词 follow by "href" word
\s*=\s* # 两端可以有空格符 allows spaces on either side of the equal sign,
( # 第一个群组开始 start of group #1
"([^"]*") # 容许一个字符串在双引号中，如： - "string"
| # ..或
'[^']*' # 容许一个字符串在单引号中，如： - 'something'
| # ..或
([^'">]+) # 不包含单独的单引号，双引号，或反尖括号，
) # 第一群组结束
java代码
package com.mkyong.crawler.core;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class HTMLLinkExtractor {
private Pattern patternTag, patternLink;
private Matcher matcherTag, matcherLink;
private static final String HTML_A_TAG_PATTERN = "(?i)<a([^>]+)>(.+?)</a>";
private static final String HTML_A_HREF_TAG_PATTERN =
"\\s*(?i)href\\s*=\\s*(\"([^\"]*\")|'[^']*'|([^'\">\\s]+))";
public HTMLLinkExtractor() {
patternTag = Pattern.compile(HTML_A_TAG_PATTERN);
patternLink = Pattern.compile(HTML_A_HREF_TAG_PATTERN);
}
/**
* Validate html with regular expression
*
* @param html
* html content for validation
* @return Vector links and link text
*/
public Vector<HtmlLink> grabHTMLLinks(final String html) {
Vector<HtmlLink> result = new Vector<HtmlLink>();
matcherTag = patternTag.matcher(html);
while (matcherTag.find()) {
String href = matcherTag.group(1); // href
String linkText = matcherTag.group(2); // link text
matcherLink = patternLink.matcher(href);
while (matcherLink.find()) {
String link = matcherLink.group(1); // link
HtmlLink obj = new HtmlLink();
obj.setLink(link);
obj.setLinkText(linkText);
result.add(obj);
}
}
return result;
}
class HtmlLink {
String link;
String linkText;
HtmlLink(){};
@Override
public String toString() {
return new StringBuffer("Link : ").append(this.link)
.append(" Link Text : ").append(this.linkText).toString();
}
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = replaceInvalidChar(link);
}
public String getLinkText() {
return linkText;
}
public void setLinkText(String linkText) {
this.linkText = linkText;
}
private String replaceInvalidChar(String link){
link = link.replaceAll("'", "");
link = link.replaceAll("\"", "");
return link;
}
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-extract-html-links-with-regular-expression/
http://www.mkyong.com/regular-expressions/10-java-regular-expression-examples-you-should-know/
正则表达式是一种编程艺术，它难以调式，学习和掌握。但是它的强大的功能仍然吸引着开发者来使用它。
这里我将示范10种常用的正则表达式，希望对你有所帮助，喜欢它。
1：用户名的正则表达式校验
正则表达式：长度为3到15，可以包含小写字母，数字，及字符"-",字符"_"
^[a-z0-9_-]{3,15}$
说明：
^ # 行的开始
[a-z0-9_-] # 匹配字符a-z,数字0-9，以及符号下划线 "_" 横线 "-"
{3,15} # 长度最短为3，最长为15
$ #结束行
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 返回true校验成功，false失败
*/
public boolean validate(final String username){
matcher = pattern.matcher(username);
return matcher.matches();
}
}
原文
http://www.mkyong.com/regular-expressions/how-to-validate-username-with-regular-expression/
2：密码校验
正则表达式：长度为6到20，至少包含一个数字，一个小写字母，一个大写字母， 及"@#$%" 中的一个特殊字符
((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})
说明：
( # 群组开始
(?=.*\d) # 必需包含0-9中的一个数字
(?=.*[a-z]) # 至少包含一个小写字母
(?=.*[A-Z]) # 至少包含一个大学字母
(?=.*[@#$%]) # 至少包含特殊字符 "@#$%" 中的一个
. # 匹配任何前面的校验的
{6,20} # 最短6，最长20
) # 群组结束
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();
}
}
原文
http://www.mkyong.com/regular-expressions/how-to-validate-password-with-regular-expression/
3：十六进制颜色代码正则表达式
正则表达式：以#字符开始，包含中括号[A-Fa-f0-9]中的6个或3个
^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
说明：
^ #行的开始
# # 必需有#字符
( # 群组开始
[A-Fa-f0-9]{6} # 中括号[A-Fa-f0-9]中的6个
| # ..或者
[A-Fa-f0-9]{3} # 中括号[A-Fa-f0-9]中的3个
) # 群组结束
$ #行的结束
java代码示例：
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();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-hex-color-code-with-regular-expression/
4：Email的正则表达式
表达式：
^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+
(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$
说明
^ #行的开始
[_A-Za-z0-9-]+ # 至少包含中括号 [_A-Za-z0-9-]的一个
( # 第一个群组（小括号）开始
\\.[_A-Za-z0-9-]+ # 在点符号后面，至少包含[_A-Za-z0-9-]中的一个
)* # 第一个群组结束，这个群组是可选的
@ # "@" 符号必需有
[A-Za-z0-9]+ # 至少包含[_A-Za-z0-9]中的一个（注意没有符号"-"了）
( # 第二个群组开始，第一次TLD校验
\\.[A-Za-z0-9]+ # 在点符号后面，至少包含[_A-Za-z0-9-]中的一个
)* # 第二个群组结束，这个群组是可选的
( # 第三个群组开始，第二次TLD校验
\\.[A-Za-z]{2,} # 在点符号后面，至少包含[_A-Za-z0-9-]中的两个
) # 第三个群组结束
$ #结束行
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();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-email-address-with-regular-expression/
5：图片文件正则表达式校验
表达式：
([^\s]+(\.(?i)(jpg|png|gif|bmp))$)
说明：
( # 第一个群组开始
[^\s]+ # 至少包含一个除空格键以外的字母，数字，符号等
( # 第二个群组开始
\. # 点号"."
(?i) # 忽略大小写检查
( # 第三个群组开始
jpg # 包含字符 "jpg" 或"png" 或 "gif" 或 "bmp"
| #
png #
| #
gif #
| #
bmp #
) # 第三个群组开始
) # 第二个群组开始
$ #
) #第一个群组开始
java 代码：
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ImageValidator{
private Pattern pattern;
private Matcher matcher;
private static final String IMAGE_PATTERN =
"([^\\s]+(\\.(?i)(jpg|png|gif|bmp))$)";
public ImageValidator(){
pattern = Pattern.compile(IMAGE_PATTERN);
}
/**
* Validate image with regular expression
* @param image image for validation
* @return true valid image, false invalid image
*/
public boolean validate(final String image){
matcher = pattern.matcher(image);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-val ebf0
idate-image-file-extension-with-regular-expression/
6：IP地址匹配
表达式：
^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.
([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$
说明：
^ #行开始
( # 第一个群组开始
[01]?\\d\\d? # 可以包含1到2位数字，如果出现3位数字，必需是以0或1开始的
# 例如： ([0-9], [0-9][0-9],[0-1][0-9][0-9])
| # ...或
2[0-4]\\d # 以2开始，紧接着[0-4]，并以[0-9]任何数字结束。如：(2[0-4][0-9])
| # ...或
25[0-5] # 以25开始，以[0-5]结束的。如：(25[0-5])
) # 第一歌群组结束
\. # 接着点号"."
.... # 重复上面的3次
$ #结束行
java代码
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class IPAddressValidator{
private Pattern pattern;
private Matcher matcher;
private static final String IPADDRESS_PATTERN =
"^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";
public IPAddressValidator(){
pattern = Pattern.compile(IPADDRESS_PATTERN);
}
/**
* Validate ip address with regular expression
* @param ip ip address for validation
* @return true valid ip address, false invalid ip address
*/
public boolean validate(final String ip){
matcher = pattern.matcher(ip);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-ip-address-with-regular-expression/
7：时间格式化正则表达式
1):12小时制时间格式化
表达式：
(1[012]|[1-9]):[0-5][0-9](\\s)?(?i)(am|pm)
说明：
( #第一个群组开始
1[012] # 以10,11,12 开始
| # 或
[1-9] # 以[1-9]开始
) #第一个群组结束
: # 冒号 ":"
[0-5][0-9] # 跟[0-5][0-9]数字 ，即从00到59
(\\s)? # 空格可选的
(?i) # 忽略大小写检查
(am|pm) # 跟am或pm
java代码
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Time12HoursValidator{
private Pattern pattern;
private Matcher matcher;
private static final String TIME12HOURS_PATTERN =
"(1[012]|[1-9]):[0-5][0-9](\\s)?(?i)(am|pm)";
public Time12HoursValidator(){
pattern = Pattern.compile(TIME12HOURS_PATTERN);
}
/**
* Validate time in 12 hours format with regular expression
* @param time time address for validation
* @return true valid time fromat, false invalid time format
*/
public boolean validate(final String time){
matcher = pattern.matcher(time);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-time-in-12-hours-format-with-regular-expression/
2）24小时制
表达式
([01]?[0-9]|2[0-3]):[0-5][0-9]
说明：
( #第一个群组开始
[01]?[0-9] # 以 0-9,1-9,00-09,10-19开始
| # 或
2[0-3] # 以 20-23开始
) #第一个群组结束
: # 后接冒号":"
[0-5][0-9] # 后跟[0-5][0-9]，即从00到59
java代码
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Time24HoursValidator{
private Pattern pattern;
private Matcher matcher;
private static final String TIME24HOURS_PATTERN =
"([01]?[0-9]|2[0-3]):[0-5][0-9]";
public Time24HoursValidator(){
pattern = Pattern.compile(TIME24HOURS_PATTERN);
}
/**
* Validate time in 24 hours format with regular expression
* @param time time address for validation
* @return true valid time fromat, false invalid time format
*/
public boolean validate(final String time){
matcher = pattern.matcher(time);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-time-in-24-hours-format-with-regular-expression/
8：格式化日期（(dd/mm/yyyy）正则表达式
表达式：
(0?[1-9]|[12][0-9]|3[01])/(0?[1-9]|1[012])/((19|20)\\d\\d)
说明：
( #第一个群组
0?[1-9] # 01-09 或 1-9
| # ..或
[12][0-9] # 10-19 或 20-29
| # ..或
3[01] # 30, 31
) #第一个群组结束
/ # 跟分隔符"/"
( # 第二个群组开始
0?[1-9] # 01-09 或 1-9
| # ..或
1[012] # 10,11,12
) # 第二个群组结束
/ # 跟分隔符"/"
( # 第三个群组开始
(19|20)\\d\\d # 19[0-9][0-9] 或 20[0-9][0-9]
) # 第三个群组结束
java代码
package com.mkyong.regex;
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;
}
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-date-with-regular-expression/
9：HTML标签校验
表达式：
<("[^"]*"|'[^']*'|[^'">])*>
说明：
< #以标签"<"开始
( # 第一个群组开始
"[^"]*" # 容许一个字符串在双引号中，如： - "string"
| # ..或
'[^']*' # 字符串可以在单引号中，如： - 'string'
| # ..或
[^'">] # 不能只有一个单引号，一个双引号，或反尖括号，
) # 第一个群组结束
* # 可选
> #以 ">"结束
HTML标签是以"<"开始，后面跟 双引号括着的字符，或单引号括着的字符，但不能只包含
单独的单引号，单独的双引号，或尖括号。最后以">"结束
java代码
package com.mkyong.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class HTMLTagValidator{
private Pattern pattern;
private Matcher matcher;
private static final String HTML_TAG_PATTERN = "<(\"[^\"]*\"|'[^']*'|[^'\">])*>";
public HTMLTagValidator(){
pattern = Pattern.compile(HTML_TAG_PATTERN);
}
/**
* Validate html tag with regular expression
* @param tag html tag for validation
* @return true valid html tag, false invalid html tag
*/
public boolean validate(final String tag){
matcher = pattern.matcher(tag);
return matcher.matches();
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-validate-html-tag-with-regular-expression/
10：抽取HTML标签中的链接
1)抽取<a>标签
(?i)<a([^>]+)>(.+?)</a>
说明
( #第一个群组开始
?i # 忽略所有得大小写检查
) #第一个群组结束
<a # 以 "<a" 开始 start with "<a"
( # 第二个群组开始 start of group #2
[^>]+ # 除">"的任何内容，并且至少一个字符 anything except (">"), at least one character
) # 第二个群组结束
> # 跟 ">"
(.+?) # 匹配任何内容
</a> # 以 "</a>"j结束
2)抽取标签中的链接
\s*(?i)href\s*=\s*(\"([^"]*\")|'[^']*'|([^'">\s]+));
说明
\s* # 可以以空格符开始 can start with whitespace
(?i) # 忽略所有的大小写检查 all checking are case insensive
href # 跟"href" 单词 follow by "href" word
\s*=\s* # 两端可以有空格符 allows spaces on either side of the equal sign,
( # 第一个群组开始 start of group #1
"([^"]*") # 容许一个字符串在双引号中，如： - "string"
| # ..或
'[^']*' # 容许一个字符串在单引号中，如： - 'something'
| # ..或
([^'">]+) # 不包含单独的单引号，双引号，或反尖括号，
) # 第一群组结束
java代码
package com.mkyong.crawler.core;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class HTMLLinkExtractor {
private Pattern patternTag, patternLink;
private Matcher matcherTag, matcherLink;
private static final String HTML_A_TAG_PATTERN = "(?i)<a([^>]+)>(.+?)</a>";
private static final String HTML_A_HREF_TAG_PATTERN =
"\\s*(?i)href\\s*=\\s*(\"([^\"]*\")|'[^']*'|([^'\">\\s]+))";
public HTMLLinkExtractor() {
patternTag = Pattern.compile(HTML_A_TAG_PATTERN);
patternLink = Pattern.compile(HTML_A_HREF_TAG_PATTERN);
}
/**
* Validate html with regular expression
*
* @param html
* html content for validation
* @return Vector links and link text
*/
public Vector<HtmlLink> grabHTMLLinks(final String html) {
Vector<HtmlLink> result = new Vector<HtmlLink>();
matcherTag = patternTag.matcher(html);
while (matcherTag.find()) {
String href = matcherTag.group(1); // href
String linkText = matcherTag.group(2); // link text
matcherLink = patternLink.matcher(href);
while (matcherLink.find()) {
String link = matcherLink.group(1); // link
HtmlLink obj = new HtmlLink();
obj.setLink(link);
obj.setLinkText(linkText);
result.add(obj);
}
}
return result;
}
class HtmlLink {
String link;
String linkText;
HtmlLink(){};
@Override
public String toString() {
return new StringBuffer("Link : ").append(this.link)
.append(" Link Text : ").append(this.linkText).toString();
}
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = replaceInvalidChar(link);
}
public String getLinkText() {
return linkText;
}
public void setLinkText(String linkText) {
this.linkText = linkText;
}
private String replaceInvalidChar(String link){
link = link.replaceAll("'", "");
link = link.replaceAll("\"", "");
return link;
}
}
}
原文：
http://www.mkyong.com/regular-expressions/how-to-extract-html-links-with-regular-expression/
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- java知识点汇总
- java类的初始化顺序
- 单点登录原理和java实现简单的单点登录
- 对spring的理解
- 怎樣下載JAVA JDK的API幫助文檔壓縮包
- Eclipse中文语言包安装和设置中文Doc
- netbeans 应用
- java反射机制
- java反射机制
- java加密算法简介
- JSF-IDE（eclipse插件）比较 .
- EasyUI+Struts2整合KindEditor
- Activiti-04-.Spring integration
- java学习多线程之创建多线程一
- Spring3 整合Hibernate3.5 动态切换SessionFactory （切换数据库方言）
- perl基本语言语法(与java,c#不同的地方积累）
- perl基本语言语法(与java,c#不同的地方积累）
- Spring3 整合Hibernate3.5 动态切换SessionFactory （切换数据库方言）
- java类路径使用
- bae 配置 struts2