String num = "13988887777\nhaha";
String numRegex = "[1][3578]\\d{9}"; // 匹配手机号码
boolean b = num .matches(numRegex );

public static void split() {
  String str1 = "itheima.java.jacob.meteor";
  // 按“.”分割字符串
  String regex1 = "\\.";
 
  String str2 = "itheima  java    jacob \tmeteor";
  // 按空白字符分割字符串
  String regex2 = "\\s+";
 
  String str3 = "itheimaeeejava$$jacoboooometeor";
  // 按重复字符分割字符串
  String regex3 = "(.)\\1+";
 
  split (str1 , regex1 );
  split (str2 , regex2 );
  split (str3 , regex3 );
}
 
public static void split(String str, String regex) {
  String[] arr = str.split(regex);
  for (String string : arr ) {
    System.out.print( string + " | ");
  }
  System.out.println();
}

String str1 = "itheima######java&&&&&&&meteor";
// 将将叠词替换成"-"
str1 = str1 .replaceAll("(.)\\1+" , "-" );
 
String str2 = "itheima######java&&&&&&&meteor";
// 将将叠词替换成其中的一个，多个######用#替换。
// 当在第二个参数中使用第一个正则参数中的组时，可以使用$编号来完成组的调用。\\1只能使用在正则表达式中。
str2 = str2 .replaceAll("(.)\\1+" , "$1" );
 
String str3 = "13988887777";
// 将电话中的中间四位替换成****;
str3 = str3 .replaceAll("(\\d{3})(\\d{4})(\\d{4})" , "$1****$3");

package regex;
 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class PatternDemo {
 
  public static void main(String[] args) {
 
    // 需求：获取字符串中由10个字母及以上组成的单词。
 
    String str =
        "Backslashes within string literals in Java source code are interpreted as required "
        + "by The Java Language Specification as either Unicode escapes (section 3.3) or other "
        + "character escapes (section 3.10.6) It is therefore necessary to double backslashes "
        + "in string literals that represent regular expressions to protect them from "
        + "interpretation by the Java bytecode compiler. The string literal b, "
        + "for example, matches a single backspace character when interpreted as a regular "
        + "expression, while b matches a word boundary. The string literal (hello) is illegal "
        + "and leads to a compile-time error; in order to match the string (hello) the string "
        + "literal (hello) must be used.";
 
    // 定义规则。
    String regex = "\\b[a-zA-Z]{10,}\\b";
 
    // 1. 将正则字符串编译成正则对象。
    Pattern p = Pattern.compile(regex );
 
    // 2. 将正则对象和字符串相关联，并获取匹配器。
    Matcher m = p.matcher(str);
 
    // 3. 使用find的方法
    /*
     * m.lookingAt()方法从头匹配正则表达式一次。
     * m.start()和m.end()分别能够获取匹配字符串的头尾索引值。
     */
    while ( m.find()) {
      System.out.println( m.group());
    }
  }
}

package regex;
 
import java.util.Arrays;
 
public class Text_Regex {
 
  public static void main(String[] args) {
    // 需求1：匹配电子邮箱
    matchEmail();
 
    /*
     * 需求2：
     * 把“我我.....我我.我....我.要.要要.....要.要学....学...学学....学.学编..编....编..编.编.程程.程...
     * ..程.程程”
     * 还原成：我要学编程。
     */
    replace();
 
    /*
     * 需求3：
     * 127.0.0.1   3.3.3.3  192.168.104.23        10.10.10.10
     * 要求按照 ip地址的分类进行从小到大的排序。
     */
    sortIP();
  }
 
  public static void sortIP() {
    /*
     * 思路：
     * 由于需要按照数字排序，而字符串排序方式为字典顺序排序，所以先补零以获得同等长度IP地址字符串，再排序，最后还原。
     */
    String ip = "127.0.0.1   3.3.3.3  192.168.104.23        10.10.10.10";
    ip = ip.replaceAll( "(\\d+)", "00$1" );
    ip = ip.replaceAll( "0*(\\d{3})", "$1" );
    String[] ips = ip.split("\\s+");
    Arrays.sort(ips );
    for (String string : ips) {
      string = string.replaceAll( "0*(\\d+)", "$1" );
      System.out.println( string);
    }
  }
 
  public static void replace() {
    String str = "我我.....我我.我....我.要.要要.....要.要学....学...学学....学.学编..编....编..编.编.程程.程.....程.程程" ;
    str = str.replaceAll( "\\.+", "" );
    str = str.replaceAll( "(.)\\1+", "$1" );
    System.out.println( str);
  }
 
  public static void matchEmail() {
    String email = "jacobvv@163.com";
    String regex = "\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}" ;
    boolean b = email.matches( regex);
    System.out.println( b);
  }
}

package regex;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class Text_NetSpider {
 
  public static void main(String[] args) {
    /*
     * 需求：网络爬虫
     * 获取某网页上的所有邮箱地址
     */
    String url = "http://tieba.baidu.com/p/2720132008";
    Set<String> email = null;
    try {
      email = getEmail(url );
    } catch (IOException e) {
      e.printStackTrace();
    }
    for (String string : email) {
      System.out.println( string);
    }
  }
 
  public static Set<String> getEmail(String urlStr ) throws IOException {
    Set<String> email = new HashSet<String>();
    String regex = "\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}" ;
    Pattern p = Pattern.compile(regex );
   
    URL url = new URL( urlStr);
    URLConnection conn = url.openConnection();
    BufferedReader br = new BufferedReader( new InputStreamReader(conn.getInputStream()));
    String content = null;
    while (( content = br.readLine()) != null) {
      Matcher m = p.matcher(content);
      while ( m.find()) {
        email.add( m.group());
      }
    }
    br.close();
    return email;
  }
}

• .    匹配除换行符以外的任意字符
• \w   匹配字母或数字或下划线或汉字
• \s   匹配任意的空白符
• \d   匹配数字
• \b   匹配单词的开始或结束
• ^    匹配字符串的开始
• $    匹配字符串的结束

• \b\w\w\b：匹配由2个字母构成的单词。（Java字符串中为"\\b\\w\\w\\b"）

• *     重复零次或更多次
• +     重复一次或更多次
• ?     重复零次或一次
• {n}   重复n次
• {n,}  重复n次或更多次
• {n,m} 重复n到m次

• \ba\w*\b：匹配以字母a开头的单词。（Java字符串中为"\\ba\\w*\\b"）
• \d+：匹配1个或更多连续的数字。（Java字符串中为"\\d+"）
• \b\w{6}\b：匹配刚好6个字符的单词。（Java字符串中为"\\b\\w{6}\\b"）

• 单个字符的判断可以使用集合概念，只需使用"[]"即可，例如："[aeiou]"匹配任何一个英文元音字母。
• 在Java字符串中，由于字符"\"本身具有转义性，所以凡是带有"\"的正则表达式，均需要使用"\\"来替代"\"。例如上述例子"\d+"在Java字符串中应写成"\\d+"。
• 如果需要匹配正则表达式中有特殊意义的字符本身，需要使用"\"进行转义。例如可以使用正则表达式"\\w*\.\\w*"来匹配"abc.com"。

• \(?0\d{2,3}[) -]?\d{7,8}：匹配几种格式的电话号码，类似(010)88886666，或0554-22334455，或05541234567等。

• 如果多种情况需要匹配，可以使用"|"将多种正则表达式连接在一起成为一个，任何满足其中一个正则表达式即可匹配。

• 0\d{2}-\d{8}|0\d{3}-\d{7}：匹配两种以连字号分隔的电话号码：一种是三位区号，8位本地号(如010-12345678)，一种是4位区号，7位本地号(0376-2233445)。

• 如果需要对多个字符进行重复或者在Java字符串中进行替换处理，可以使用分组，符号为"()"。
• Java字符串处理中，使用"\数字"来代替前面的第几个分组，例如"(.)\\1+"匹配出现连续相同字符。

• (\d{1,3}\.){3}\d{1,3}：简单的IP地址匹配表达式，但是类似"111.222.666.999"的IP地址也视为匹配。
• ((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)：IP地址匹配表达式，由于正则表达式不支持数学运算和比较，所以只能使用繁杂的分组和分支来实现。

• \W       匹配任意不是字母，数字，下划线，汉字的字符
• \S       匹配任意不是空白符的字符
• \D       匹配任意非数字的字符
• \B       匹配不是单词开头或结束的位置
• [^x]     匹配除了x以外的任意字符
• [^aeiou] 匹配除了aeiou这几个字母以外的任意字符

• \S+：匹配不包含空白符的字符串。

• boolean  matches(String regex)

• String[]  split(String regex)
• String[]  split(String regex, int limit)

示例

• String  replaceAll(String regex, String replacement)
• String  replaceFirst(String regex, String replacement)

• 编译正则表达式
  static Pattern  compile(String regex)
• 按正则表达式获取匹配输入的匹配器
  Matcher  matcher(CharSequence input)
• 按给定正则表达式匹配字符序列
  static boolean  matches(String regex, CharSequence input)
• 获取该正则表达式
  String  pattern()
• 按正则表达式分割字符序列
  String[]  split(CharSequence input)
  String[]  split(CharSequence input, int limit)

• 匹配下一处
  boolean  find()
• 重置匹配器，从start开始匹配下一处
  boolean  find(int start)
• 获取先前已经匹配的字符串
  String  group()
• 获取匹配成功的次数
  int  groupCount()
• 从区域开头开始匹配
  boolean  lookingAt()
• 整个区域进行匹配
  boolean  matches()
• 获取该匹配器的正则表达式对象
  Pattern  pattern()
• 对匹配器的区域进行限制
  Matcher  region(int start, int end)
• 全部替换
  String  replaceAll(String replacement)
• 替换匹配第一处
  String  replaceFirst(String replacement)
• 重置匹配器
  Matcher  reset()
• 使用新的字符序列重置匹配器
  Matcher  reset(CharSequence input)
• 获取上一次匹配的开始索引
  int  start()

• 将正则表达式的字符串格式先通过Pattern中的compile方法编译成Pattern正则表达式对象。
  Pattern p = Pattern.compile("a*b");
• 要想用这个规则对字符串进行操作，还需要通过正则对象matcher方法和指定的字符串关联，并获取匹配器对象Matcher。
  Matcher m = p.matcher("aaaaab");
• 用匹配器对象Matcher的功能(方法)对字符串进行操作。
  一般使用matches()，find()，lookingAt()，start()，end()，等方法。