正则表达式

package com.yyq;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Arrays;
import java.util.TreeSet;
import java.util.regex.*; 
/*
 *     重要的，必须掌握的 校验。
 *  对邮件地址的校验。。
 *  网页爬虫（蜘蛛）
 *  
 */
/*
 * 正则表达式的功能。
 * 1.匹配：matches() 真假
 * 2.切割：split() 切割后的
 * 3.替换：replace replaceAll() 替换后的
 * 4.获取： 将字符串中的符合规则的字串取出
 * 1，  将正则表达是封装成对象。
 * 2， 让正则对象和要操作的字符串相关联
 * 3， 通过引擎对符合规则的字串进行操作，比如取出。
 * 其实 string类中的matches 方法，用的就是pattern 和Matcher
 * 对象来完成的，只不过被string方法封装后，用起来较为简单，但是功能却单一。
 *
 * 
 * 正则表达式： 符合一定规则的表达式。
 * 作用：用于专门操作字符串
 * 特点： 用于一些特定的符号来表示一些代码操作。这样就简化书写。
 * 学习正则表达式 就是学习符号的使用。
 *  matches 方法： 用规则匹配整个字符串，只要有一次不匹配，返回false
     好处：简化对字符串的复杂操作
     弊端：阅读性差
 */
/*
 *     对QQ号码进行校验，
 * 要求;5-15 0 不能开头，只能是数字
 * 具体操作功能： 匹配： string matches 方法
 * [] 校验的特点： 只校验一个位置上的字符，
 * [a-zA-Z] 所有字符。
 * [a-z&&[^m-p]]
 * [a-z&&[^bc]]
 * 字符类 
        [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]（减去） 
          
        预定义字符类 
        . 任何字符（与行结束符可能匹配也可能不匹配） 
        \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 次 
        特殊构造（非捕获） 
        (?:X) X，作为非捕获组 
        (?idmsux-idmsux)  Nothing，但是将匹配标志i d m s u x on - off 
        (?idmsux-idmsux:X)   X，作为带有给定标志 i d m s u x on - off 
        的非捕获组  (?=X) X，通过零宽度的正 lookahead 
        (?!X) X，通过零宽度的负 lookahead 
        (?<=X) X，通过零宽度的正 lookbehind 
        (?<!X) X，通过零宽度的负 lookbehind 
        (?>X) X，作为独立的非捕获组 
    边界匹配器 
    ^ 行的开头 
    $ 行的结尾 
    \b 单词边界 
    \B 非单词边界 
    \A 输入的开头 
    \G 上一个匹配的结尾 
    \Z 输入的结尾，仅用于最后的结束符（如果有的话） 
    \z 输入的结尾 
 */

public class MyDemo {
    private static String ss = "1111qqq11111111";
    public static void main(String[] args) throws Exception {
        //splitDemo();
        //String str = "aaaaadddffdfdfsdddfaffqwerqsddddafaf"; // 将叠词替换成#号
        //replaceAllDemo(str,"(.)\\1+","$1");  // 将多个变成一个， 获取组 使用$符号
        // 拿前一个第一个组 $1 没有大括号
        //String str = "wer4564664646ssdffff4646546466dddf46498ddd54"; // 将叠词替换成#号
        //replaceAllDemo(str,"\\d{5,}","#");
        //checkMain();
        getMails();
    }
    // 到底用四种功能中的哪一个呢？ 或者使用哪几个呢？？
    // 1.匹配：判断对错
    // 2.替换
    // 3.切割： 获取规则以外的字串
    // 4.获取：获取符合规则的字串。
    
    // 192.068.001.254 102.049.023.013 10.10.10.10 2.2.2.2 8.109.90.30
    // 将ip 地址进行地址段顺序的排序。
    // 还按照字符串自然顺序，只要让他们每一段都是3位即可
    /*
     * 1. 按照每一段需要的最多的0进行补齐，那么每一段就会至少有三位。
     * 2. 将每一段只保留三位，这样所有的ip地址都是每一段三位。
     */
    // 对邮件地址的校验
    public static void checkMain(){
        String mail = "1015604150@qq.com.cn.abc";
        // 较为精确的匹配。
        String reg = "[a-zA-Z0-9_]{6,12}@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";
        //相对不精确的匹配。
        //reg = "\\w+@\\w(\\.\\w)+";
        System.out.println(mail.matches(reg));
    }
    public static void test_2(){
        String ip = "192.068.001.254 102.049.023.013 10.10.10.10 2.2.2.2 8.109.90.30";

        ip = ip.replaceAll("(\\d+)", "00$1");
        ip = ip.replaceAll("0*(\\d{3})", "$1");
        ip = ip.replaceAll("0*(\\d+)", "$1");
        String [] arr = ip.split(" +");
        /*Arrays.sort(arr);  // 数组排序。
        for(String s : arr){
            System.out.println(s);
        }*/
        TreeSet<String> ts = new TreeSet<String>();
        for(String s:arr){
            ts.add(s);
        }
        for(String s : ts){
            System.out.println(s);
        }
    }
    public static void test_1(){
        String str = "我我...........我我要...要要...学学学....编编编.编..程....程";
        /*
         * 操作： 替换 将一个字符串编程另一个字符串。
         * 1.先将点去掉
         * 2.将重复内容编程单个内容。
         */
        str = str.replaceAll("\\.+", "");
        
        // 去除叠词  （.）\\1+
        str = str.replaceAll("(.)\\1+", "$1");
        System.out.println(str);
    }
    // 按照叠词进行切割。
    public static void splitDemo(){
        //String str = "zhangsan.lisi.wangwu";
        //String reg = "[ ]+"; // 按照多个空格来进行切割。
        //String reg = "\\."; // 按照. 进行切割
        //String str = "C:\\abc\\a.txt";
        //String reg = "\\\\";
        String str = "abcaaaaabccdef";
        String reg = "(.)\\1+"; // 叠词进行切割  (要重用的部分叫做组 使用 （） 包含，从1 开始编号。) (.)\\1
        // 为了可以让规则的结果可以被重用，可以将规则封装成一个捕获组，用（）完成，组的出现都有编号，//
        // 从1开始，想要使用已有的组可以通过\\n 来使用组。
        
        String [] arr = str.split(reg);
        for(String s:arr){
            System.out.println(s);
        }
    }
    public static void checkTel(){
        //匹配手机号段 15***，13***，18***
        String str = "18753377360";
        String regex = "[1][538]\\d{9}";
        if(str.matches(regex)){
            System.out.println("手机号正确");
        }
        else{
            System.out.println("手机号错误");
        }
    }
    public static void demo(){
        String str = "b1111";
        //该只能校验两个位置。
        String reg = "[a-zA-Z]\\d+";
        boolean b = str.matches(reg);
        System.out.println(b);
    }
    public static void checkQQ_2(){
        String qq = "9188536";
        String regex = "[1-9]\\d{4,14}";
        if(qq.matches(regex)){
            System.out.println("it is ok!!!");
        }
        else{
            System.out.println("youw");
        }
    }
    public static void checkQQ(){
        String qq = ss;
        int len = qq.length();
        System.out.println(qq.length());
        if(!(len>15 || len<5)){
            if(!qq.startsWith("0")){
                try{
                    long l = Long.parseLong(qq);
                    System.out.println("qq:" + l);
                }
                catch(NumberFormatException e){
                    
                }
                /*char[] arr = qq.toCharArray();
                boolean b = false;
                for(int x = 0;x<arr.length;x++){
                    if(!(arr[x]>='0' && arr[x]<='9')){
                    
                        b = true;
                        break;
                    }
                }
                if(!b){
                    System.out.println("qq:"+qq);
                }
                else{
                    System.out.println("QQ号中出现了非法字符");
                }
            
            */
            }
            else{
                System.out.println("不可以0开头");
            }
        }
        else{
            System.out.println("密码长度不正确。");
        }
    }
    public static void replaceAllDemo(String str,String reg,String newChar){
        str = str.replaceAll(reg, newChar);
        System.out.println(str);
    }
    
    public static void getDemo(){
        String str = "ming tian jiu yao fang jia le";
        String reg = "\\b[a-zA-Z]{4}\\b";
        //str = "123456789";
        //String reg ="[1-9]\\d{4,14}";
        //1. 将正则表达式封装成对象。
        Pattern p = Pattern.compile(reg);
        //2.让正则对象和要作用字符串相关连。 获取匹配器对象。
        Matcher m = p.matcher(str);
        //m.find();  // 将规则作用到字符串上，并进行符合规则的查找。
        //m.find();
        //System.out.println(m.matches());
        // group() 方法，用于获取匹配后的结果。
        // 只有找了，才能去。
        while(m.find()){
        System.out.println(m.group());
        }
    }
    // 编写网络爬虫  
    /*
     * 使用获取功能  使用pattern 和matcher
     *  爬网页上的
     */
    public static void getMails() throws Exception{
        BufferedReader bufr = new BufferedReader(new  FileReader("E:\\myjavaee\\aaa\\mail.txt"));
        String line = null;
        //1.编写正则表达式
        String reg = "[a-zA-Z0-9_]{6,14}@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";
        //2.将正则表达式封装成对象
        Pattern p = Pattern.compile(reg);
        
        while((line = bufr.readLine())!=null){
            Matcher m = p.matcher(line);
            while(m.find()){
                System.out.println(m.group());
            }
        }
    }
}