[JAVA] 정규 표현식

정규표현식이란?

프로그래밍에서 문자열을 다룰 때, 문자열의 일정한 패턴을 표현하는 일종의 형식 언어

 

프로그램을 작성할 때 일정한 규칙을 가진 텍스트 문자열을 사용하는 경우, 정규 표현식을 사용한다.

특정한 조건의 문자를 검색 or 치환하는 과정을 편리하게 해준다.

정규표현식은 패턴을 사용해서 문자열을 처리한다.

기본 원리는 아래와 같다.

패턴의 종류

정규표현식의 기본적인 패턴은 아래와 같다.

문자열 "abc axc cat 123 end boo bb"를 예시로 들면 아래와 같다.

패턴	기능	사용 예시	설명
.	문자 하나	"a.c"	'a'와 'c' 사이에 어떤 문자가 하나 있는 문자열을 찾음. 예: "abc", "axc"
|	또는 (OR)	"cat|boo"	"cat" 또는 "boo"에 해당하는 문자열을 찾음. 예: "cat", "boo"
[]	문자 집합	"[ac]at"	'a' 또는 'c'로 시작하고 "at"으로 끝나는 문자열을 찾음. 예: "cat"
^	시작하는 문자열	"^abc"	"abc"로 시작하는 문자열을 찾음. 예: "abc"
$	끝나는 문자열	"b$"	"b"로 끝나는 문자열을 찾음. 예: "b"
*	0회 이상 반복	"bo*"	'b' 뒤에 'o'가 0번 이상 나타나는 문자열을 찾음. 예: "b", "boo", "b", "b"
+	1회 이상 반복	"bo+"	'b' 뒤에 'o'가 1번 이상 나타나는 문자열을 찾음. 예: "boo"
{m,n}	m회 이상 n회 이하 반복	"b{1,2}"	'b'가 1회 이상 2회 이하 나타나는 문자열을 찾음. 예: "bb"
?	0회 또는 1회 반복	"boo?"	"bo" 또는 "boo"를 찾음. 예: "boo"
[A-Za-z]	알파벳 대문자 또는 소문자	"[A-Za-z]+"	하나 이상의 알파벳으로 이루어진 문자열을 찾음. 예: "abc", "axc", "cat", "end", "boo", "bb"
[0-9]	숫자	"[0-9]+"	하나 이상의 숫자로 이루어진 문자열을 찾음. 예: "123"
[^0-9]	숫자 제외	"[^0-9]+"	숫자를 포함하지 않는 문자열을 찾음. 예: "abc axc cat end boo bb"

사용 예시

기본적인 패턴만 보면 이해가 잘 가지 않기에 실 사례 예시를 들어보겠다.

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

public class RegexExamples {
    public static void main(String[] args) {
        // 간결하고 포괄적인 테스트 문자열
        String text = "abc axc cat 123 end boo bb";

        // 1. 문자 하나 (.)
        System.out.println("Matching '.' (one character in a.c):");
        Matcher matcher1 = Pattern.compile("a.c").matcher(text);
        while (matcher1.find()) {
            System.out.println(matcher1.group());  // "abc", "axc"
        }

        // 2. 또는 (OR) (|)
        System.out.println("\nMatching 'cat|boo':");
        Matcher matcher2 = Pattern.compile("cat|boo").matcher(text);
        while (matcher2.find()) {
            System.out.println(matcher2.group());  // "cat", "boo"
        }

        // 3. 문자 집합 ([])
        System.out.println("\nMatching '[ac]at':");
        Matcher matcher3 = Pattern.compile("[ac]at").matcher(text);
        while (matcher3.find()) {
            System.out.println(matcher3.group());  // "cat"
        }

        // 4. 시작하는 문자열 (^)
        System.out.println("\nMatching '^abc':");
        Matcher matcher4 = Pattern.compile("^abc").matcher(text);
        if (matcher4.find()) {
            System.out.println(matcher4.group());  // "abc"
        }

        // 5. 끝나는 문자열 ($)
        System.out.println("\nMatching 'b$':");
        Matcher matcher5 = Pattern.compile("b$").matcher(text);
        if (matcher5.find()) {
            System.out.println(matcher5.group());  // "b"
        }

        // 6. 0회 이상 반복 (*)
        System.out.println("\nMatching 'bo*':");
        Matcher matcher6 = Pattern.compile("bo*").matcher(text);
        while (matcher6.find()) {
            System.out.println(matcher6.group());  // "b", "boo" ,"b", "b"
        }

        // 7. 1회 이상 반복 (+)
        System.out.println("\nMatching 'bo+':");
        Matcher matcher7 = Pattern.compile("bo+").matcher(text);
        while (matcher7.find()) {
            System.out.println(matcher7.group());  // "boo"
        }

        // 8. m회 이상 n회 이하 반복 ({m,n})
        System.out.println("\nMatching 'b{1,3}':");
        Matcher matcher8 = Pattern.compile("b{1,3}").matcher(text);
        while (matcher8.find()) {
            System.out.println(matcher8.group());  // "b" ,"b" ,"bb"
        }

        // 9. 0회 또는 1회 반복 (?)
        System.out.println("\nMatching 'boo?':");
        Matcher matcher9 = Pattern.compile("boo?").matcher(text);
        while (matcher9.find()) {
            System.out.println(matcher9.group());  // "boo"
        }

        // 10. 알파벳 대문자 또는 소문자 ([A-Za-z])
        System.out.println("\nMatching '[A-Za-z]+':");
        Matcher matcher10 = Pattern.compile("[A-Za-z]+").matcher(text);
        while (matcher10.find()) {
            System.out.println(matcher10.group());  // "abc", "axc", "cat", "end", "boo", "bb"
        }

        // 숫자 ([0-9])
        System.out.println("\nMatching '[0-9]+':");
        Matcher matcher11 = Pattern.compile("[0-9]+").matcher(text);
        while (matcher11.find()) {
            System.out.println(matcher11.group());  // "123"
        }

        // 문자 제외 ([^0-9])
        System.out.println("\nMatching '[^0-9]+':");
        Matcher matcher12 = Pattern.compile("[^0-9]+").matcher(text);
        while (matcher12.find()) {
            System.out.println(matcher12.group());  // "abc axc cat  end boo bb"
        }
    }
}