Java RegEx

자바 정규 표현식 (Java RegEx): 개념 및 사용법

*정규 표현식(Regular Expression, RegEx)**은 문자열에서 특정한 패턴을 찾거나, 패턴에 맞는 문자열을 처리하기 위한 방법입니다. 자바에서는
```
.util.regex 패키지를 사용해 정규 표현식을 지원하며, 문자열의 검색, 매칭, 치환 등의 작업을 쉽게 수행할 수 있습니다.
```

1. 자바에서 정규 표현식을 사용하기 위한 클래스

자바에서 정규 표현식을 사용하기 위해 두 가지 주요 클래스를 사용합니다:

Pattern 클래스: 정규 표현식을 컴파일하는 클래스입니다.
Matcher 클래스: Pattern 객체를 사용하여 텍스트를 매칭하고, 매칭 결과를 확인하는 클래스입니다.

1.1 `Pattern` 클래스

Pattern.compile(String regex): 정규 표현식을 컴파일하여 Pattern 객체를 생성합니다.

1.2 `Matcher` 클래스

Matcher 객체는 Pattern 객체에서 생성되며, 입력된 문자열에서 패턴을 매칭하는 기능을 제공합니다.
matcher(String input): 입력 문자열과 패턴을 매칭하는 Matcher 객체를 생성합니다.
find(): 입력 문자열에서 패턴과 일치하는 부분을 찾습니다.
matches(): 입력 문자열이 패턴과 완전히 일치하는지 확인합니다.
replaceAll(): 패턴과 일치하는 부분을 다른 문자열로 교체합니다.

2. 기본 사용법

2.1 문자열이 패턴에 일치하는지 확인

Pattern.matches() 메서드는 문자열이 정규 표현식과 완전히 일치하는지 확인합니다.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String pattern = "a*b";  // 'a'가 0번 이상 반복되고 뒤에 'b'가 오는 패턴
        String input = "aaab";

        boolean isMatch = Pattern.matches(pattern, input);
        System.out.println("패턴 일치 여부: " + isMatch);  // 출력: true
    }
}

2.2 `Pattern`과 `Matcher`를 사용한 패턴 매칭

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

public class Main {
    public static void main(String[] args) {
        String text = "I have 2 apples and 3 oranges.";
        String regex = "\\\\\\\\d+";  // 하나 이상의 숫자를 찾는 패턴

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            System.out.println("찾은 숫자: " + matcher.group());  // 출력: 2, 3
        }
    }
}

2.3 문자열 치환

replaceAll() 메서드는 패턴과 일치하는 부분을 다른 문자열로 치환합니다.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String text = "I have 2 apples and 3 oranges.";
        String regex = "\\\\\\\\d+";  // 숫자를 찾는 패턴

        // 숫자를 '#'으로 치환
        String replacedText = text.replaceAll(regex, "#");
        System.out.println(replacedText);  // 출력: I have # apples and # oranges.
    }
}

3. 정규 표현식의 주요 기호

정규 표현식은 다양한 **메타 문자(Meta Characters)**를 사용해 문자열 패턴을 정의합니다. 자주 사용하는 기호는 다음과 같습니다:

기호	설명	예시
`.`	임의의 한 문자	`a.b` -> "acb", "a2b"
`*`	앞의 문자가 0번 이상 반복됨	`a*` -> "", "a", "aaa"
`+`	앞의 문자가 1번 이상 반복됨	`a+` -> "a", "aaa"
`?`	앞의 문자가 0번 또는 1번 나타남	`a?` -> "", "a"
`\\\\d`	숫자와 매칭	`\\\\d` -> "0", "9"
`\\\\D`	숫자가 아닌 문자와 매칭	`\\\\D` -> "a", "#"
`\\\\w`	단어 문자와 매칭 (영문자, 숫자, 언더스코어)	`\\\\w` -> "a", "9", "_"
`\\\\W`	단어 문자가 아닌 문자와 매칭	`\\\\W` -> "!", " "
`\\\\s`	공백 문자와 매칭 (스페이스, 탭 등)	`\\\\s` -> " ", "\t"
`\\\\S`	공백이 아닌 문자와 매칭	`\\\\S` -> "a", "1"
`^`	문자열의 시작을 의미	`^a` -> "apple"
`$`	문자열의 끝을 의미	`b$` -> "cab"
`[abc]`	괄호 안에 있는 문자 중 하나와 매칭	`[abc]` -> "a", "b", "c"
`[a-z]`	지정된 범위의 문자와 매칭 (소문자 a부터 z까지)	`[a-z]` -> "a", "m", "z"
`[^abc]`	괄호 안에 없는 문자와 매칭	`[^abc]` -> "d", "1"
`(abc)`	괄호 안의 문자열과 정확히 일치	`(abc)` -> "abc"
`	`	또는 조건 (OR)

예시

a*b: 'a'가 0번 이상 반복되고 뒤에 'b'가 오는 패턴. ("b", "ab", "aab" 등이 매칭)
\\\\\\\\d+: 하나 이상의 숫자를 찾는 패턴. ("123", "0" 등)
[a-zA-Z]: 대소문자 영문자 하나를 찾는 패턴.

4. 패턴 그룹화와 매칭된 부분 추출

정규 표현식에서 소괄호 ( )를 사용하면 그룹화할 수 있으며, 매칭된 결과에서 해당 그룹을 추출할 수 있습니다.

그룹화 예제

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

public class Main {
    public static void main(String[] args) {
        String text = "John was born on 1992-05-30.";
        String regex = "(\\\\\\\\d{4})-(\\\\\\\\d{2})-(\\\\\\\\d{2})";  // 연도-월-일 형식 패턴

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {
            System.out.println("전체 날짜: " + matcher.group(0));  // 전체 매칭
            System.out.println("연도: " + matcher.group(1));       // 첫 번째 그룹 (연도)
            System.out.println("월: " + matcher.group(2));         // 두 번째 그룹 (월)
            System.out.println("일: " + matcher.group(3));         // 세 번째 그룹 (일)
        }
    }
}

출력 예시:

전체 날짜: 1992-05-30
연도: 1992
월: 05
일: 30

5. 자주 사용되는 정규 표현식 패턴

5.1 이메일 주소 검증

String emailPattern = "^[\\\\\\\\w-\\\\\\\\.]+@[\\\\\\\\w-\\\\\\\\.]+\\\\\\\\.[a-zA-Z]{2,}$";
String email = "test@example.com";

boolean isValidEmail = Pattern.matches(emailPattern, email);
System.out.println("이메일 유효성: " + isValidEmail);  // 출력: true

5.2 전화번호 검증 (010-XXXX-XXXX 형식)

String phonePattern = "^010-\\\\\\\\d{4}-\\\\\\\\d{4}$";
String phone = "010-1234-5678";

boolean isValidPhone = Pattern.matches(phonePattern, phone);
System.out.println("전화번호 유효성: " + isValidPhone);  // 출력: true

5.3 URL 검증

String urlPattern = "^(https?://)?(www\\\\\\\\.)?[a-zA-Z0-9-]+\\\\\\\\.[a-zA-Z]{2,}(/\\\\\\\\S*)?$";
String url = "<https://www.example.com/path>";

boolean isValidUrl = Pattern.matches(urlPattern, url

);
System.out.println("URL 유효성: " + isValidUrl);  // 출력: true

요약

*정규 표현식(Regular Expression, RegEx)**은 문자열에서 특정 패턴을 찾거나, 패턴에 맞는 문자열을 처리하기 위한 기술입니다.
자바에서는 **Pattern*과 Matcher 클래스를 사용하여 정규 표현식을 컴파일하고 문자열 매칭 작업을 수행할 수 있습니다.
find(), matches(), replaceAll() 등의 메서드를 사용해 문자열 검색, 매칭, 치환 작업을 할 수 있습니다.
정규 표현식의 다양한 메타 문자와 기호를 통해 복잡한 문자열 패턴을 처리할 수 있습니다.
자바 정규 표현식은 이메일, 전화번호, URL과 같은 문자열의 유효성을 검증하는 데 유용하게 사용됩니다.

정규 표현식은 복잡한 패턴을 효율적으로 처리할 수 있는 강력한 도구로, 자바에서 문자열 처리에 매우 유용하게 활용됩니다.

코딩 스쿨 Java