자바 정규 표현 식, 당신 은 얼마나 알 고 있 습 니까?

머리말
정규 표현 식 은 일반적으로 문자열 일치, 문자열 찾기 와 문자열 교체 에 사 용 됩 니 다.그 역할 을 얕 보지 마라. 업무 학습 에서 정규 표현 식 처리 문자열 을 유연 하 게 활용 하면 효율 을 크게 높 일 수 있 고 프로 그래 밍 의 즐거움 은 이렇게 간단 하 다.
다음은 정규 표현 식 의 사용 을 간단명료 하 게 설명 할 것 이다.
단순 입문 .

package test;

public class Test01 {

    public static void main(String[] args) {
        //   abc       "...",   "."      
        //"..."      
        System.out.println("abc".matches("..."));

        System.out.println("abcd".matches("..."));
    }

}

출력 결과:

true
false

String 클래스 에 matches(String regex) 방법 이 있 습 니 다. 반환 값 은 불 형식 입 니 다. 이 문자열 이 주어진 정규 표현 식 과 일치 하 는 지 알려 줍 니 다.
이 예 에서 우리 가 제시 한 정규 표현 식 은 ... 이 고 그 중에서 각각 . 은 한 문 자 를 나타 내 며 전체 정규 표현 식 의 뜻 은 세 글자 이다. 분명히 일치 abc 할 때 결 과 는 true 이 고 일치 abcd 할 때 결 과 는 false 이다.
정규 표현 식 에 대한 자바 지원java.util.regex 가방 아래 정규 표현 식 에 사용 되 는 두 가지 종류 가 있 습 니 다. 하 나 는 Matcher 이 고 다른 하 나 는 Pattern 입 니 다.
자바 공식 문서 에서 이 두 가지 유형 에 대한 전형 적 인 용법 을 제시 합 니 다. 코드 는 다음 과 같 습 니 다.

package test;

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

public class Test02 {

    public static void main(String[] args) {
        //[a-z]  a~z         , {3}  3   ,           3,         a~z    
        Pattern p = Pattern.compile("[a-z]{3}");
        Matcher m1 = p.matcher("abc");
        System.out.println(m2.matches());
    }
}

출력 결과: truePattern 문자열 은 특정한 패턴 과 일치 해 야 하 는 패턴 으로 이해 할 수 있다.예 를 들 어 Test02 에서 우리 가 정의 한 모델 은 3 , a~z 이다.
우 리 는 Pattern 대상 을 만 들 때 Pattern 클래스 의 compile 방법 을 호출 하 는 것 을 보 았 습 니 다. 즉, 우리 가 들 어 온 정규 표현 식 을 컴 파일 한 후에 모델 대상 을 얻 었 습 니 다.한편, 이 컴 파일 된 모델 대상 은 정규 표현 식 의 사용 효율 을 크게 향상 시 키 고 상수 로 서 여러 스 레 드 를 안전하게 병행 할 수 있 습 니 다.Matcher 패턴 이 특정한 문자열 과 일치 한 결과 로 이해 할 수 있다.문자열 이 어떤 패턴 과 일치 하면 여러 가지 결과 가 나 올 수 있 습 니 다. 이것 은 뒤의 예 에서 설명 합 니 다.
마지막 으로 우리 가 호출 m.matches() 할 때 전체 문자열 이 패턴 과 일치 하 는 결 과 를 되 돌려 줍 니 다.
위의 세 줄 코드 는 한 줄 코드 로 간략화 할 수 있다.

System.out.println("abc".matches("[a-z]{3}"));

그러나 정규 표현 식 이 반복 적 으로 일치 해 야 한다 면 쓰기 효율 이 낮 습 니 다.
일치 횟수 기호
기호.
횟수
*
0 회 혹은 여러 번
+
한 번 혹은 여러 번
？
0 회 혹은 1 회
{n}
마침 n 회
{n,m}
n ~ m 회 출현
{n,}
최소 n 회
코드 예제:

package test;

public class Test03 {

    private static void p(Object o){
        System.out.println(o);
    }
    
    public static void main(String[] args) {
        // "X*"        X
        p("aaaa".matches("a*"));
        p("".matches("a*"));
        // "X+"        X
        p("aaaa".matches("a+"));
        // "X?"        X
        p("a".matches("a?"));
        // \\d    A digit: [0-9],     ,    java  "\\"        \\    ,     \\d
        p("2345".matches("\\d{2,5}"));
        // \\.    "."
        p("192.168.0.123".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
        // [0-2]    0~2      
        p("192".matches("[0-2][0-9][0-9]"));
    }
}

출력 결과: 모두 true.
범위 [][] 한 글자 의 범 위 를 설명 하 는 데 사 용 됩 니 다. 다음은 예 입 니 다.

package test;

public class Test04 {

    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        //[abc] abc        
        p("a".matches("[abc]"));
        //[^abc]   abc     
        p("1".matches("[^abc]"));
        //a~z A~Z   ,           
        p("A".matches("[a-zA-Z]"));
        p("A".matches("[a-z|A-Z]"));
        p("A".matches("[a-z[A-Z]]"));
        //[A-Z&&[REQ]] A~Z     REQ       
        p("R".matches("[A-Z&&[REQ]]"));
    }
}

출력 결과: 모두 true.
\s \w \d \S \W \D
... 에 대하 여\
자바 의 문자열 에서 특수 문 자 를 사용 하려 면 앞 에 \ 를 추가 하여 전 의 를 해 야 합 니 다.
예 를 들 어 이 문자열 " :" , !"" 을 고려 합 니 다.만약 우리 가 전의 문자 가 없다 면, 시작 하 는 더 블 따옴표 의 끝 은 :" 여기에 있어 야 합 니 다. 그러나 우리 문자열 에는 더 블 따옴표 가 필요 하기 때문에 전의 문 자 를 사용 해 야 합 니 다.
전의 문 자 를 사용 한 문자열 은 " :\" , !\"" 입 니 다. 그래 야 우리 의 원 의 를 정확하게 식별 할 수 있 습 니 다.
마찬가지 로 우리 가 문자열 에 사용 하려 면 \ 앞 에 하나 \ 를 추가 해 야 하기 때문에 문자열 에 "\\" 를 표시 합 니 다.
그렇다면 정규 표현 식 에서 어떻게 일치 하 는 지 \ 를 표시 합 니까?답 은 "\\\\".
우 리 는 정규 식 에서 \ 역시 전의 가 필요 하기 때문에 앞의 \\ 은 정규 표현 식 에서 의 전의 문자 \ 를 나타 내 고 뒤의 \\ 는 정규 표현 식 에서 \ 자 체 를 나타 내 며 합 쳐 정규 표현 식 에서 \ 를 나타 낸다.
코드 예제 먼저 보기:

package test;

public class Test05 {

    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        // \s{4}  4    
        p(" 
\r\t".matches("\\s{4}"));
        // \S      
        p("a".matches("\\S"));
        // \w{3}          
        p("a_8".matches("\\w{3}"));
        p("abc888&^%".matches("[a-z]{1,3}\\d+[%^&*]+"));
        //    \
        p("\\".matches("\\\\"));
    }
}

기호.
나타내다
\d
[0 - 9] 숫자
\D
1 비 숫자
\s
[\ t \ r \ f] 스페이스 바
\S
2 비 스페이스 바
\w
[0 - 9A - Z a - z] 숫자 자모 와 밑줄
\W
3 비 숫자 자모 와 밑줄
경계 처리 ^^ 중 괄호 안에 반 을 취 하 는 뜻 [^] 을 표시 하고 중 괄호 안에 없 으 면 문자열 의 시작 을 나타 낸다.
코드 예제:

package test;

public class Test06 {

    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        /**
         * ^    The beginning of a line         
         * $    The end of a line             
         * \b    A word boundary                ,      ,     
         */
        p("hello sir".matches("^h.*"));
        p("hello sir".matches(".*r$"));
        p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));
        p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));
    }
}

출력 결과:

true
true
true
false

Matcher 클래스

matches() 방법 은 전체 문자열 을 템 플 릿 과 일치 시 킵 니 다.

find() 는 현재 위치 부터 일치 합 니 다. 문자열 을 입력 한 후에 먼저 진행 find() 하면 현재 위 치 는 문자열 의 시작 입 니 다. 현재 위치 에 대한 구체 적 인 분석 은 아래 의 코드 예제

를 볼 수 있 습 니 다.

lookingAt() 방법 은 문자열 의 시작 부분 에서 일치 합 니 다.

코드 예제:

package test;

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

public class Test07 {
    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d{3,5}");
        String s = "123-34345-234-00";
        Matcher m = pattern.matcher(s);

        //   matches(),         .
        p(m.matches());
        //   false,      3~5     -     

        //    find(),    reset()                
        m.reset();
        p(m.find());//true   123  
        p(m.find());//true   34345  
        p(m.find());//true   234  
        p(m.find());//false   00  

        //        matches()  reset(),          
        m.reset();//   
        p(m.matches());//false          ,       -
        p(m.find());// true   34345  
        p(m.find());// true   234  
        p(m.find());// false   00  
        p(m.find());// false       ,   

        //  lookingAt(),      
        p(m.lookingAt());//true   123,   
    }
    
}

한 번 일치 에 성공 하면 start() 일치 하 는 시작 위 치 를 되 돌려 줍 니 다.end() 끝 문자 와 일치 하 는 뒤의 위 치 를 되 돌려 주 는 데 사 용 됩 니 다.
코드 예제:

package test;

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

public class Test08 {

    private static void p(Object o) {
        System.out.println(o);
    }

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d{3,5}");
        String s = "123-34345-234-00";
        Matcher m = pattern.matcher(s);

        p(m.find());//true   123  
        p("start: " + m.start() + " - end:" + m.end());
        p(m.find());//true   34345  
        p("start: " + m.start() + " - end:" + m.end());
        p(m.find());//true   234  
        p("start: " + m.start() + " - end:" + m.end());
        p(m.find());//false   00  
        try {
            p("start: " + m.start() + " - end:" + m.end());
        } catch (Exception e) {
            System.out.println("   ...");
        }
        p(m.lookingAt());
        p("start: " + m.start() + " - end:" + m.end());
    }
}

출력 결과:

true
start: 0 - end:3
true
start: 4 - end:9
true
start: 10 - end:13
false
   ...
true
start: 0 - end:3

대체 문자열Matcher 류 중의 한 방법group() 일치 하 는 문자열 을 되 돌려 줍 니 다.
코드 예제: 문자열 의 java 을 대문자 로 변환 합 니 다.

package test;

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

public class Test09 {

    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        Pattern p = Pattern.compile("java");
        Matcher m = p.matcher("java I love Java and you");
        p(m.replaceAll("JAVA"));//replaceAll()              
    }
}

출력 결과:

JAVA I love Java and you

대소 문자 구분 없 이 문자열 찾기 및 바 꾸 기
템 플 릿 템 플 릿 을 만 들 때 대소 문자 가 민감 하지 않 음 을 지정 해 야 합 니 다.

public static void main(String[] args) {
    Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);//          
    Matcher m = p.matcher("java I love Java and you");
    p(m.replaceAll("JAVA"));
}

출력 결과:

JAVA I love JAVA and you

대소 문 자 를 구분 하지 않 고 찾 은 지정 한 문자열 을 바 꿉 니 다.
찾 은 홀수 문자열 을 대문자 로 바 꾸 고, 짝수 문자열 을 소문 자로 바 꾸 는 것 을 보 여 줍 니 다.
여기에 Matcher 클래스 의 강력 한 방법 appendReplacement(StringBuffer sb, String replacement) 을 도입 합 니 다. 문자열 연결 을 위해 StringBuffer 를 입력 해 야 합 니 다.

public static void main(String[] args) {
    Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
    Matcher m = p.matcher("java Java JAVA JAva I love Java and you ?");
    StringBuffer sb = new StringBuffer();
    int index = 1;
    while(m.find()){
        m.appendReplacement(sb, (index++ & 1) == 0 ? "java" : "JAVA");
        index++;
    }
    m.appendTail(sb);//         
    p(sb);
}

출력 결과:

JAVA JAVA JAVA JAVA I love JAVA and you ?

패 킷
먼저 예 시 를 보 자.

package test;

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

public class Test10 {

    private static void p(Object o) {
        System.out.println(o);
    }

    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d{3,5}[a-z]{2}");
        String s = "005aa-856zx-1425kj-29";
        Matcher m = p.matcher(s);
        while (m.find()) {
            p(m.group());
        }
    }
}

출력 결과:

005aa
856zx
1425kj

그 중에서 정규 표현 식 "\\d{3,5}[a-z]{2}" 은 3 ~ 5 개의 숫자 가 두 자 모 를 따라 간 다음 에 일치 하 는 문자열 을 출력 합 니 다.
모든 일치 하 는 문자열 의 숫자 를 인쇄 하려 면 어떻게 조작 합 니까?
그룹 체 제 는 정규 표현 식 에서 그룹 을 나 누 는 데 도움 을 줄 수 있 습 니 다.규정 에 따라 사용 () 을 그룹 으로 나 누 는데 여기 서 우 리 는 자모 와 숫자 를 각각 한 조로 나 누 었 다 "(\\d{3,5})([a-z]{2})".
그리고 m.group(int group) 방법 을 호출 할 때 그룹 번 호 를 입력 하면 됩 니 다. : 그룹 번 호 는 0 부터 시작 합 니 다. 0 조 는 전체 정규 표현 식 을 대표 합 니 다. 0 이후 정규 표현 식 에서 왼쪽 에서 오른쪽 까지 왼쪽 괄호 마다 한 그룹 에 대응 합 니 다.이 표현 식 에서 1 조 는 숫자 이 고 2 조 는 알파벳 입 니 다.

public static void main(String[] args) {
    Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");//      3~5         
    String s = "005aa-856zx-1425kj-29";
    Matcher m = p.matcher(s);
    while(m.find()){
        p(m.group(1));
    }
}

출력 결과:

005
856
1425

정리 하 다.

중국어 문자 와 일치 하 는 정규 표현 식: [\u4e00-\u9fa5]

쌍 바이트 문자 일치 (한자 포함): [^\x00-\xff]

빈 줄 과 일치 하 는 정규 표현 식:
[\s| ]*\r

HTML 태그 와 일치 하 는 정규 표현 식: /.*|/

수미 빈 칸 과 일치 하 는 정규 표현 식: (^\s*)|(\s*$)

IP 주소 와 일치 하 는 정규 표현 식: /(\d+)\.(\d+)\.(\d+)\.(\d+)/g //

이메일 주소 와 일치 하 는 정규 표현 식: \w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

사이트 URL 과 일치 하 는 정규 표현 식: http://(/[\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

sql 문장: ^(select|drop|delete|create|update|insert).*$

비 마이너스 정수: ^\d+$

정수: ^[0-9]*[1-9][0-9]*$

비정 정수: ^((-\d+)|(0+))$

마이너스 정수: ^-[0-9]*[1-9][0-9]*$

정수: ^-?\d+$

비 마이너스 부동 소수점: ^\d+(\.\d+)?$

부동 소수점: ^((0-9)+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$

비정 상 부동 소수점: ^((-\d+\.\d+)?)|(0+(\.0+)?))$

마이너스 부동 소수점: ^(-(( )))$

영어 문자열: ^[A-Za-z]+$

영문 대문자 꼬치: ^[A-Z]+$

영어 소문 자 꼬치: ^[a-z]+$

영문 문자열: ^[A-Za-z0-9]+$

영 숫자 에 밑줄 친 문자열 추가: ^\w+$

이메일 주소: ^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$

URL： ^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$ ：^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~@[\]\':+!]*([^<>\"\"])*$

우편 번호: ^[1-9]\d{5}$

중국어: ^[\u0391-\uFFE5]+$

전화번호: ^((\(\d{2,3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$

핸드폰 번호: ^((\(\d{2,3}\))|(\d{3}\-))?13\d{9}$

두 바이트 문자 (한자 포함): ^\x00-\xff

시작 과 끝 에 일치 하 는 스페이스 바: (^\s*)|(\s*$)（ vbscript trim ）

HTML 태그 와 일치 합 니 다: .*|

일치 하 는 빈 줄:
[\s| ]*\r

추출 정보 중의 네트워크 링크: (h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

추출 정보 에서 메 일 주소: \w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

추출 정보 중의 이미지 링크: (s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

추출 정보 에서 IP 주소: (\d+)\.(\d+)\.(\d+)\.(\d+)

추출 정보 중의 중국 핸드폰 번호: 86)*0*13\d{9}

추출 정보 중의 중국 고정 전화번호: (\(\d{3,4}\)|\d{3,4}-|\s)?\d{8}

추출 정보 중의 중국 전화번호 (이동 과 고정 전화 포함): (\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}

추출 정보 중의 중국 우편 번호: [1-9]{1}(\d+){5}

추출 정보 중의 부동 소수점 (즉 소수): (-?\d*)\.?\d+

추출 정보 중의 모든 숫자: (-?\d*)(\.\d+)?

IP 주소: (\d+)\.(\d+)\.(\d+)\.(\d+)

전화번호: /^0\d{2,3}$/

텐 센트 QQ 번호: ^[1-9]*[1-9][0-9]*$

계 정 (알파벳 시작, 5 - 16 바이트 허용, 알파벳 숫자 밑줄 허용): ^[a-zA-Z][a-zA-Z0-9_]{4,15}$

중국어, 영어, 숫자 및 밑줄: ^[\u4e00-\u9fa5_a-zA-Z0-9]+$

총결산
이상 은 정규 표현 식 에 대한 정리 와 사용 설명 입 니 다. 정규 표현 식 이 당신 에 게 더욱 즐 거 운 프로 그래 밍 체험 을 가 져 다 주 기 를 바 랍 니 다.
엔 딩
나 는 타격 을 받 고 열심히 전진 하고 있 는 우리 다.만약 문장 이 당신 에 게 도움 이 된다 면, 기억 하 세 요 、 , 감사합니다!
0—9 ↩
\t\r\f ↩
0—9A—Z_a—z ↩