Javaベースの正規表現_

 1:正则表达式(理解)
    (1)就是符合一定规则的字符串, 好处：可以简化对字符串的复杂操作。弊端：符合定义越多，正则越长，阅读性越差。
    (2)常见规则
        A:字符
            x 字符 x。举例：'a'表示字符a
            \\ 反斜线字符。
            \n 新行（换行）符 ('\u000A') 
            \r 回车符 ('\u000D')

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

        C:预定义字符类
            . 任何字符。我的就是.字符本身，怎么表示呢? \.
            \d 数字：[0-9]
            \w 单词字符：[a-zA-Z_0-9]
                在正则表达式里面组成单词的东西必须有这些东西组成

        D:边界匹配器
            ^ 行的开头 
            $ 行的结尾 
            \b 单词边界
                就是不是单词字符的地方。
                举例：hello world?haha;xixi

        E:Greedy 数量词 
            X? X，一次或一次也没有
            X* X，零次或多次
            X+ X，一次或多次
            X{n} X，恰好 n 次 
            X{n,} X，至少 n 次 
            X{n,m} X，至少 n 次，但是不超过 m 次 
    (3)常见功能：(分别用的是谁呢?)
        A:判断功能
            String类的public boolean matches(String regex)
        B:分割功能
            String类的public String[] split(String regex)
        C:替换功能
            String类的public String replaceAll(String regex,String replacement)
        D:获取功能
            Pattern和Matcher
                Pattern p = Pattern.compile("a*b");
                Matcher m = p.matcher("aaaaab");

                find():查找存不存在
                group():获取刚才查找过的数据
    (4)案例
        A:判断电话号码和邮箱
        B:ip地址排序
        C:网络爬虫Spider

1、試合：試合

/*
 *  主要有四种具体功能：匹配、切割、替换和获取
            matches , split , replaceAll , Pattern
    匹配：String类中的booleanmatches(String regex)方法。
    用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。
    用String类中的matches方法来匹配
 * 
 * A需求：校验QQ号码 和手机号
 * */
public class MatchesDemo {
            public static void main(String[] args) {
                String qq = "12365";
                qqCheck(qq);

                String phone = "13878987654";
                PhoneCheck(phone);
            }

            //校验QQ号码
            public static void qqCheck(String qq)
            {
                String  regex="[1-9]\\d{4,13}";//开头是1-9，第二位以后\d任何数字,X{n,m}  X，至少 n次，但是不超过 m 次
                if(qq.matches(regex))//用String类中的matches方法来匹配
                {
                    System.out.println("QQ:"+qq);
                }else{
                    System.out.println(qq+"是非法号码");
                }
            }

            //匹配手机号码号段只有 13xxxx 15xxxx 18xxxx
            public static void PhoneCheck(String phone)
            {
                String regex="1[358]\\d{9}";
                if(phone.matches(regex))
                {
                    System.out.println(phone+"::is ok");
                }else{
                    System.out.println("手机号码输入有误");
                }
            }

}

図2に示すように、分割切削

//切割：String 类中的 String[]split(String regex)方法
/*
    .  任何字符（与行结束符可能匹配也可能不匹配）
    按叠词完成切割：为了让规则被重用，可将规则封装成一个组，
用()完成。组的出现都有编号，从1开始。想要使用已有的组可通过\n（n就是组的编号）的形式来获取
*/

public class SplitDemo {
        public static void main(String[] args) {

            String regex1 = "\\.";//按.切

            String regex2 = " +";//按空格切，可能有一个空格或者多个空格

            String regex3 = "(.)\\1+";//.是任何字符，封装成组按照出现两次或者两次以上的叠词切

            String[] arr="192.168.0.1".split(regex1);
            print(arr);

            arr = "wo shi shui   58 0  1 55    3".split(regex2);

            arr ="eq55rkkitppdsaqqq0zzfogff".split(regex3);
            print(arr);             
        }
        //遍历功能
        public static void print(String[] arr)
        {
            for(String s :arr)
            {
                System.out.println(s);
            }
        }
}

3、置き換えでReplaceAll

/*
说明：
        按叠词完成切割：为了让规则被重用，可将规则封装成一个组，
        用()完成。组的出现都有编号，从1开始。想要使用已有的组可通过\n（n就是组的编号）的形式来获取。
        对于组中所匹配的字符，可以用$n来获取。$在正则中表示行的结尾，
        所以出现在正则中不能用来表示组，一般用于替换中。
        如下面功能中

    替换：String replaceAll(String regex,String replacement)方法

*/
public class ReplaceDemo {
        public static void main(String[] args) {
            String s1 = "eqrewq55555wid666666eao88f15123fs999d";

            String regex = "\\d{5,}";//将字符串中的数字{5个以上}替换成# ;X{n,}   X，至少 n次
                s1 = s1.replaceAll(regex, "#");

            String s2 = "erkkyoqqdsafffdwqzzzzzo";//将叠词地换位一个，其中$1表示符合组中一个字符
             String regex2 = "(.)\\1+";
                s2 = s2.replaceAll(regex2, "$1");

                 System.out.println("s1:"+s1);
                 System.out.println("s2:"+s2);  
        }
}

得る4：パターン

*
 *  获取：将字符串中的符合规则的子串取出
 * 
 * 简单一句话就是定义好规则，封装成Pattern对象，通过Matcher和要作用的字符串关联，获取匹配器
 * 通过匹配器循环find查找,group获取匹配后的结果
 * 操作步骤：
 *      1，将正则表达式封装成对象
 *      2，让正则对象和要操作的字符串相关联
 *      3，关联后，获取正则匹配引擎
 *      4，通过引擎对符合规则的子串进行操作，比如取出
 * */
public class PatternDemo {
        public static void main(String[] args) {
            String s = " ming tian  jiu  yao  fang  jia  le , da  jia !";
            String regex="\\b[a-z]{4}\\b";//  \\b单词边界  , 匹配四个字符的子串
            get(s,regex);
        }

        //定义一个获取匹配规则的功能 可重复调用，让正则对象和要操作的字符串相关联
        public static void get(String s ,String regex)
        {
            //将规则封装成对象
            Pattern p  = Pattern.compile(regex);

            //让正则对象和要作用的字符串相关联，获取匹配器对象
            Matcher m = p.matcher(s);

            //System.out.println(m.matches());
            //其实String类中的matches方法，用的就是Pattern和Matcher对象来完成的
            //只不过被String的方法封装后，用起来比较简单，但是功能单一

            while(m.find())//find()方法是将规则作用到字符串上，并进行符合规则的子串查找
            {
                System.out.println(m.group());//group()方法用于获取匹配后的结果

                System.out.println(m.start()+"..."+m.end());
                 //start()和end()分别表示匹配字符的开始和结尾的索引,包含头不包含尾
            }

        }
}

ケースB：IPアドレスのソート

/*
需求： 
将ip地址进行地址段顺序的排序。 
192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.301 

思路：
    按照字符串自然顺序，只要让他们每一段都是3位即可。
    1，按照每一段需要的最多的0进行补齐，name每一段就会至少保证有3位
    2，将每一段只保留3位，这样所有的ip地址都是每一段3位；

 需求2：对邮件地址进行校验。 

*/
public class IPSortTest {
        public static void main(String[] args) {

            CheckMail();
            IPSort();
        }

        //需求：对邮箱地址进行校验
        public static void CheckMail(){
            String mail = "[email protected]";
            String regex = "\\w+@[a-zA-Z0-9]+(\\.[z-zA-z]+){1,3}";//[a-zA-Z_0-9] 简写\w ;封装组1次到3次
                    // regex = "\\w@\\w+(\\.\\w)+";//相对不太精确的匹配
            boolean b = mail.matches(regex);
            System.out.println(b);
        }

        //校验IP地址
        public static void IPSort()
        {
             String ip="192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.301"; 
               System.out.println("原始ip=="+ip);

               ip =ip.replaceAll("(\\d+)","00$1");// 保证每段至少都有三位
               System.out.println("添加两个0=="+ip);

               ip = ip.replaceAll("0*(\\d{3})", "$1"); //再替换一次，打头0没有或多次，数字出现3次，$1匹配第一组的内容,每段只保留三位 
               System.out.println("每段保留三位=="+ip);

               String[] arr = ip.split(" ");//按照空格切

               System.out.println("按空格切后的数组:"+Arrays.toString(arr));

               //定义一个TreeSet集合，利用元素的自然排序
               TreeSet<String> ts = new TreeSet<String>();
               for(String str :arr)
               {
                   ts.add(str);//添加进数组
               }
                //把每段前面多余的0替换掉
               for(String s:ts)
               {
                   String str= s.replaceAll("0*(\\d)", "$1");
                   System.out.println("结果:"+str);
               }

        }
}

ケースC：クローラは、一致するメールボックスを取得します

/* 
网络爬虫（蜘蛛） 
实际上是一个功能，用于搜集网络上的指定信息 
需求：可用于收集邮箱，qq号等之类的信息。 
应用：如通过关键字搜索blog，实际就是使用的“蜘蛛”，通过查找关键字获取相关的blog 
*/
public class Spider {

    public static void main(String[] args) throws Exception {
        //getWebMail();
        getFileMail();
    }

    //获得网页中的mail
    public static void getWebMail() throws Exception
    {
        //封装网页地址
        URL url = new URL("http://tieba.baidu.com/p/1390896758?pn=2");
        //连接服务器
        URLConnection conn = url.openConnection();
        //创建带缓冲区的网页读取流
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));

        //定义匹配邮件地址的正则表达式，并封装
        String regex = "\\w+@\\w+(\\.\\w+)+";//我们模糊搜索

        Pattern p = Pattern.compile(regex);

        //读取网页数据
        String line = null;
        while ((line=br.readLine())!=null)
        {
            //正则关联数据，获取匹配器对象
            Matcher m = p.matcher(line);//每行读取到的内容都要去匹配，然后循环输出
            //寻找匹配的邮箱
            while(m.find())
            {
                System.out.println(m.group());//输出匹配邮箱
            }

        }

    }

     //获取指定文档中的邮件地址，使用获取功能  pattern Matcher
     public static void getFileMail() throws Exception
     {
         //将文件封装城对象
         String path = Spider.class.getResource("mail.txt").getFile();//获取文件路径，如果在src根目录则需要加/
         //System.out.println(path);// "src//cn//itcast//RegexTest//mail.txt" //实际执行的是bin目录下的
         File file = new File(path);

         //创建带缓冲区的读取流
         BufferedReader br = new BufferedReader(new FileReader(file));

         //定义正则表达式
         String regex = "\\w+@[a-zA-Z]+(\\.[a-zA-Z])+";

         //创建pattern对象，封装正则表达式
         Pattern p = Pattern.compile(regex);

         //读取文件中的数据
         String line =null;
         while((line=br.readLine())!=null)
         {
             //关联字符串
             Matcher m = p.matcher(line);
             //寻找匹配的字符串
             while(m.find())
             {
                 System.out.println(m.group());//获取匹配后的结果
             }
         }
     }
}