正则表达式基本用法

正则表达式：符合一定规则的表达式，用特定符号来表达一些代码。

    特点：用于一些特定的符号来表示一些代码操作，这样可以简化书写

    作用:专门用于操作字符串。

    优点：可以简化对字符串的复杂操作。

    缺点：符号定义越多，正则表达式越长，阅读性越差

正则表达式的构造摘要

1. 字符

        \\                 反斜线字符

        \t                 制表符 ('\u0009')

        \n                 新行（换行）符 ('\u000A')

        \r                 回车符 ('\u000D')

2、字符类

        [abc]                    a、b或 c（简单类）

        [^abc]                 任何字符，除了 a、b或 c（否定）

        [a-zA-Z]               a到 z或 A 到 Z，两头的字母包括在内（范围）

        [a-d[m-p]]            a到 d或 m 到 p：[a-dm-p]（并集）

        [a-z&&[def]]               d、e或 f（交集）

        [a-z&&[^bc]]        a到 z，除了 b和 c：[ad-z]（减去）

        [a-z&&[^m-p]]     a到 z，而非 m到 p：[a-lq-z]（减去）

3、预定义字符类

        .                         任何字符（与行结束符可能匹配也可能不匹配）

        \d                        数字：[0-9]

        \D                       非数字： [^0-9]

        \w                       单词字符：[a-zA-Z_0-9]

        \W                      非单词字符：[^\w]

4、边界匹配器

         \b                        单词边界

        \B                       非单词边界

5、Greedy数量词

        X?                       X，一次或一次也没有

        X*                       X，零次或多次

        X+                       X，一次或多次

        X{n}                    X，恰好 n次

        X{n,}                   X，至少 n次

        X{n,m}                X，至少 n次，但是不超过 m 次

6、组和捕获

       捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C)))中，存在四个这样的组：

                    1     ((A)(B(C)))

                    2     \A

                    3     (B(C))

                    4     (C)

       组零始终代表整个表达式。在替换中常用$匹配组的内容。

具体操作功能：匹配、切割、替换和获取

匹配：String  matches方法。

    用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。

判断一串数字是否是手机号：手机号段只有 13xxx 15xxx 18xxxx

       public static void checkTel()

       {

              String tel = "16900001111";

              String telReg = "1[358]\\d{9}";

              System.out.println(tel.matches(telReg));

       }

判断字符串是否是以字母开头其余全是数字

       public static void demo()

       {

              String str = "b23a23456789";

              String reg = "[a-zA-Z]\\d*";

              boolean b= str.matches(reg);

              System.out.println(b);

       }

判断qq是否正确：qq5-15位，不能以0开头，中间也不能有字母

       public static void checkQQ()

       {

              String qq = "123a454";

              String regex = "[1-9]\\d{4,14}";

              boolean flag = qq.matches(regex);

              if(flag)

                     System.out.println(qq+"...is ok");

              else

                     System.out.println(qq+"... 不合法");

       }

切割：String split();

    多空格切割：" _+"  _表示空格 

     .点的切割："\."操作

    \\ 切割 ："\\\\"操作

    叠词的切割："(.)\\1+"来操作，其中(.)是通配符，\\1代表叠一次，后面的+表示叠了多次。

实例：用 \\ 切割c:\\abc\\234\\a.doc

class RegexDemo

{

    public static void main(String[] args)

    {

    splitDemo("c:\\abc\\234\\a.doc","\\\\");

    }

    public static void splitDemo(String s,String t)

    {

        String [] arr= s.split(t);

        for(String st:arr)

        System.out.println(st);

    }

}

替换：String replaceAll(regex,str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组。

    典型的写法 str.replaceAll("(.)\\1+","$1")

实例：

public static void test_1()

{

    String str = "我我...我我...我要..要要...要要...学学学....学学...编编编...编程..程.        程程...程...程";

    /*

    将已有字符串变成另一个字符串。使用 替换功能。

    1,可以先将 . 去掉。

    2，在将多个重复的内容变成单个内容。

    */

    str = str.replaceAll("\\.+","");

    System.out.println(str);

    str = str.replaceAll("(.)\\1+","$1");

    System.out.println(str);

}

获取:将字符串中的符合规则的子串取出。

操作步骤：

1，将正则表达式封装成对象。            Pattern p = Pattern.compile(reg);

2，让正则对象和要操作的字符串相关联。  Matcher m = p.matcher(str);

3，关联后，获取正则匹配引擎。           while( m.find())

4，通过引擎对符合规则的子串进行操作，    {    m.group(); }               伪代码

    比如取出。

实例：获取ming tian jiu yao fang jia le ,da jia。 中4个字母的单词

import java.util.regex.*;

class RegexDemo2

{

       public static void main(String[] args)

       {

              getDemo();

       }

       public static void getDemo()

       {

              String str = "ming tian jiu yao fang jia le ,da jia。";

              System.out.println(str);

              String reg = "\\b[a-z]{4}\\b";

              //将规则封装成对象。

              Pattern p = Pattern.compile(reg);

              //让正则对象和要作用的字符串相关联。获取匹配器对象。

              Matcher m  = p.matcher(str);

              while(m.find())

              {

                     System.out.println(m.group());

                     System.out.println(m.start()+"...."+m.end());//返回索引位置

              }

       }

}

其中group(),start(),end()所带的参数i就是正则表达式中的子表达式索引（第几个子表达式）

用法总结：

    1.只想知道字符串对错（判断）用匹配

    2.将字符串变为另一个字符串  用替换

    3.将字符串按规则获取成多个子串  用分割

    4.想获取字符串中的一部分  用获取

网页爬虫实例：

/*

网页爬虫(蜘蛛)

实际上是一个功能，用于搜集网络上的指定信息

需求：可用于收集邮箱等信息。

应用：如通过关键字搜索，实际就是使用“蜘蛛”，通过查找关键字获取相关的信息

*/

import java.io.*;

import java.util.regex.*;

import java.net.*;

import java.util.*;

class RegexTest2

{

    public static void main(String[] args) throws Exception

    {

       getMails_1();

    }

    public static void getMails_1()throws Exception

    {

       URL url = new URL("http://192.168.1.254:8080/myweb/mail.html");

       URLConnection conn = url.openConnection();

       BufferedReader bufIn = new BufferedReader(new InputStreamReader(conn.getInputStream()));

       String line = null;

       String mailreg = "\\w+@\\w+(\\.\\w+)+";

       Pattern p = Pattern.compile(mailreg);

       while((line=bufIn.readLine())!=null)

       {

           Matcher m = p.matcher(line);

           while(m.find())

           {

              System.out.println(m.group());

           }

       }

    }

    /*

    获取指定文档中的邮件地址。

    使用获取功能。Pattern  Matcher

    */

    public static void getMails()throws Exception

    {

       BufferedReader bufr =

           new BufferedReader(new FileReader("mail.txt"));

       String line = null;

       String mailreg = "\\w+@\\w+(\\.\\w+)+";

       Pattern p = Pattern.compile(mailreg);

       while((line=bufr.readLine())!=null)

       {

           Matcher m = p.matcher(line);

           while(m.find())

           {

              System.out.println(m.group());

           }

       }

    }

}