add user agent parser and update build configuration

docs/자바 스트림 API .md

@@ -0,0 +1,156 @@
+# Java Stream API
+
+Java의 **Stream API**는 컬렉션, 배열 등에서 요소를 효율적으로 처리할 수 있도록 제공되는 기능이다. 
+Stream은 **중간 연산(Intermediate Operation)**과 **최종 연산(Terminal Operation)**으로 나뉘며, 
+스트림을 사용하면 **반복문 없이 데이터 변환, 필터링, 집계 등을 간결하게 처리 가능**하다. 
+
+
+## Stream API 메서드
+
+### 스트림 생성 메서드
+| 메서드 | 설명 |
+|--------|------|
+| `Stream.of(T... values)` | 여러 개의 값을 직접 입력하여 스트림 생성 |
+| `Stream.ofNullable(T t)` | 값이 `null`이면 비어있는 스트림 반환 |
+| `Arrays.stream(T[] array)` | 배열을 스트림으로 변환 |
+| `Collection.stream()` | 컬렉션(List, Set 등)에서 스트림 생성 |
+| `Collection.parallelStream()` | 병렬 스트림 생성 |
+| `IntStream.range(int start, int end)` | 특정 범위의 숫자 스트림 생성 (end 미포함) |
+| `IntStream.rangeClosed(int start, int end)` | 특정 범위의 숫자 스트림 생성 (end 포함) |
+| `Stream.iterate(T seed, UnaryOperator<T> f)` | 초기값과 람다식을 사용하여 무한 스트림 생성 |
+| `Stream.generate(Supplier<T> s)` | Supplier를 사용해 무한 스트림 생성 |
+
+
+### 필터링 및 매핑 (중간 연산)
+| 메서드 | 설명 |
+|--------|------|
+| `filter(Predicate<T> predicate)` | 조건에 맞는 요소만 포함하는 스트림 반환 |
+| `map(Function<T, R> mapper)` | 각 요소를 변환하여 새로운 스트림 생성 |
+| `flatMap(Function<T, Stream<R>> mapper)` | 각 요소를 스트림으로 변환한 후 하나의 스트림으로 결합 |
+| `distinct()` | 중복 요소 제거 |
+| `sorted()` | 요소들을 정렬 (기본 정렬 기준 사용) |
+| `sorted(Comparator<T> comparator)` | 지정한 비교자를 사용하여 정렬 |
+| `peek(Consumer<T> action)` | 스트림의 각 요소를 확인 (디버깅용) |
+
+
+### 요소 제한 및 조작 (중간 연산)
+| 메서드 | 설명 |
+|--------|------|
+| `limit(long maxSize)` | 지정된 개수만큼 요소를 제한 |
+| `skip(long n)` | 앞의 n개 요소를 건너뛰고 나머지 반환 |
+| `takeWhile(Predicate<T> predicate)` | 조건을 만족하는 동안 요소를 유지하고 이후 요소는 제외 |
+| `dropWhile(Predicate<T> predicate)` | 조건을 만족하는 동안 요소를 버리고 이후 요소만 유지 |
+
+
+### 집계 및 종료 연산 (최종 연산)
+| 메서드 | 설명 |
+|--------|------|
+| `count()` | 스트림 내 요소 개수 반환 |
+| `min(Comparator<T> comparator)` | 최소값 반환 |
+| `max(Comparator<T> comparator)` | 최대값 반환 |
+| `findFirst()` | 첫 번째 요소 반환 (Optional) |
+| `findAny()` | 임의의 요소 반환 (Optional) |
+| `allMatch(Predicate<T> predicate)` | 모든 요소가 조건을 만족하는지 검사 (boolean) |
+| `anyMatch(Predicate<T> predicate)` | 하나 이상의 요소가 조건을 만족하는지 검사 (boolean) |
+| `noneMatch(Predicate<T> predicate)` | 모든 요소가 조건을 만족하지 않는지 검사 (boolean) |
+| `forEach(Consumer<T> action)` | 각 요소에 대해 작업 수행 (최종 연산) |
+
+
+### 스트림을 컬렉션으로 변환
+| 메서드 | 설명 |
+|--------|------|
+| `toArray()` | 스트림을 배열로 변환 |
+| `collect(Collectors.toList())` | 스트림을 리스트로 변환 |
+| `collect(Collectors.toSet())` | 스트림을 집합(Set)으로 변환 |
+| `collect(Collectors.toMap(Function<T,K>, Function<T,V>))` | 스트림을 Map으로 변환 |
+
+
+### 요소를 조합하여 결과 생성
+| 메서드 | 설명 |
+|--------|------|
+| `reduce(BinaryOperator<T> accumulator)` | 요소를 하나의 값으로 축약 |
+| `reduce(T identity, BinaryOperator<T> accumulator)` | 초기값을 사용하여 축약 |
+| `reduce(T identity, BiFunction<T, U, T> accumulator, BinaryOperator<T> combiner)` | 병렬 처리용 축약 연산 |
+
+
+## Stream API 예제
+
+### 스트림 생성 및 변환
+```java
+import java.util.*;
+import java.util.stream.*;
+
+public class StreamExample {
+ public static void main(String[] args) {
+ // 리스트에서 스트림 생성
+ List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
+
+ // 이름 길이가 4 이상인 요소 필터링
+ List<String> result = names.stream()
+ .filter(name -> name.length() >= 4)
+ .sorted()
+ .collect(Collectors.toList());
+
+ System.out.println(result); // 출력: [Alice, Charlie, David]
+ }
+}
+```
+
+
+### `map()`을 이용한 변환
+```java
+List<String> words = Arrays.asList("apple", "banana", "cherry");
+
+List<Integer> lengths = words.stream()
+ .map(String::length)
+ .collect(Collectors.toList());
+
+System.out.println(lengths); // 출력: [5, 6, 6]
+```
+
+
+### `flatMap()`을 이용한 중첩 리스트 평탄화
+```java
+List<List<String>> listOfLists = Arrays.asList(
+ Arrays.asList("a", "b"),
+ Arrays.asList("c", "d"),
+ Arrays.asList("e", "f")
+);
+
+List<String> flatList = listOfLists.stream()
+ .flatMap(List::stream)
+ .collect(Collectors.toList());
+
+System.out.println(flatList); // 출력: [a, b, c, d, e, f]
+```
+
+
+### `reduce()`를 이용한 합산
+```java
+List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
+
+int sum = numbers.stream()
+ .reduce(0, Integer::sum);
+
+System.out.println(sum); // 출력: 15
+```
+
+
+### `groupingBy()`를 이용한 그룹화
+```java
+List<String> items = Arrays.asList("apple", "banana", "apple", "orange", "banana");
+
+Map<String, Long> itemCount = items.stream()
+ .collect(Collectors.groupingBy(s -> s, Collectors.counting()));
+
+System.out.println(itemCount);
+// 출력: {banana=2, apple=2, orange=1}
+```
+
+
+## 정리
+- **Java Stream API**는 **중간 연산**과 **최종 연산**을 조합하여 데이터를 효과적으로 변환하고 처리하는 도구다. 
+- **`filter()`**, **`map()`**, **`flatMap()`**을 사용하여 데이터를 가공할 수 있다. 
+- **`collect()`**를 사용하여 스트림을 **리스트, 셋, 맵**으로 변환할 수 있다. 
+- **`reduce()`**, **`groupingBy()`** 등의 메서드를 활용하면 데이터 집계를 손쉽게 수행할 수 있다. 
+- 대량의 데이터를 **간결하고 효율적으로 처리하는 경우 Stream API를 적극 활용**하자!