正则化学习总结

正则表达式

符合一定规则的表达式。(操作字符串的规则)

---

作用：用于专门操作字符串。
特点：用一些特定的符号来表示一些代码操作，这样就简化了书写。所以学习正则表达式，就是在学习一些特殊符号的使用。
好处：可以简化对字符串的复杂操作。
弊端：符号定义越多，正则越长，阅读性越差。

---

具体操作功能：
1、匹配：String类中的 matches()方法。用规则匹配整个字符串，只要有一处不符合规则就匹配结束，返回false
2、切割：String类中的 split()方法。
3、替换：String类中的 replaceAll()、replaceFirst()方法.
4、获取：Pattern类中的compile、matcher、find、group等一系列方法

---

1、匹配

String类中的matches()方法
boolean - matches(String regex);告知此字符串是否匹配给定的正则表达式。

class RegexDemo
{
    public static void checkTel()
    //练习：匹配手机号，手机号段只有13xxx 15xxx 18xxx
    {   BufferedReader bufr = null;
        try
        {
            bufr = new BufferedReader(new InputStreamReader(System.in));
            String tel = bufr.readLine();
            //String tel = "12911289129";
            String regex = "[1][358]\\d{9}";
            boolean b = tel.matches(regex);
            if(b)
                sop("tel:"+tel);
            else
                sop("手机号不匹配");
        }
        catch (IOException e)
        {
        }
        finally
        {
            if(bufr != null)
                try
                {
                    bufr.close();
                }
                catch (IOException e)
                {
                }
        }

    }
    public static void demo()
    {
        String str = "c1";

        String reg = "[a-zA-Z]\\d";//第一位字母，第二位数字

        boolean b = str.matches(reg);
        sop(b);
    }
    public static void checkQQ()
    {
        String qq = "1356944544";

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

        boolean flag = qq.matches(regex);
        if(flag)
            sop(qq+"---is OK!");
        else
            sop(qq+"---nonononono");
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

---

2、切割

1、String - split(String regex);
根据给定正则表达式的匹配拆分此字符串；
2、String - split(String regex,int limit);
根据匹配给定的正则表达式来拆分此字符串。

+ 表示出现一次或多次

不能用”.”来切割，因为被正则表达式(表示任意字符)占用，如果要用写作"\\."

为了可以让规则的结果被重用，可以将规则分装成一个组，用小括号()完成。
组的出现都有编号，从1 开始。想要使用已有的组，可以使用\\n 的形式获取，
n 就是组的编号。

(1(2(3))(4)) 有几个组看有几个左括号，第几个左括号就是第几组

正则表达式的弊端：符号定义越多，正则越长，阅读性越差。

class RegexDemo2
{
    public static void main(String[] args)
    {
        splitDemo("zhangsan  ,./\\  -lisi ,.,/,.,.   wangwu","[^a-zA-Z-]+");

        //splitDemo("zhangsan.lisi.wangwu","\\.");//用.切
        //splitDemo("C:\\abc\\a.txt","[^a-zA-Z.:]+");//用非字母、“.”以及‘:’切
        //splitDemo("C:\\abc\\a.txt","\\\\");//用\\切

        //splitDemo("erkkteeeeeyqqui","(.)\\1+");//用叠词切
    }
    public static void splitDemo(String str,String reg)
    {
        String[] arr = str.split(reg);
        sop(arr.length);
        for (String s : arr)
        {
            sop(s);
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

---

3、替换

替换：String - replaceAll(String regex,String replacement);
使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。

String - replaceFirst(String regex,String replacement);
使用给定的replacement替换此字符串所有匹配给定的正则表达式的第一个子字符串。

class RegexDemo3 
{
    public static void main(String[] args)
    {
        String str = "wer234tyu452342346ioui678op";
        //1、要求：将字符串中的连续超过5个的数字替换成#
        replaceAllDemo(str,"[0-9]{5,}","#");
        replaceAllDemo(str,"\\d{5,}","#");

        String str1 = "ereeeeetyfffffui";
        //2、要求：将叠词替换成$  $在正则化中是特殊符号
        replaceAllDemo(str1,"(.)\\1+","\\$");//不写\\会越界，$后面没有数字默认整个字符串

        //3、要求，将叠词替换成单个词  -- 用$n符号可以指定组中的第n组
        replaceAllDemo(str1,"(.)\\1+","$1");//newStr 为前面组中的第一个组

    }
    public static void replaceAllDemo(String str,String reg,String newStr)
    {
        String str2 = str.replaceAll(reg,newStr);

        sop(str2);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

---

4、获取

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

操作步骤：
1、将正则表达式封装成对象；
2、让正则对象和要操作的字符串相关联；
3、关联后，获取正则匹配引擎；
4、通过引擎对符合规则的子串进行操作，比如取出。

static Pattern - compile(String regex);
将给定的正则表达式编译到模式中。
static Pattern - compile(String regex，int flags);
将给定的正则表达式编译到具有给定标识的模式中。
int - flags();
返回此模式的匹配标志。
Matcher - matcher(CharSequence input);
创建匹配给定输入与此模式的匹配器。

其实String类中的matches方法其实就是用的Pattern和Matcher
方法完成的。只不过被String的方法封装后，用起来比较简单，
但是功能却单一了。

---

class RegexDemo4
{
    public static void main(String[] args) 
    {
        getDemo();
    }
    public static void getDemo()
    {
        String str = "ming tian jiu yao fang jia le , da jia";

        String reg = "\\b[a-zA-Z]{4}\\b";//\b 单词边界

        //1、将规则封装成对象。
        Pattern p = Pattern.compile(reg);

        //2、3、让正则对象和要操作的字符串相关联。获取匹配器对象
        Matcher m = p.matcher(str);

        //boolean b = m.find();//让规则作用到字符串上，并进行符合规则的子串查找
        //sop(b);
        //sop(m.group());//group()方法用于获取匹配后的结果**

        //4、通过引擎对符合规则的子串进行操作
        //sop("matches:"+m.matches());//同一个匹配器用的是同一个指针，
        //这样在匹配前调用匹配器的其他方法，会让下个方法开始时匹配器的指针不在初始位置，使结果错误。
        while (m.find())
        {
            sop(m.group());
            sop(m.start()+"---"+m.end());//获取子串的索引(指针)位置，包含头不包含尾
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}