170 lines
6.0 KiB
Markdown
170 lines
6.0 KiB
Markdown
# **자바 정규 표현식(Regex) 쉽게 배우기**
|
|
|
|
자바에서는 정규 표현식(Regex)을 **문자열 검색, 패턴 매칭, 텍스트 변환** 등에 사용할 수 있다.
|
|
정규 표현식을 활용하면 **복잡한 문자열을 간단한 패턴으로 처리**할 수 있다.
|
|
|
|
자바에서 정규 표현식을 다룰 때 주로 사용하는 클래스는 `Pattern`과 `Matcher`이다.
|
|
또한, `String` 클래스에서도 정규 표현식을 지원하는 몇 가지 메서드가 있다.
|
|
|
|
---
|
|
|
|
## **1. 주요 클래스 및 메서드 정리**
|
|
|
|
### **(1) `Pattern` 클래스 (정규식 컴파일)**
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `Pattern.compile(String regex)` | 정규식을 컴파일하여 `Pattern` 객체 생성 |
|
|
| `Pattern.matches(String regex, CharSequence input)` | 전체 문자열이 정규식과 일치하는지 확인 |
|
|
| `pattern()` | 정규식을 문자열 형태로 반환 |
|
|
| `split(CharSequence input)` | 정규식을 기준으로 문자열을 분리 |
|
|
| `matcher(CharSequence input)` | `Matcher` 객체를 생성하여 세부적인 패턴 검색 수행 |
|
|
|
|
**사용 예시:**
|
|
```java
|
|
Pattern pattern = Pattern.compile("\\d+"); // 숫자 찾기
|
|
Matcher matcher = pattern.matcher("abc123");
|
|
|
|
System.out.println(matcher.find()); // true
|
|
```
|
|
|
|
---
|
|
|
|
### **(2) `Matcher` 클래스 (패턴 검색)**
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `find()` | 정규식과 일치하는 부분이 있는지 확인 |
|
|
| `matches()` | 전체 문자열이 정규식과 일치하는지 확인 |
|
|
| `lookingAt()` | 문자열의 **시작 부분**이 정규식과 일치하는지 확인 |
|
|
| `group()` | 최근에 매칭된 문자열을 반환 |
|
|
| `group(int group)` | 특정 그룹의 매칭 결과를 반환 |
|
|
| `start()` | 매칭된 문자열의 시작 인덱스 반환 |
|
|
| `end()` | 매칭된 문자열의 끝 인덱스 반환 |
|
|
| `replaceAll(String replacement)` | 모든 매칭된 부분을 대체 |
|
|
| `replaceFirst(String replacement)` | 첫 번째 매칭된 부분만 대체 |
|
|
|
|
**사용 예시:**
|
|
```java
|
|
Pattern pattern = Pattern.compile("\\d+");
|
|
Matcher matcher = pattern.matcher("abc123xyz456");
|
|
|
|
while (matcher.find()) {
|
|
System.out.println("찾은 숫자: " + matcher.group());
|
|
}
|
|
```
|
|
출력 결과:
|
|
```
|
|
찾은 숫자: 123
|
|
찾은 숫자: 456
|
|
```
|
|
→ `find()`를 사용하면 여러 번 매칭 가능.
|
|
|
|
---
|
|
|
|
### **(3) `String` 클래스의 정규 표현식 관련 메서드**
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `matches(String regex)` | 전체 문자열이 정규식과 일치하는지 확인 |
|
|
| `split(String regex)` | 정규식을 기준으로 문자열을 분리하여 배열 반환 |
|
|
| `replaceAll(String regex, String replacement)` | 모든 매칭된 부분을 대체 |
|
|
| `replaceFirst(String regex, String replacement)` | 첫 번째 매칭된 부분만 대체 |
|
|
|
|
**사용 예시:**
|
|
```java
|
|
String text = "apple,banana,grape";
|
|
String[] fruits = text.split(",");
|
|
|
|
for (String fruit : fruits) {
|
|
System.out.println(fruit);
|
|
}
|
|
```
|
|
출력 결과:
|
|
```
|
|
apple
|
|
banana
|
|
grape
|
|
```
|
|
→ `split()`을 사용하면 쉼표(`,`)를 기준으로 문자열을 쉽게 분리할 수 있다.
|
|
|
|
---
|
|
|
|
## **2. 정규 표현식 쉽게 설명하기**
|
|
|
|
정규 표현식은 **특정한 패턴을 가진 문자열을 검색하고, 추출하고, 변환할 수 있는 도구**이다.
|
|
아래는 자주 사용하는 정규 표현식 패턴이다.
|
|
|
|
| 정규식 | 설명 | 예제 |
|
|
|--------|------|------|
|
|
| `.` | 임의의 한 글자 | `a.b` → "acb", "a1b" (O) / "ab", "acdb" (X) |
|
|
| `\d` | 숫자 (0-9) | `\d+` → "123", "4567" |
|
|
| `\D` | 숫자가 아닌 문자 | `\D+` → "abc", "!@#" |
|
|
| `\w` | 알파벳, 숫자, `_` | `\w+` → "hello_123" |
|
|
| `\W` | 알파벳, 숫자, `_` 제외한 문자 | `\W+` → "!@#" |
|
|
| `\s` | 공백 (스페이스, 탭, 줄바꿈) | `\s+` → " " |
|
|
| `\S` | 공백이 아닌 문자 | `\S+` → "Hello" |
|
|
| `^` | 문자열의 시작 | `^abc` → "abcdef" (O) / "zabc" (X) |
|
|
| `$` | 문자열의 끝 | `xyz$` → "abcxyz" (O) / "xyzabc" (X) |
|
|
| `*` | 0개 이상 반복 | `a*` → "", "a", "aa", "aaaa" |
|
|
| `+` | 1개 이상 반복 | `a+` → "a", "aa", "aaaa" (O) / "" (X) |
|
|
| `?` | 0개 또는 1개 | `a?` → "", "a" |
|
|
| `{n}` | 정확히 n번 반복 | `a{3}` → "aaa" |
|
|
| `{n,}` | 최소 n번 반복 | `a{2,}` → "aa", "aaa", "aaaa" |
|
|
| `{n,m}` | n번 이상 m번 이하 반복 | `a{2,4}` → "aa", "aaa", "aaaa" |
|
|
|
|
---
|
|
|
|
## **3. 자주 쓰는 정규식 예제**
|
|
|
|
### **(1) 이메일 검증**
|
|
```java
|
|
String regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}$";
|
|
String email = "test@example.com";
|
|
|
|
boolean isValid = Pattern.matches(regex, email);
|
|
System.out.println("이메일 검증: " + isValid); // true
|
|
```
|
|
→ 이메일 형식인지 확인할 때 사용.
|
|
|
|
---
|
|
|
|
### **(2) 전화번호 검증 (010-xxxx-xxxx)**
|
|
```java
|
|
String regex = "^010-\\d{4}-\\d{4}$";
|
|
String phone = "010-1234-5678";
|
|
|
|
boolean isValid = Pattern.matches(regex, phone);
|
|
System.out.println("전화번호 검증: " + isValid); // true
|
|
```
|
|
→ `010-xxxx-xxxx` 형식의 전화번호인지 확인.
|
|
|
|
---
|
|
|
|
### **(3) 숫자만 포함된 문자열 체크**
|
|
```java
|
|
String regex = "^\\d+$";
|
|
String input = "123456";
|
|
|
|
boolean isNumber = Pattern.matches(regex, input);
|
|
System.out.println("숫자만 포함?: " + isNumber); // true
|
|
```
|
|
→ 숫자로만 이루어진 문자열인지 검증할 때 사용.
|
|
|
|
---
|
|
|
|
### **(4) 특정 문자 제거 (`replaceAll()`)**
|
|
```java
|
|
String text = "Hello123World";
|
|
String result = text.replaceAll("\\d", ""); // 숫자 제거
|
|
|
|
System.out.println(result); // "HelloWorld"
|
|
```
|
|
→ 숫자(`\d`)를 찾아서 제거.
|
|
|
|
---
|
|
|
|
## **4. 정리**
|
|
|
|
✅ **정규 표현식을 사용하면 복잡한 문자열 처리를 간단하게 해결 가능!**
|
|
✅ **`Pattern` & `Matcher` 클래스를 사용하면 세부적인 패턴 매칭이 가능!**
|
|
✅ **`String` 클래스에서도 `matches()`, `split()`, `replaceAll()` 등을 활용할 수 있음!**
|
|
|
|
즉, **자바의 정규 표현식 API를 잘 활용하면 문자열 검색, 치환, 검증이 훨씬 쉬워진다!** |