正则表达式

  正则表达式就是描述字符串的规则。jdk 内置正则表达式引擎：java.util.regex

  判断用户输入的年份是否是 19xx 年

  写法一：

package cn.itcast.order.pojo;

public class Demo {
    public static void main(String[] args) {
        String input = "1990";
        boolean is19xx = input.matches("19\d\d");
        System.out.println(is19xx);
    }
}

  写法二：

package cn.itcast.order.pojo;

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

public class Demo {
    static Pattern pattern = Pattern.compile("19\d\d");
    
    public static void main(String[] args) {
        Matcher matcher = pattern.matcher("1990");
        boolean matches = matcher.matches();
        System.out.println(matches);
    }
}

  写法二把正则表达式编译为 Pattern 对象，适用于反复使用这个正则表达式的情形

注意：

Java 字符串的正则表达式要多加一个 ，因为 也要转义正则表达式符号的大写与小写所代表的含义是相反的

  我们可以通过小括号进行分组，然后提取出每组的内容

  正则表达式：String regex = "^\d{3,4}\-\d{6,8}$";
  上面的正则表达式只能判断给定的字符串能否匹配，但是不能提取每个部分匹配的字符串，这时候就要用小括号来进行分组匹配：String regex = "^(\d{3,4})\-(\d{6,8})$";

  我们可以通过方式二的 Matcher.group(n) 来提取子串

package cn.itcast.order.pojo;

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

public class Demo {
    static Pattern pattern = Pattern.compile("^(\d{3,4})\-(\d{6,8})$");
    
    public static void main(String[] args) {
        Matcher matcher = pattern.matcher("010-12345678");
        if (matcher.matches()) {
            String whole = matcher.group(0); // 0 表示匹配整个字符串
            String firstString = matcher.group(1); // 1 表示匹配第一个带括号的子串
            String secondString = matcher.group(2); // 2 表示匹配第二个带括号的子串
            System.out.println(whole); // 010-12345678
            System.out.println(firstString); // 010
            System.out.println(secondString); // 12345678
        }
    }
}

  判断数字末尾 0 的个数

“123000”：3 个 0“10100”：2 个 0“1001”：0 个 0

  正则表达式默认使用贪婪匹配，尽可能多的向后匹配

package cn.itcast.order.pojo;

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

public class Demo {
    static Pattern pattern = Pattern.compile("^(\d+)(0*)$");

    public static void main(String[] args) {
        Matcher matcher = pattern.matcher("1230000");
        if (matcher.matches()) {
            String firstString = matcher.group(1);
            String secondString = matcher.group(2);
            System.out.println(firstString); // "1230000"
            System.out.println(secondString); // ""
        }
    }
}

  我们使用 ? 实现非贪婪匹配

package cn.itcast.order.pojo;

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

public class Demo {
    static Pattern pattern = Pattern.compile("^(\d+?)(0*)$");

    public static void main(String[] args) {
        Matcher matcher = pattern.matcher("1230000");
        if (matcher.matches()) {
            String firstString = matcher.group(1);
            String secondString = matcher.group(2);
            System.out.println(firstString); // "123"
            System.out.println(secondString); // "0000"
        }
    }
}

注意：? 既可以表示匹配 0 个或 1 个字符，也可以表示非贪婪匹配

  字符串的 split 方法，将一个字符串分割为数组

package cn.itcast.order.pojo;

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        String[] split1 = "a b c".split("\s");
        System.out.println(Arrays.toString(split1)); // [a, b, c]

        String[] split2 = "a b  c".split("\s+");
        System.out.println(Arrays.toString(split2)); // [a, b, c]

        String[] split3 = "a, b ; ; c".split("[\,\s\;]+");
        System.out.println(Arrays.toString(split3)); // [a, b, c]
    }
}

	private static final String regEx_script = "]*?>[\s\S]*?<\/script>"; // 定义script的正则表达式
    private static final String regEx_style = "]*?>[\s\S]*?<\/style>"; // 定义style的正则表达式
    private static final String regEx_html = "<[^>]+>"; // 定义HTML标签的正则表达式
    private static final String regEx_space = "\s*|t|r|n";// 定义空格回车换行符
    private static final String regEx_w = "]*?>[\s\S]*?<\/w[^>]*?>";//定义所有w标签