你应该知道的10种java正则表达式

原文：
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-validate-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)抽取标签
(?i)]+)>(.+?)

说明

(        #第一个群组开始
 ?i        #  忽略所有得大小写检查
)        #第一个群组结束
  (        #  第二个群组开始 start of group #2
    [^>]+    #     除">"的任何内容，并且至少一个字符  anything except (">"), at least one character
   )        #  第二个群组结束
  >        #     跟 ">"
    (.+?)    #    匹配任何内容
             #     以 ""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)]+)>(.+?)";
    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 grabHTMLLinks(final String html) {
 
        Vector result = new Vector();
 
        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/