正则表达式

正则表达式：　　是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则，有自己特殊的应用。

常用的如下：

字符类：

　　x x表示由一个字符所组成

　　\ \\表示转义字符“\”

　　\t              \t(制表符）表示一个“\t”符号

　　\n            \n表示换行符号

 

　　[abc] a或b或c

　　[^abc] 除了a、b、c之外的任意字符

　　【a-z】          a-z中的任一字符，小写字母；

　　[a-zA-Z] a-zA-Z中的任一字符，不区分大小写

　　[0-9]         表示任意的一位数字

 

预定义字符类：

　　.  任何一位字符 

　　\d  数字：[0-9] 

　　\D  非数字：[^0-9] 

　　\w  单词字符：[a-zA-Z_0-9] 

　　\W  非单词字符：[^\w] 

　　\s                   表示任一的空白字符，例如：\t  \n

　　\S                表示任一的非空白字符

 

边界匹配器（主要在js中使用）：

　　^ 行的开头

　　$ 行的结尾

　　\b   单词边界

例：

　　"I am here".matches("I\\b \\bam\\b \\bhere")

　　注意:边界所处的位置。

 

Greedy--数量表达式

　　X?  X，一次或一次也没有                   正则？  表示正则出现一次或者零次；

　　X*  X，零次、一次或多次 

　　X+  X，一次或多次 

　　X{n}  X，恰好 n 次 

　　X{n,m}  X，至少 n 次，但是不超过 m 次

 

代码示例：

package com.ibeifeng.regex;
public class RegexDemo2 {
    public static void main(String[] args) {
        /*
         * [abc]        a或b或c
         * [^abc]        除了a、b、c之外的任一字符
         * [a-zA-Z]    a-zA-Z中的任一字符
         */
        System.out.println("d".matches("[abc]"));
        System.out.println("a".matches("[^abc]"));
        System.out.println("aa".matches("[a-zA-Z]"));
        
        /*
         * \d
         * "\\"代表一个"\"
         * \w  0-9a-zA-Z_
         */
        System.out.println("a".matches("\\d"));
        System.out.println("~".matches("\\D"));
        System.out.println("0".matches("\\w"));
        
        /*
         * ^
         * $
         * \b
         */
        System.out.println("acbc".matches("^a\\w\\w\\w"));
        System.out.println("abcde".matches("\\w\\w\\w\\we$"));
        
        /*
         * ?  1次或0次
         * *  0次或多次
         * +  1次或多次
         * {n}    恰好N次
         * {m,n}    至少m次 至多n次
         */
        System.out.println("carsdff".matches("\\w*"));
        System.out.println("teacher".matches("\\w+"));
        System.out.println("abcq".matches("\\w{3}"));
        System.out.println("===================");
        System.out.println("I am here".matches("I\\b \\bam\\b \\bhere"));
        System.out.println("a".matches("."));
    }
}

代码示例(/检测邮箱的功能):

package com.ibeifeng.regex;
public class RegexDemo3 {
    public static void main(String[] args) {
        //匹配校验邮箱的正则表达式
        String s1 = "abcde@163.com";
        String s2 = "abcdefg@qq.com";
        String s3 = "adfdfw@sina.com.cn";
        String s4 = "fwef#com.cn.cn.cn";
        /*
         * .    \.
         * @    \@
         */
        System.out.println(s4.matches("\\w+\\@\\w+(\\.\\w{2,3}){1,2}"));
    }
}

分割功能：

范例：尝试输入一个年龄 显示是否是在范围内的合适年龄 提示大小

package com.ibeifeng.regex;
import java.util.Arrays;
import java.util.Scanner;
/*
 * public String[] split(String regex)
 */
public class RegexDemo5 {
    public static void main(String[] args) {
        //String age = “18-28”;
        //尝试输入一个年龄 显示是否是在范围内的合适年龄 提示大小
        String age = "18-28";
        String[] split = age.split("-");
        System.out.println(Arrays.toString(split));
        int min = Integer.valueOf(split[0]);
        int max = Integer.valueOf(split[1]);
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你需要的年龄的对象:");
        int nextInt = scanner.nextInt();
        if(nextInt > max){
            System.out.println("哈哈");
        }else if (nextInt < min) {
            System.out.println("儿童哦");
        }else {
            System.out.println("这里就有你想要的.");
        }
    }
}

替换功能：

package com.ibeifeng.regex;
import java.util.Arrays;
public class RegexDemo6 {
    public static void main(String[] args) {
    
        
        /*
         * public String replaceAll(String regex,
         *               String replacement)
         */
        //fuck f***  shit s***  cao c**
        String str5 = "Oh shit! cao! what a fucking weather, what are you fucking doing!";
        String replaceAll = str5.replaceAll("fuck", "f***")
                .replaceAll("shit", "s***")
                .replaceAll("cao", "c**");
        
        System.out.println(replaceAll);
        
        String str6 = "show me the money 999999";
        //数字替换掉 同一替换成*
        System.out.println(str6.replaceAll("\\d+", "*"));
        System.out.println(str6.replaceAll("\\d{3}", "*"));
    }
}

获取功能：

Pattern和Matcher类的使用

Pattern类：此类对象如果要想取得必须使用compile()方法，方法的功能是编译正则；

Matcher类：是通过Pattern类取得。

步骤：

　　1.通过编译规则得到模式Patterm;

　　2.通过模式匹配字符序列得到匹配器；

　　3.通过匹配器得到find,在group里获取。

　　

Pattern pattern = Pattern.compile(String regex);

Matcher matcher = pattern.matcher(String str);

while(matcher.find()){

String str = matcher.group();

}

 

package com.ibeifeng.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PatternDemo {
    public static void main(String[] args) {
    //获取由三个字符组成的单词
    //You may be out of my sight, but never out of my mind.
        String s = "You may be out of my sight, but never out of my mind";
        //1.根据正则表达式创建模式Pattern
        Pattern pattern = Pattern.compile("\\b\\w{3}\\b");
        //2.通过模式匹配字符序列得到匹配器
        Matcher matcher = pattern.matcher(s);
        //3.通过匹配器find,在group里获取
        int num = 0;
        while(matcher.find()){
            String group = matcher.group();
            int start = matcher.start();
            int end = matcher.end();
            System.out.println(group);
            System.out.println(start+"==="+end);
            num ++;
        }
        System.out.println(num+"次");
        
        /*matcher.find();
        String group = matcher.group();
        System.out.println(group);
        
        matcher.find();
        group = matcher.group();
        System.out.println(group);*/
    }
}