코딩테스트 공부하면서 작성하는 노트!!

택스트 색 변경

배경 색 변경

📌 Class & Interface

🙂 Math 클래스

• Math 클래스는 수학에서 자주 사용하는 상수들과 함수들을 미리 구현해 놓은 클래스이다.

long sqrt = (long)Math.sqrt(n);  // n의 제곱근 반환
long pow = (long)Math.pow(sqrt, 2);  // sqrt의 2제곱 반환
int random = (int)(Math.random() * 45) + 1; // 1부터 45까지의 난수 반환
... Math.abs(-10);  // 10 (절대값 반환)
... Math.max(10, 20);  // 20 (더 큰 수 반환)
... Math.min(10, 20);  // 10 (더 작은 수 반환)
... Math.ceil(9.2);  // 10.0 (올림)
... Math.floor(9.2);  // 9.0 (내림)
... Math.round(9.5);  // 10.0 (반올림)

🙂 Stack 클래스

• Java의 스택은 LIFO(Last In, First Out) 원칙을 따르는 데이터 구조이다.
• Stack은 동기화되는 Vector를 상속하므로 단일 스레드 환경에서 오버헤드가 높아집니다.
• 모든 메서드를 동기화 하기때문에 불필요한 작업이 많아져 성능이 저하된다.

  동기화는 동시 환경에서 여러 스레드가 공유 리소스에 대한 액세스를 제어하는 ​​메커니즘입니다. 한 번에 하나의 스레드만 리소스에 액세스할 수 있도록 하여 데이터 손상을 방지하고 스레드 안전성을 보장합니다.

import java.util.Stack;

Stack<Integer> stack = new Stack<>();

// 요소를 스택의 맨 위에 추가 (Deque와 작동 방식이 다르다.)
stack.push(element);
// 스택 맨 위의 객체를 반환하고 제거
stack.pop();
// 스택 맨 위의 객체를 반환
stack.peek();
// 스택이 비어있는지 확인 (true or false)
stack.isEmpty();

🙂 Deque 인터페이스

• 자바 1.6부터 지원하게된 Deque는 'Queue' 인터페이스를 확장하여 만들어진 인터페이스다.
• 양쪽 끝(헤드와 테일)에서 요소 삽입 및 제거를 지원하므로 스택 및 대기열 작업을 모두 구현하는 더 많은 사용 사례에 적합하다.
• Deque에서는 Stack에서와 다르게 메서드를 동기화하지 않아서 성능이 좋다.

import java.util.ArrayDeque;
import java.util.Deque;

Deque<Integer> deque = new ArrayDeque<>();

// 데크 맨 앞에 요소를 추가 -> 삽입 실패시 IllegalstateException
stack.addFirst(element);
// 삽입 가능한 경우(용량이 충분한 경우 등) 데크 맨 앞에 요소를 추가 -> 예외 발생 x
stack.offerFirst(element);  // boolean 반환
// 데크 맨 끝에 요소를 추가
stack.addLast(element);
// 삽입 가능한 경우(용량이 충분한 경우 등) 데크 맨 끝에 요소를 추가 -> 예외 발생 x
stack.offerLast(element);  // boolean 반환
// 데크 맨 앞에(헤드 부분에 요소를 추가
stack.push(element);


// 데크 첫번째 요소를 반환하고 제거 -> 덱이 비어있는 경우 NoSuchElementException 예외 발생
stack.removeFirst();
// 데크 첫번째 요소를 반환하고 제거 -> 덱이 비어있는 경우 예외를 발생시키지 않고 null 반환
stack.pollFirst();
// 데크 마지막 요소를 반환하고 제거 -> 덱이 비어있는 경우 NoSuchElementException 예외 발생
stack.removeLast();
// 데크 마지막 요소를 반환하고 제거 -> 덱이 비어있는 경우 예외를 발생시키지 않고 null 반환
stack.pollLast();
// 데크 마지막 요소를 반환하고 제거 -> 덱이 이미 비어있는 경우 NoSuchElementException 예외 발생
stack.pop();

// 데크의 첫번째 요소를 반환 -> 덱이 비어있는 경우 NoSuchElementException 예외 발생
stack.getFirst();
// 데크의 첫번째 요소를 반환 -> 덱이 비어있는 경우 예외를 발생시키지 않고 null을 반환
stack.peekFirst();
// 데크의 마지막 요소를 반환 -> 덱이 비어있는 경우 NoSuchElementException 예외 발생
stack.getLast();
// 데크의 마지막 요소를 반환 -> 덱이 비어있는 경우 예외를 발생시키지 않고 null을 반환
stack.peekLast();
// 데크의 헤드(첫번째) 요소를 반환 -> 덱이 비어있는 경우 NoSuchElementException 예외 발생
stack.element();
// 데크의 헤드(첫번째) 요소를 반환 -> 덱이 비어있는 경우 예외를 발생시키지 않고 null 반환
stack.peek();

// 데크 요소의 수를 반환
stack.size();
// 데크가 비어있는지 확인 -> boolean 반환
stack.isEmpty();
// 데크에 요소가 포함되어 있는지 검색 -> boolean 반환
stack.contains(element);
// 데크의 모든 요소를 제거
stack.clear();
// 데크의 모든 요소를 배열로 반환
stack.toArray();

🙂 PriorityQueue 클래스

• 데이터의 우선순위에 따라 정렬된 상태로 관리되는 자료구조이다.

• 우선순위 큐는 내부적으로 힙(heap) 자료구조를 사용하여 구현되므로, 요소 삽입, 제거, 검색 등의 연산이 효율적으로 수행될 수 있다.

• 힙 자료구조를 사용하므로 일반적인 큐에 비해 메모리 사용량이 증가할 수 있다.

• Comparable 인터페이스를 구현해 요소 간 우선순위 비교 기준을 정의할 수 있다.

• 기본 자료형 Integer나 String으로 생성하면 오름차순으로 우선순위가 정해진다.

import java.util.PriorityQueue;

PriorityQueue<Integer> priQueue = new PriorityQueue<>();

// 큐에 요소를 추가
priQueue.offer(element);

// 가장 우선순위가 높은 요소를 제거하고 반환
priQueue.poll();
// 주어진 요소를 제거
priQueue.remove(element);

// 가장 우선순위가 높은 요소를 반환
priQueue.peek():;

// 큐에 주어진 요소가 포함되어 있는지 확인 -> boolean 반환
priQueue.contains(element);
// 큐에 포함된 요소의 개수를 반환
priQueue.size();
// 큐가 비어있는지 확인 -> boolean 반환
priQueue.isEmpty(); 

// 큐의 모든 요소를 제거
priQueue.clear();
// 큐의 모든 요소를 배열로 반환
priQueue.toArray();

🙂 StringBuilder 클래스

• StringBuilder 클래스는 Java에서 문자열을 효율적으로 조작하기 위해 사용됨.
  문자열을 자주 변경하거나 연결해야 하는 경우, 문자열을 반복 수행하거나 큰 문자열을 만들때 StringBuilder는 성능 면에서 유리하다.
• String 객체는 불변(immutable)인 반면, StringBuilder는 가변(mutable)하기 때문이다.

String a = "abc";

StringBuilder sb = new StringBuilder();
sb.append(a);  // 문자열 추가
sb.insert(n, a);  // n번째에 문자열 추가
sb.delete(n, m);  // n번째부터 m번째까지의 문자열 삭제
sb.replace(n, m, a);  // n번째부터 m번째까지의 문자열 교체
sb.substring(n, m);  // n번째부터 m번째까지의 문자열 반환
sb.length();  // 문자열 길이 반환
sb.setLength();  // 문자열 길이 설정
sb.reverse();  // 문자열 반전
sb.toString();  // 문자열을 반환

🙂 List 인터페이스 (java.util.List)

• 배열과 같이 객체를 일렬로 늘어놓은 구조를 가지고 있다. 객체를 인덱스(index)로 관리하기 때문에 객체를 저장하면 자동으로 인덱스가 부여되고, 인덱스로 객체를 검색, 추가, 삭제할 수 있는 등의 기능을 제공한다.
• 순서가 있고 중복을 허용한다.
• 인덱스로 관리하기 때문에 인덱스로 접근이 가능하다.
• 크기가 가변적이다.

List<String> list = new ArrayList<>();

// index에 값을 추가한다.
list.add(int index, Object element);  

//index위치의 값을 변경하고 Object 타입으로 리턴한다.
list.set(int index, Object element); 

// start부터 end에 있는 객체를 반환한다. List 타입으로 리턴한다.
list.subList(int start, int end);

// index 위치에 있는 값을 삭제한다. Object 타입으로 리턴한다.
list.remove(int index);

// list가 비어있는지 확인한다. boolean 타입으로 티턴한다.
list.isEmpty();

// list의 길이를 반환한다.
list.size();

// list에 element가 있는지 확인한다. boolean 타입으로 리턴한다.
list.contains(Object element);

// index번째 list 요소를 Object 타입으로 반환한다.
list.get(int index);

// 순방향 / 역방향으로 탐색하여 주어진 객체의 위치를 반환한다. int 타입으로 리턴한다.
list.indexOf(Object o); / lastIndex(Object o); 

🙂 ArrayList 클래스

• 객체가 인덱스로 관리된다는 점에서 배열과 유사하다. 그러나 배열은 생성될 때 크기가 고정되며, 크기를 변경할 수 없지만 ArrayList는 저장 용량을 초과하여 객체들이 추가되면, 자동으로 저장용량이 늘어나게 된다. 또한 데이터가 연속적으로 존재하여 데이터의 순서가 유지된다.

• 특정 인덱스의 객체를 제거하면, 바로 뒤 인덱스부터 마지막 인덱스까지 모두 앞으로 1씩 당겨진다.

• ArrayList에 객체를 순차적으로 저장할 때에는 데이터를 이동하지 않아도 되므로, 작업 속도가 빠르지만, 중간에 위치한 객체를 추가, 삭제할 때에는 데이터 이동이 많이 일어나므로 속도가 저하된다.

• 반면 인덱스가 n인 요소인 데이터에 빠르게 접근이 가능하기 때문에 검색(읽기) 측면에서는 유리하다.

ArrayList<String> list = new ArrayList<String>();
// 초기 용량을 명시적으로 전달하지 않으면 기본적으로 10으로 설정된다.

🙂 Arrays (java.util.Arrays)

• 배열을 다루는 다양한 메서드를 제공
• 정적 메서드(static method)만으로 구성: 객체 생성 없이 바로 사용 가능
• 배열 정렬, 검색, 복사, 변경 등: 다양한 작업 수행 가능
• 기본 데이터 타입 배열 및 객체 배열 모두 지원: int[], double[], String[], custom objects 등

// 배열의 오름차순 정렬
Arrays.sort(Object[] array);
// 배열을 문자열 형식으로 변환
Arrays.toString(Object[] array);
// 요소의 존재 여부 확인 boolean 타입으로 반환
Arrays.indexOf(Object[] array, Object element);

🙂 Collections 클래스

• 컬렉션 조작 관련 메서드 제공: 정렬, 검색, 복사, 변경 등

import java.util.Collections;

// list를 오름차순 정렬한다.
Collections.sort(List<T> list);

// list를 내림차순 정렬한다.
Collections.sort(List<T> list, Collections.reverseOrder());

// list의 요소 순서를 뒤집는다.
Collections.reverse(List<T> list);

🙂 DeferredResult 클래스

• Spring Framework에서 제공하는 비동기 요청 처리를 위해 사용되는 클래스
• 여러 사용자가 동시에 검색 요청을 보낼 경우, 비동기 처리 방식은 더 많은 동시 요청을 효율적으로 처리할 수 있습니다.
• 결과적으로 적은 수의 스레드로 많은 동시 요청을 처리할 수 있습니다.
• 같이 사용되는 WebClient는 Servlet API에 의존하지 않습니다. 이는 더 가벼운 리소스 사용을 의미합니다.
• 전통적인 동기식 접근방식(예: RestTemplate)과 달리, 각 요청마다 새로운 스레드를 할당하지 않습니다.

import org.springframework.web.context.request.async.DeferredResult;

DeferredResult<String> deferredResult = new DeferredResult<>();

DeferredResult<ResponseEntity<String>> deferredResult = new DeferredResult<>();

---

📌 Method

🙂 split()

• 문자열을 분할하여 배열로 반환하는 메서드

String s = "hello world";
String[] str = s.split(""); // ["h", "e", "l", "l", "o","  ", "w", "o", "r", "l", "d"]
String[] str = s.split(" "); // ["hello", "world"]
String[] str = s.split("(?=\\s)"); // ["hello", " world"]
String[] str = s.split("(?<=\\s)"); // ["hello ", "world"]
String[] str = s.split("(?<=\\s)|(?=\\s)"); // ["hello", " ", "world"]

str.length; // 요소의 개수

---

📌 자료형

🙂 char

• 문자열을 소문자 or 대문자인지 확인하는 방법

char c = 'a';
Character.isUpperCase(c);  // false 
Character.isLowerCase(c);  // true

• 문자열을 소문자 or 대문자로 변환하는 방법

char c = 'a';
Character.toUpperCase(c);  // A
Character.toLowerCase(c);  // a

🙂 String

• 문자열를 소문자 or 대문자로 변환하는 방법

String str = "ABC";
str.toLowerCase();  // abc
str.toUpperCase();  // ABC

• String 문자열에서 i번째 index에 있는 문자 하나만 반환 하는 방법

String str = "ABC";
str.charAt(i);  // i=1 이라면 A

• String 문자열에서 맨 앞과 맨 뒤의 공백을 제거하는 방법

String str = " AB CD ";
str.trim();  // "AB CD"로 반환됨

• String 문자열에서 'a'라는 문자가 위치하는 index 반환하는 방법

String a = "bbba123@naver.com"
int index = a.indexOf('a');  // 3

문자가 여러개 있더라도 가장 앞에 위치하는 문자의 index 하나만 반환한다.

• String 문자열을 n부터 m까지 반환하는 방법

String str = "abcd";
str.substring(n, m);

n=0, m=2일때는 ab로 출력된다. m번째 바로 이전까지 반환됨.
m을 생략하고 n만 작성한다면 str.substring(n); n번째부터 문자열 끝까지 반환됨

// substring은 index로도 활용할 수 있다.
String a = "abc123@naver.com"
int index = a.indexOf('a');
String b = a.substring(index+1);  // naver.com (도메인이 반환된다.)

• String 문자열을 n만큼 반복하는 방법

String str = "abc";
str.repeat(n);

• int를 String으로 변환하는 방법

int a = 10;
String str = Integer.toString(a);  // "10"
String str = Long.toString(a);  // "10"
String str = Double.toString(a);  // "10"
                ...
String str = String.valueOf(a);  // "10"

• String 문자열을 배열로 변환하는 방법

String a = "abc";
String[] str = a.split("");

• String 배열을 문자열의 형태로 반환하는 방법

String a = "abc";
String[] str = a.split("");

Arrays.toString(str);  // [a, b, c]

배열의 내용을 다른 문자열과 합치거나, 배열의 값을 출력할때 주로 사용된다.

• String 배열을 문자열로 합쳐서 반환하는 방법

String a = "abc";
String[] str = a.split("");

String.join("", str);  // abc

• int를 String[] 배열로 변환하는 방법

String a = "abc";
String[] str = Integer.toString(a).split("");
String[] str = String.valueOf(a).split("");

• String [] 배열에서 문자 비교하는 방법

String [] str = {"kim", "park", "lee", ...};
str[i].equals("kim")...

🙂 int

• String 문자열을 int로 반환하는 방법

String a = "123";
int b = Integer.parseInt(a);

만약 int로 변환 할 수 없는 형식의 문자열(ex: String)이 입력된다면, NumberFormatException 예외가 발생한다.

• n진수로 변환하는 방법

int a = 100;
Integer.toString(a, n);  

• n진수를 10진수로 변환하는 방법

int a = 100;
Integer.parseInt(a, n); 

---

📌 제어문

🙂 향상된 for 문

String[] arr = {"1-1","1-2","1-3","1-4","1-5"};
 		
for(String s : arr) {
    System.out.println(s);
}

// 이차원 배열
String[][] arr = {{"1-1","1-2","1-3","1-4","1-5"},{"2-1","2-2","2-3","2-4","2-5"}};
 		
for(String[] arrs : arr) {
	for(String s : arrs) {
		System.out.println(s);
	}
}

ArrayList<String> arrlist = new ArrayList<String>();
arrlist.add("1-1");
arrlist.add("1-2");
arrlist.add("1-3");
		
for(String s : arrlist) {
			  
  System.out.println(s);
			  
}

🙂 swich

---

📌 기타

🙂 정규 표현식

1) 정규 표현식 문법

• 정규표현식(Regular Expression)이란 문자열 값에서 원하는 조건(패턴)과 일치하는 문자열 일부를 찾아내거나 치환하기 위해 사용한다.
• \ 기호는 \\ 으로 이스케이프 사용해야한다.
• .(dot)을 정규표현식에 사용해야한다면 \. 으로 사용해야한다. -> 이스케이프사용해서 \\. 으로 사용
• 정규식 패턴에서 문법 오류가 발생한다면(이스케이프 처리하지 않았을때 등) PatternSyntaxException 발생

기호	의미	설명
.	임의의 문자 1개	a.c : a로 시작하고 c로 끝나는 모든 문자
^	시작을 의미한다. [] 괄호 안에 있다면 일치하지 않는 부정의 의미로로 쓰인다.	^a : a로 시작하는 단어 [^a] : a가 아닌 문자 1개 [^a-z0-9.-] : 영어 소문자, 숫자, .(dot), - 를 제외한 모든 문자
$	$앞의 문자열로 문자가 끝나는지를 의미한다.	a$ : a로 끝나는 단어 ^\\.|\\.$ : .으로 시작하거나 .으로 끝나는 문자
[]	[] 괄호 안의 문자가 있는지를 확인한다.	[ab][cd] : a와b중 하나의 문자와 c와d중 하나의 문자 [abp] : a,b,p 문자
-	사이, 범위를 지정한다.	[a-z] : 알파벳 소문자 a부터 z까지 하나 [a-z0-9] : 알파벳 소문자 전체,0~9 중 한 문자
|	or	[a|b] : a 혹은 b
()	그룹	01(0|1) : 01뒤에 0 또는 1이 들어간다 → 010(o), 011(o), 012(x)
{}	개수	a{3}b : a가 3번 온 후 b가 온다 → aab(x), aaab(o), aaaab(o) \\.{2,4} : .이 2~4회 연속하는 문자 a{3,} : a가 3개 이상인 문자
\d	모든 숫자 [0-9]와 같은 의미	\\d로 사용
\D	숫자가 아닌 모든 문자 [^0-9]와 같은 의미	\\D로 사용
\s	공백, tab을 의미	\\s로 사용
\S	공백, tab이 아닌 문자	\\S로 사용
\w	일반문자를 의미한다. [a-zA-Z_0-9]와 같은 의미	\\w로 사용
\W	일반문자가 아닌 문자 [^a-zA-Z_0-9]와 같은 의미	\\W로 사용
?	앞의 표현식이 없는 or 최대 한개만 존재하는 문자	a1? : 1이 없거나 최대 1개
+	앞의 표현식이 1개 이상 or 여러개인 문자	a1+ : 1이 최소 1개 이상
*	앞의 표현식이 없는 or 1개 이상인 문자	a1* : 1이 있을수도 없을수도 있다
(?=)	가장 앞 문자를 기준으로 검색
(?<=)	가장 뒷 문자를 기준으로 검색

✅ (?=) 와 (?<=)에 대해서!!
아래와 같은 코드가 있다고 했을 때,

String text = "This is a sample text";
        Pattern pattern = Pattern.compile("(.+)(?=sample)");
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            System.out.println("검색 : '" + matcher.group() +"'");
        }

1. compile("(.+)(?=sample)");으로 검색하면 sample의 가장 앞 문자인 s를 기준으로 전방 검색하게 되고, 검색 : 'This is a ' 라고 출력된다.
   (가장 앞 문자에서 전방 검색을 하게되면 검색어 문자가 미 포함된다.)
2. compile("(.+)(?<=sample)");으로 검색하면 sample의 가장 뒷 문자인 e를 기준으로 전방 검색하게 되고, 검색 : 'This is a sample' 라고 출력된다.
   (가장 뒤 문자에서 전방 검색을 하게되면 검색어 문자가 포함된다.)
   3.compile("(?=sample)(.+)");으로 검색하면 sample의 가장 앞 문자인 s를 기준으로 후방 검색하게 되고, 검색 : 'sample text'라고 출력된다.
   (가장 앞 문자에서 후방 검색하게 되면 검색어 문자가 포함된다.)
3. compile("(?<=sample)(.+)");으로 검색하면 sample의 가장 뒤 문자인 e를 기준으로 후방 검색하게 되고 , 검색 : ' text'라고 출력된다.
   (가장 뒤 문자에서 후방 검색을 하게 되면 검색어 문자가 미 포함된다.)

2) 자주 사용되는 정규 표현식

정규 표현식	설명
^[0-9]*$	숫자
^[a-zA-Z]*$	영문
^[가-힣]*$	한글
^01(?:0|1|[6-9])-(?:\d{3}|\d{4})-\d{4}$	핸드폰번호
\d{6} - [1-4]\d{6}	주민등록번호
^\d{3}-\d{2}$	우편번호

3) matches()

• matches의 속성과 일치하는지 확인한다.
  반환은 boolean 형식으로 true or false 반환

String str = "1";
boolean result = str.matches("[0-9]");  // true 반환

4) replaceAll()

• 문자열을 치환할때 사용된다

String str1 = "123abc";
String str2 = str1.replaceAll("\\d",""); // 모든 숫자를 치환한다.
System.out.println(str2); // abc 출력

String str1 = ".123abc.";
String str2 = str1.replaceAll("^\\.|\\.$",""); // 문자열 시작과 끝에 있는 .(dot)을 치환한다.
System.out.println(str2); // 123abc 출력

5) Pattern 클래스

• 문자열을 정규표현식 패턴 객체로 변환해주는 클래스

String str = "^[0-9]*$";
Pattern pattern = Pattern.compile(str);

String str = "123123";
boolean result = Pattern.matches("^[0-9]*$", str); // 검증 대상
System.out.println(result); // true

6) Matcher 클래스

• 주어진 패턴과 일치하는지 판별하고 여러 메소드를 이용해서 매칭 결과를 반환한다.

String str = "123abc";
String patternString = "^[0-9]+";

// 문자열을 정규표현식 패턴 객체로 변환
Pattern pattern = Pattern.compile(patternString); 

// 패턴 객체로 matcher 메서드를 통해 문자열을 검사하고 결과를 matcher 객체로 반환
Matcher matcher = pattern.matcher(txt);           

// Matcher 클래스 메소드를 통해 결과를 출력
System.out.println(matcher.find());  // true 출력
System.out.println(matcher.group());  // 1487 출력

Matcher 클래스 메서드	설 명
find( )	패턴이 일치하는 경우 true를 반환, 불일치하는 경우 false반환
find(int index)	index 위치 이후부터 매칭검색
start( )	매칭되는 문자열의 시작위치 반환
start(int index)	지정된 그룹이 매칭되는 시작위치 반환
end( )	매칭되는 문자열 끝위치의 다음 문자위치 반환
end(int index)	지정된 그룹이 매칭되는 끝위치의 다음 문자위치 반환
group( )	매칭된 부분(값)을 반환
group(int index)	그룹화되어 매칭된 패턴중 ndex번째 부분 반환
groupCount( )	그룹핑한 패턴의 전체 개수 반환
matches( )	패턴이 전체 문자열과 일치할 경우 true반환

7) 활용

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

public class Main {
    public static void main(String[] args) {
    
        // 비교할 문자열
        String str = "1234문자";

        // 문자열 형태의 정규표현식 문법
        String patternString = "[^0-9]+";

        // 1)  문자열 형태의 정규표현식을 패턴 객체로 컴파일
        Pattern pattern = Pattern.compile(patternString); 
        
        // 2) 패턴 객체로 matcher 메서드를 통해 문자열을 검사하고 필터링된 결과를 매처 객체로 반환
        Matcher matcher = pattern.matcher(str);           

        // 3) 정규식 필터링된 결과를 담은 matcher에서 메소드를 통해 결과를 출력
        System.out.println(matcher.find());  // true
        System.out.println(matcher.group());  // 문자
        
        // group이 여러개일 경우에는 반복문을 통해 반환해준다
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
        
        // while 활용
        // 매칭된 부분을 index를 사용하여 일부만 반환 할 수도 있다.
        while (matcher.find()) {
            System.out.println(matcher.group() + " -> " + matcher.group(1) + ", " + matcher.group(2) + ", " + matcher.group(3));
        }
        
        // 매칭된 위치를 반환
        while (matcher.find()) {
            // start()와 end()로 일치하는 부분의 위치를 알아낼 수 있다.
            System.out.println("매칭되는 문자열 위치 : " + matcher.start() + " ~ " + matcher.end());
            // 출력 : 매칭되는 문자열 위치 : 4 ~ 6
        }
    }
}