java正则表达式

一、正则表达式基本规则

package org.mytest;


import java.util.Arrays;
//java.util.regex正则表达式工具包
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;



public class Test {


    //正则表达式就是字符串, java用regex标识
    //字符串的 matches方法可以接收正则表达式
    public static void test1() {

        //正则表达式就是字符串
        //字符串的 matches方法可以接收正则表达式
//        案例1
        //3个字
        System.out.println("三个字案例");
        String str = "1234";
        String str2 = "...";//.在正则表达式的规范就是任意一个字符
        System.out.println(str.matches(str2));
        System.out.println("123".matches(str2));


        System.out.println("手机号案例");
        //案例2
        //判断是否是手机号
        //定义字符串匹配规则
//        String pattern = "1[3,5,8]\\d{9}";//[]里面不要乱添加,分割符。错误
        String pattern = "1[358]\\d{9}";//正确
//        String pattern = "1[358][1-9]{9}";//另外的正确写法
        System.out.println("1,382557144".matches(pattern));//false,如果pattern[]里面有空格就是true
        System.out.println("12346578987".matches(pattern));//true

        System.out.println("汉字案例");
        //案例3
        //判断字符串中有没有汉字
        // 以\开始的字符就是转义字符。\u是字符的另一种十六进制写法，是Unicode字符集，可以表示所有世界各国文字 "\u9fa5" 是java的Unicode 转义字符，后面跟4位16进制数，表示一个4位16进制的一个整数
        //0x4e00 - 0x9fa5 就是汉字的值的范围。  编码格式 unicode（不要研究）
//        pattern = "[\u4e00-\u9fa5]*";//全是中文吗？ 空字符也算。若有字符必须是中文。
//        pattern = ".*[\u4e00-\u9fa5].*";//有中文就行
//        pattern = "[\u4e00-\u9fa5]]{1,}";//全是中文，不能为空
        pattern = "[\u4e00-\u9fa5]]+";//全是中文，不能为空

        System.out.println("hello中国!".matches(pattern));
        System.out.println("你好".matches(pattern));
        System.out.println("".matches(pattern));
        //案例4
        //要求账号的姓名要么全中文，要么全英文，不能有其它特殊符号
        String name = "张三李四王五";
        name = name.trim();//清除两边空格

        if(name.matches("[\u4e00-\u9fa5]{2,6}|[a-zA-Z]{2,20}")){//方式1，正则表达式可以有逻辑运算|或者
            //还是不要随意添加空格。没有分割符
            //作用是：两边的正则表达式满足其一就行
            //        if(name.matches("[\u4e00-\u9fa5]{2,6}")||name.matches("[a-zA-Z]{1,20}")){//方式2
            System.out.println("命名正确");
        }
        else{
            System.out.println("命名错误");
        }

        //总结
        //1、不要随意添加分隔字符，每一个字符都是有用的。
        //2、 正则表达式有逻辑或运算
        //详细规则如下：
        System.out.println("单个字符练习案例");

        //非运算
        //不是A，
        pattern = "[^A]";
//        pattern = "^A";pattern = "^[A]";//^表示开始，正好意义相反了
        System.out.println("a".matches(pattern));
        System.out.println("A".matches(pattern));
        //不是[A-Z]
        pattern = "[^A-Z]";
        System.out.println("T".matches(pattern));
        System.out.println("t".matches(pattern));
        //^ -运算符需要写到里面
        //^最后运算

        //或者运算符
        //a-z或者A-Z
        //方式一
        pattern  = "[a-zA-Z]";
        System.out.println("m".matches(pattern));
        System.out.println("M".matches(pattern));
        System.out.println("0".matches(pattern));
        //方式二
        pattern = "[a-z]|[A-Z]";
        System.out.println("m".matches(pattern));
        System.out.println("M".matches(pattern));
        System.out.println("0".matches(pattern));

        //java中的转义字符练习
        //表示空格--java里面 \s就是空格space
        pattern = "\s";

        System.out.println(" ".matches(pattern));
        System.out.println("java中\\s到底是什么：你好啊\s张三");
        // "\s"就是一个空格的字符串


        //1、总结正则表达式需要首先遵守java语言的字符串规范。
                //1.转义字符会自动转义--java字符串规范
                //2.最终的结果遵守正则表达式规范
                     // 正则表达式也有自己的转义字符，同样用\作为开始
                //总而言之，正则表达式要用转义字符，必须写两个\\,一个不够
        //验证1
//        System.out.println("\w");//java中的非法转义符
        pattern = "\\w";//java中表示字符串 \w  正则表达式中表示表示任意的一位字母或数字
        System.out.println("1".matches(pattern));//true
        System.out.println("a".matches(pattern));//true
        System.out.println("A".matches(pattern));//true
        System.out.println("".matches(pattern));//false

        pattern = "\\s";//java中表示字符串 \s 正则表达式该字符串表示一位空格
        System.out.println(" ".matches(pattern));//true
        System.out.println("a".matches(pattern));//false

        //验证2 正则表达式转义字符的大写就是逻辑非
        System.out.println("z".matches("\\S"));//true
        System.out.println(" ".matches("\\D"));//true

        System.out.println("多个字符练习案例");
        //练习多个字符串
        //每个字符都是a-z， *就是任意个数的意思
        pattern = "[a-z]*";
        //不能为空,+就是至少一个的意思等同于{1,}
        pattern = "[a-z]+";
        //0个或1个小写字母
        pattern = "[a-z]？";
//        pattern构造是私有的 ，我们不能new，别人帮我们new
        //{}表示个数的意思，
        pattern = "[a-z]{10}";
        //，分割上下界 相当于+
        pattern = "[a-z]{1,}";
        //字符个数闭区间[1,10]
        pattern = "[a-z]{1,10}";

        //总结
        //3.不存在二义性，运行可能出现异常，因为不符合定义规范。

        //[]{}里面参数不能为空
        //正则表达式在遵守java字符串规则后，发现不遵守自己的规则，于是出现异常。
      //异常1  java.util.regex.PatternSyntaxException
//        pattern = "[a-z]{}";
//        System.out.println("a{}".matches(pattern));

        //异常2  java.util.regex.PatternSyntaxException
//        pattern = "[]";
//        System.out.println("[]".matches(pattern));
        //异常原因：因为若[]里面是空的，[]代表[]里面的任意一个字符，这没有啊，{}里面是空的，个数没法确定了。
        //异常3  java.util.regex.PatternSyntaxExceptio
//        pattern = "\\";
//        System.out.println("\\".matches(pattern));
            //异常原因：符合java字符串语法要求，但是不符合正则表达式语法要求。没法转移啊，类似异常1，和异常2


        //最后正则表达式的开始和结束标识^和$练习

        System.out.println("liu".matches("^liu"));//true --自动跳过了开始标识^
        System.out.println("liu".matches("liu$"));//true --自动跳过了结束标识$
        System.out.println("liu".matches("^liu$"));//true --自动跳过了开始和结束标识
        System.out.println("liu".matches("liu"));//true--不添加也可
        System.out.println();
        //开始和结束标识说明了是正则表达式，不是普通字符串，这点在java中没有体现。
        //没有必要，因为java自动认定为正则表达式，正则表达式大部分情况下兼容字符串。
        // 下面是不兼容的一个情况。
        //如果开始或结束标识不在相应位置，那么是错误的正则表达式。
        pattern = "l^i$u";
        pattern = "^l^i$u$";//我就算加了开始和结束也是不正确的，匹配不到
//        pattern = "^l\\^i\\$u$";//这样写，下面的"l^i$u"情况是对的。想要开始和结束出现中间，必须转义

        System.out.println("i".matches(pattern));//false
        System.out.println("l^i$u".matches(pattern));//false

        System.out.println("l".matches(pattern));//false
        System.out.println("u".matches(pattern));//false
        System.out.println("li".matches(pattern));//false
        System.out.println("iu".matches(pattern));//false
        System.out.println("liu".matches(pattern));//false

        System.out.println("l^iu".matches(pattern));//false
        System.out.println("li&u".matches(pattern));//false
        System.out.println("l^i&u".matches(pattern));//false

        System.out.println("^liu".matches(pattern));//false
        System.out.println("liu&".matches(pattern));//false
        System.out.println("^liu&".matches(pattern));//false

        System.out.println("^l^i&u&".matches(pattern));//false
        System.out.println("^l^iu&".matches(pattern));//false
        System.out.println("^l^i&u&".matches(pattern));//false

        System.out.println("正则表达式训练结束");
        System.out.println("使用正则表达式开始：");
        //案例一
        //将字符串分割成多个字符串。
        //"java,php,mysql,javascript,c/c++"可以通过字符串split操作分割成多个字符串数组。
        String str1 = "java,php,mysql,javascript,c/c++";
        String[] ch = str1.split(",");
        System.out.println(Arrays.toString(ch));

        //那么 "java123php456mysql789javascript567c/c++"怎么分割
        str1 = "java123php456mysql789javascript567c/c++";//[java, php, mysql, javascript, c/c++]


        //字符串split方法可以接收正则表达式作为分隔符。
                //那么要注意普通字符串和正则表达式不能冲突的问题。这不是我们考虑的，用就行了。

//        ch = str1.split("//d+");//低级错误，//不是转义字符
        ch = str1.split("\\d+");//错误了因为不是转义字符

        System.out.println(Arrays.toString(ch));//[java, php, mysql, javascript, c/c++]

        //理解贪婪模式
        //分组非常妙 -- 反向理解 ->正向理解
        //换名
        //找所有的合适的字符串
        //把他人的项目作者改为自己

        //什么是贪婪模式--
        //在字符匹配的时候
        //我想要  (zhangsan)(java)(lisi)  加括号是为了分组,更加清晰

        //我这样写正则表达式
        pattern = ".*java.*";
        str1 = "zhangsanjavalisi";
        str2 = "http:127.0.0.0:8080/www.taobao.ui.zhangsanjavalisi.com";
        System.out.println(str1.matches(pattern));
        System.out.println(str2.matches(pattern));
    }




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

    //深入理解正则表达式
    //java.util.regex包主要包含以下三个类
    //Pattern类：模式类，
    //ma 匹配器类


    public static void test(){

        Pattern p = Pattern.compile("\\d?");//模式类，返回是一个Pattern
        //私有的，其它任何人都不能new，类可以new。
        Matcher m = p.matcher("a");
        System.out.println(m.matches());//false
        System.out.println(m.find());//true

        //把姓李的人的名字列出来
        String str = """
                李四，java
                1234王五1234，李武，李留
                ，李六七八九sir
                """;
//        p = Pattern.compile("李.{1,2}");//错误 名字应该是中文
//        p = Pattern.compile("李[\u4e00-\u9fa5]*");//错误 性李的名字长度应该2-3
        p = Pattern.compile("李[\u4e00-\u9fa5]{1,2}");//正确

        m = p.matcher(str);
        //输出所有姓李的人 ，类似集合遍历
        //find()作用
        // 一方面是看看有没有元素，
        // 另一方面后移一位元素，方便group()方法使用。
        //group()作用
        //返回当前匹配的结果，
        while(m.find()){
            System.out.print(m.group()+" ");//输出结果 ：李四 李武 李留 李六七
        }
        //这个答案，李六七算是半对。可以认为这是名字，也可以认为不是。

        //1-9要求 按顺序数字顺序写成一个式子
        // 如 1+23-45+67+8-9
        // 使得结果为 100

        //方法1
        //如果告诉你一个式子，让你计算怎么办
        str = "1+23-4+56-89";
        //正解：
        //使用正则表达式，1.分割整数，2为整数添加符号
        //使用 Matcher 遍历 拿到所有符合的字符串
        p = Pattern.compile("-?\\d+");

        m = p.matcher(str);

        while (m.find()){
            System.out.print(m.group()+" ");//1 23 -4 56 -89
            //这样就有符号了 ，可以将String变为Integer
        }
        
        //剩下问题就是构造，str
        //Str是随机的，比较简单，但是会重复
        //Str按照顺序来，
        // 1-9，正负号
        Random  random = new Random();
        //我想着用StringBuilder添加随机的数据
//        char[] ch = new char[] {' ','-','+'};//错误 ，只能1位一位的
        String[] ch = new String[] {"","-","+"};//需要空字符，用于连接两个数字

        int sum;
        while(true){
            sum = 0;
            //生成一个字符串。
//            StringBuilder sb = new StringBuilder();
            StringBuilder sb = new StringBuilder("1");//需要从1开始
            for(int i=2; i<=9; i++){
                //随机
//                sb.append(ch[random.nextInt(3)]);
//                sb.append(('0'+i));
                sb.append(String.format("%s%d",ch[random.nextInt(3)],i));
            }
            //构造输出str
            str = sb.toString();
            p = Pattern.compile("-?\\d+");//自动把+去掉了，但是不影响符号
            m = p.matcher(str);
            while (m.find()){
                sum += Integer.parseInt(m.group());
            }
            if(sum==100){
                System.out.println(str);
                break;
            }
        }
    }
}

二、 正则表达式贪婪模式和分组

package before;
//练习贪婪模式

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
    //什么是贪婪模式
    //1.在正则表达式字符个数是一定范围时，默认按最多匹配原则，
    //也就是，如果范围是[1,10]。10个字符匹配的就按10个，10个不匹配，按9个....最后才按1个
    //这用现象叫做贪婪模式
    //禁用贪婪
    //1.在正则表达式字符个数一定范围时，默认按最少匹配原则，
    public static void test1(){
        //不贪婪,只有一个，或者最多一个
        System.out.println("java123mysql6php".replaceAll(".*","-"));
        //"--"
        System.out.println("java123mysql6php".replaceAll("","-"));
        //-j-a-v-a-1-2-3-m-y-s-q-l-6-p-h-p-
        System.out.println("java123mysql6php".replaceAll(".*?","-"));
        System.out.println("java123mysql6php".replaceAll("\\d+?","-"));
        System.out.println("java123mysql6php".replaceAll("\\d","-"));
        System.out.println("java123mysql6php".replaceAll("\\d{1,}?","-"));
        //-j-a-v-a-1-2-3-m-y-s-q-l-6-p-h-p-
        System.out.println("java123mysql6php".replaceAll("\\d+","-"));
        /*
java---mysql-php
java---mysql-php
java---mysql-php
java-mysql-php
        * */
    }

    //案例一：打印出<div>标签有java</div>
    //易错点,模式匹配
    //关闭贪婪模式
    //贪婪模式结论
    //找到的字符串一定符合Pattern模式要求
    //1、没有公共部分，不能往回找.
    //2、符合正则表达式的要求
    //3、字符串匹配顺序为：从前往后,不论是否关闭贪婪，都是这个顺序，
    //4、关闭贪婪就是在{1,n}范围尽可能少的找，贪婪模式尽可能多的找

    public static void test2(){
        String str = """
                <div>hello</div><div> java15 </div><div><p>   java 15</p><span> java8 </p><div>    java 15</div></div>
                """;
        Pattern p = Pattern.compile("(<div>[^<]*?)(java)([^>]*?</div>)");//规定了不选什么
//        Pattern p = Pattern.compile("<div>[\\w ]*?java[\\w ]*?</div>");//规定了选哪些值
        //其它错误
//        Pattern p = Pattern.compile("<div>.*?java</div>");
        //无
        //[ ]

//        Pattern p = Pattern.compile("<div>(.{0,5}?)(java).*?</div>");//深刻理解控制区间。
//        Pattern p = Pattern.compile("<div>(.*?)(java).*?</div>");
        //结果
        //<div>hello</div><div>java15</div>
        //<div><p>java 15</p><span>java8</p><div>java 15</div>
//        Pattern p = Pattern.compile("<div>java.*?</div>");
        //<div>java15</div>
        //<div>java 15</div>
//        Pattern p = Pattern.compile("<div>[\\w ]+?java[\\w ]+?</div>");//{1,} {0,1}有区别
        //无
//        Pattern p = Pattern.compile("<div>[\\w ]*?(java)[\\w ]*?</div>");//可以添加括号
        //<div>java15</div>
        //<div>java 15</div>
        /*
         * <div>hello</div><div>java 15</div>
<div><p>java 15</p><span>java8</p><div>java 15</div>
         */
        Matcher m = p.matcher(str);
        while(m.find()){
            System.out.println(m.group());
        }
    }

    //()括号，分组
    //1.有利于模式匹配；更加清晰.容易理解
    //2.有利于结果操作；可以批量修改.方便修改，
    public static void test3(){
        String str = """
                <div>hello</div><div> java15 </div><div><p>   java 15</p><span> java8 </p><div>    java 15</div></div>
                """;
        //只将<div>标签中的java替换为abc

        Pattern p = Pattern.compile("(<div>[^<]*?)(java)([^>]*?</div>)");
        Matcher m = p.matcher(str);
        //替换原来的字符串，返回字符串。
        String t = m.replaceAll("$1abc$3");
        System.out.println(t);
    }

    public static void main(String[] args) {
        test2();
    }
}

 1.能用普通字符串解决的不用正则表达式。

 

 

2022/9/17

正则表达式运算符使用

1.字符串startWith不支持正则表达式

12356开头或者 12456开头可以这样写

String pattern = "12(3|4)56.*";
System.out.println("123565464".matches(pattern));