正则表达式初级入门【原】

java正则表达式 pattern基本语法

其它参考: oracle正则表达式

 

参见百度百科

import java.util.regex.*;

 1 import java.util.regex.*;
 2 
 3 Pattern p = Pattern.compile("[a-z]{3}"); //编译后要匹配的模式
 4 Matcher m =p.matcher("abc");
 5 soup(m.matches());// matches匹配整个字符串
 6 soup("abc".matches("[a-z]{3}");//该种方式没有编译，处理时会较慢
 7 
 8 ？0->1个字符   . 1个字符  * 0->多个字符   + 1->多个字符
 9 soup("".matches("a?") && "".matches("a*")); //true,0宽度匹配.
10 "^[abc]"=>以abc其中之一开头   (开头)     
11 "[^abc]"=>取除了abc三个字符之外的字符  (取反)
12  \\w   等于   "[a-zA-Z_0-9]"      
13  \\d 等于[0-9]      \D 等于 [^0-9]
14     "\\".matches("\\\\"); //true
15    \\代表一个\       前面两个\\成为一个\  , 后面两个\\也成为一个\，然后因为在字符串中\\两个再转义成\
16 \\s 等于[\t\n\r\f]
17 soup("     \n".matches("^[\\s&&[^\\n]]*\\n$"); {开头是除\n外的空格字符 结尾是\n} $表示结尾 ,用来检测该行是不是空白行
18 \\b 单词边界 如abc def-ghi   (cd之间 fg之间就是\b)
19 soup("Hello sir".matches("^H[a-z]o\\b.*")//true
20 soup("Hellosir".matches("^H[a-z]o\\b.*")//false
21 "a|bc|def" //包含a或包含bc或包含def

 

另附javascript js 正则表达式样例 : js正则表达式【原】==>https://www.cnblogs.com/whatlonelytear/p/6305950.html  总体正则语法相近,但不完全相同,仅作入口,不值得参考.

我的正则使用日记

import java.util.regex.*;
public class Pattern_Test {
    public static void main(String[] args) {
        pattern20170302();
        pattern1();
        pattern2();
        pattern3();        
        pattern4();    
    }    

    public static void pattern20170302(){
        Pattern p = Pattern.compile("小区|幢|楼 ");
        Matcher m = p.matcher("abc123小区456def");
        System.out.println(m.find());
    }

    public static void pattern1(){
        Pattern p  = Pattern.compile("\\d{3,5}");
        Matcher m = p.matcher("012A45678B9");
        System.out.println(m.matches());
        m.reset();
        while(m.find()){
            System.out.println(""+m.start() +"->"+ (m.end()-1));
        }
    }    
    public static void pattern2(){
        Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);
        String str ="jaVa_JaVa_JAVa_jAVA_abc";
        Matcher m = p.matcher(str);
        StringBuffer sb = new StringBuffer();
        int number = 0;
        while(m.find()){
            number ++;
            if(number % 2 == 0){ //偶号全改成java
                m.appendReplacement(sb,"java");
            }else{ //奇号全改成JAVA
                m.appendReplacement(sb,"JAVA");
            }// 将该次匹配的替换成指定字符串"JAVA"后,
            // 再将上一次匹配的m.end()到这一次匹配的m.end()-1的这一段字符添加到sb中
        }
        m.appendTail(sb); //将最后一次匹配的m.end()到末尾全添加到sb中
        System.out.println(sb);
//        m.reset();
//        System.out.println( m.replaceAll("JAVA") );//全替换成 JAVA
    }    
    public static void pattern3(){
        Pattern p = Pattern.compile( "(\\d{3,5})([a-z]{2})" );
        Matcher m =p.matcher("123aa-34567bb-189cc-00");
        while(m.find()){
            System.out.println(m.group(0));
        }
        m.reset(); System.out.println("_____________________");
        while(m.find()){
            System.out.println(m.group(1));
        }
        m.reset(); System.out.println("_____________________");
        while(m.find()){
            System.out.println(m.group(2));
        }
    }
    public static void pattern4(){
        Pattern p1 = Pattern.compile(".{3,10}[0-9]");//Greedy
//默认贪婪的:  先直接取10个,aaaa5bbbb7| 不匹配,吐一个aaaa5bbbb|7匹配了,于是0 start->10 end
        Pattern p2 = Pattern.compile(".{3,10}?[0-9]");//Reluctant
//不情愿,勉强的:  先取aaa 3个,不匹配,吃一个aaaa 4个还不匹配,再吃一个aaaa5        
        Pattern p3 = Pattern.compile(".{3,10}+[0-9]");//Possessive
//独占的:  直接全取aaaa5bbbb6不吐出来,故not match
//                    0123456789  
        String s = "aaaa5bbbb7";
        Matcher m = p2.matcher(s);
        if(m.find()){
            System.out.println(m.start()+"--->"+m.end());
        }
    }

　　
}

 

正则表达式匹配带换行符的情况

可使用  [\s\S]*   [\d\D]*    [\w\W]*   等去匹配.哈哈

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

public class Pattern_R_N {
    public static void main(String[] args) {
        //$$$$$匹配包括换行符在内的任意字符
        String arg = "\r\n123abc\r\n456\r\ndef";
        
        String regex1 = "([\\s\\S]*)" ;//重点,尽量用这种
        Pattern p1 = Pattern.compile( regex1 );
        Matcher m1 =p1.matcher(arg);
        if(m1.find()){
            System.out.println(m1.group(1));
        }else{
            System.out.println(regex1+"未匹配到"+arg);
        }
        System.out.println("____________________________________");
        String regex2 = "(.*)*" ;
        Pattern p2 = Pattern.compile( regex2);
        Matcher m2 =p2.matcher(arg);
        if(m2.find()){
            System.out.println(m2.group(1));
        }else{
            System.out.println(regex2+"未匹配到"+arg);
        }
    }
}

 

正则表达式替换 >   < 中的空格

main方法,这个正则"(?<=>)\\s+(?=<)"到目前为止本人仍无法理解

    public static void main(String[] args) {
        String content = "1   2      3 ";
        content = content.replaceAll("(?<=>)\\s+(?=<)", "");
        System.out.println(content);
    }

结果

1 2 3 

 

 

正式表表达式替换所有特殊字符成空格

main方法

public static void main(String[] args) throws Exception {
        Pattern pattern = Pattern.compile("[`~!@#$%^&*()+=|{}':;]");
        String content = "a`b~c!d@e#f$g%h^i&j*k(l)m+n=o|p{q}r's:t;u";
        Matcher matcher = pattern.matcher(content);
        String result= matcher.replaceAll(" ").trim();
        System.out.println(result);
    }

 结果:

a b c d e f g h i j k l m n o p q r s t u

 

正则表达式(从oracle提取时的)奇葩问题 :

假如我们要把正则表达式放到oracle数据库里,想用的时候再提取出来,那么问题来了....

前题:你已经把标准的java正则表达式放在oracle中如下(非打印语句,而是调试时内容)

requestHead\"\\s*:.*userId\"\\s*:\\s*\"(.+?)\" 

然而当我们用java程序从oracle中select提取出来的时候,却变成如下:(非打印语句,而是调试时内容)

requestHead\\"\\\\s*:.*userId\\"\\\\s*:\\\\s*\\"(.+?)\\"  

应该是被转义了.

所以我们为了能正确使用,我们需要做如下替换:

format = format.replace("\\\\", "\\");

以上语句中第一个参数"\\\\"是pattern表达式,所以\\代表\, 于是\\\\代表\\ ,

而上语句中第二个参数"\\"是普通String,所以\\代表\,

最终上条语句的意思是,把真实内容中的\\都替换成\  

在理解以上情景时请以调试时的红框中内容为标准,而非System.out.println()时打印出来的内容为标准

 

知识进阶

Java正则表达式匹配模式[贪婪型、勉强型、占有型]

java正则表达式高级用法

正则表达式匹配解析过程探讨分析(正则表达式匹配原理)            浅析正则表达式—（原理篇）

你真的会用java replaceAll函数吗

public static void main(String[] args) {
        System.out.println("--1pp2pp3yy  4--".replaceAll("(.*)|(.*)|(.*)", "$1$2$3")); //bbcc
        //打印:    --1pp2pp3yy  4--
    }

 

后言

正则表达式在处理字符串上确实强大又灵活,但在高并发的压力下,可能还是避免使用,尽量手动自己写字符串处理.

高压力下正则表达式的性能瓶颈

java正则判断是否是数字（浮点数和整数）

转载于:https://www.cnblogs.com/whatlonelytear/p/5056472.html