黑马程序员——9.正则表达式（爬虫）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

正则：

正则表达式用于操作字符串数据。
通过一些特定的符号来体现的。
所以我们为了掌握正则表达式，必须要学习一些符号。

缺点：虽然简化了，但是阅读性差。

正则表达式常用构造摘要

字符类：
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类：
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

Greedy 数量词：
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

边界匹配器：
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾

/*
* 需求：定义一个功能对QQ号进行校验。
* 需求：长度5~15，只能是数字，0不能开头。
*/

public class RegexDemo
{
    public static void main(String[] args){
        String qq = "123456701";

        //创建正则表达式
        String regex = "[1-9][0-9]{4,14}";

        //检验字符串是否符合正则表达式
        boolean b = qq.matches(regex);

        System.out.println(qq + ":" + b);
    }

常见功能：

匹配、切割、替换、获取

import java.util.regex.*;
import java.util.regex.*;

public class RegexDemo
{
        public static void main(String[] args){
                functionDemo_1();
                System.out.println("------------------------");
                functionDemo_2();
                System.out.println("------------------------");
                functionDemo_3();
                System.out.println("------------------------");
                functionDemo_4();
                System.out.println("------------------------");
                functionDemo_5();
                System.out.println("------------------------");
                functionDemo_6();
                System.out.println("------------------------");
                functionDemo_7();
        }

        /*
         * 正则表达式对字符串的常见操作
         * 1. 匹配
         *       其实使用的就是String类中的matches方法。
         *
         * 2. 切割
         *       其实使用的就是String类中的split方法。
         *
         * 3. 替换
         *
         * 4. 获取
         */

         /*
          * 演示匹配
          */
        public static void functionDemo_1(){

                //匹配手机号码是否正确
                String tel = "15800001111";

                //使用转义符号\时，要再用一个\把他转义成普通符号，就是说\总是双倍出现的
                String regex = "1[358]\\d{9}";

                boolean b = tel.matches(regex);

                System.out.println(tel + ":" + b);
        }

         /*
          * 演示切割
          */
        public static void functionDemo_2(){
                String str = "zhangsan      xiaoqiang             zhaoliu";

                //切割后的字符串片段存放进字符串数组里
                String[] names = str.split(" +");

                for(String name : names){
                        System.out.println(name);
                }
        }

        public static void functionDemo_3(){
                String str = "zhangsan.xiaoqiang.zhaoliu";

                String[] names = str.split("\\.");

                for(String name : names){
                        System.out.println(name);
                }
        }

        /*
         * 在表达式 ((A)(B(C))) 中，存在四个这样的组：
         * 1 ((A)(B(C)))
         * 2 \A
         * 3 (B(C))
         * 4 (C)
         * 组零始终代表整个表达式。
         */
        public static void functionDemo_4(){
                String str = "zhangsanttttxiaoqiangmmmmmzhaoliu";

                //(.)表示一组，\\1+表示与第1组相同的出现1次以上
                String[] names = str.split("(.)\\1+");

                for(String name : names){
                        System.out.println(name);
                }
        }

         /*
          * 演示替换
          */
        public static void functionDemo_5(){
                String str = "zhangsanttttxiaoqiangmmmmmzhaoliu";

                //$表示前一个参数的第一组
                str = str.replaceAll("(.)\\1+","$1");

                System.out.println(str);
        }

        public static void functionDemo_6(){
                String str = "15800001111";

                str = str.replaceAll("(\\d{3})(\\d{4})(\\d{4})","$1****$2");

                System.out.println(str);
        }

        /*
          * 演示获取
          * 将正则规则进行对象的封装。
          * Pattern p = Pattern.compile("a*b");
          * 通过正则对象的matcher方法字符串相关联。获取要对字符串操作的匹配器对象Matcher。
          * boolean b = m.matches();
          */
        public static void functionDemo_7(){
                String str = "da jia hao,ming tian bu fang jia";

                // \\b表示单词边界
                String regex = "\\b[a-z]{3}\\b";

                //1. 将正则封装成对象
                Pattern p = Pattern.compile(regex);

                //2. 通过正则对象获取匹配器对象
                Matcher m = p.matcher(str);

                //使用Matcher对象的方法对字符串进行操作。
                //既然要获取三个字母组成的单词。
                //查找：find();
                while(m.find()){
                        System.out.println(m.group());//获取匹配的子序列
                        System.out.println(m.start() + ":" + m.end());
                }
        }
}

P.S.
1、Pattern类为正则表达式的编译表示形式。指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

对邮件地址校验:

public class RegexTest
{
        public static void main(String[] args){
                test();
        }

        public static void test(){

                String mail = "abc1@sina.com";

                String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]{1,3})+";

                //通常的写法,相对不太精确的匹配
                //String regex = "\\w+@\\w+(\\.\\w+)+";

                boolean b = mail.matches(regex);

                System.out.println(mail + ":" + b);
        }
}

/*
* 网页爬虫：其实就是一个程序用于在互联网中获取符合指定规则的数据。
* 爬取邮箱地址。
*/

import java.util.*;
import java.io.*;

public class RegexTest
{
    public static void main(String[] args) throws IOException {
        List<String> list = getMails();

        for(String mail : list){
            System.out.println(mail);
        }
    }

    public static List<String> getMails() throws IOException {

        //读取源文件。
        BufferedReader bufr = new BufferedReader(new FileReader("c:\\mail.html"));

        //对读取的数据进行规则的匹配。从中获取符合规则的数据。
        String mail_regex = "\\w+@\\w+(\\.\\w+)+";

        //创建集合存储邮箱地址
        List<String> list = new ArrayList<String>();

        //把正则封装成对象
        Pattern p = Pattern.compile(mail_regex);

        String line = null;

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

            //一行行匹配
            Matcher m = p.matcher(line);

            //匹配到的邮箱地址存进集合里
            while(m.find()){
                list.add(m.group());
            }
        }

        //返回集合
        return list;
    }
}