본문 바로가기
개발/java

java stream

by 가시죠 2025. 7. 30.
반응형
Java Stream vs 기존 문법 비교 100가지 예제

Java Stream API vs 기존 문법 비교 예제 100가지

목차

기본 컬렉션 조작

1. 리스트 순회
기존 문법
List<String> names = Arrays.asList("김철수", "이영희", "박민수");
for (String name : names) {
    System.out.println(name);
}
Stream 문법
List<String> names = Arrays.asList("김철수", "이영희", "박민수");
names.stream().forEach(System.out::println);
2. 리스트 크기 확인
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int size = numbers.size();
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream().count();
3. 빈 리스트 생성
기존 문법
List<String> emptyList = new ArrayList<>();
Stream 문법
List<String> emptyList = Stream.<String>empty().collect(Collectors.toList());
4. 배열을 리스트로 변환
기존 문법
String[] array = {"a", "b", "c"};
List<String> list = new ArrayList<>();
for (String item : array) {
    list.add(item);
}
Stream 문법
String[] array = {"a", "b", "c"};
List<String> list = Arrays.stream(array).collect(Collectors.toList());
5. 리스트 첫 번째 요소 가져오기
기존 문법
List<String> list = Arrays.asList("first", "second", "third");
String first = list.isEmpty() ? null : list.get(0);
Stream 문법
List<String> list = Arrays.asList("first", "second", "third");
Optional<String> first = list.stream().findFirst();

필터링

6. 짝수만 필터링
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = new ArrayList<>();
for (Integer num : numbers) {
    if (num % 2 == 0) {
        evenNumbers.add(num);
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
    .filter(num -> num % 2 == 0)
    .collect(Collectors.toList());
7. 특정 문자열 포함 필터링
기존 문법
List<String> names = Arrays.asList("김철수", "이영희", "김민수", "박영수");
List<String> kimNames = new ArrayList<>();
for (String name : names) {
    if (name.startsWith("김")) {
        kimNames.add(name);
    }
}
Stream 문법
List<String> names = Arrays.asList("김철수", "이영희", "김민수", "박영수");
List<String> kimNames = names.stream()
    .filter(name -> name.startsWith("김"))
    .collect(Collectors.toList());
8. null 값 제거
기존 문법
List<String> list = Arrays.asList("a", null, "b", null, "c");
List<String> filtered = new ArrayList<>();
for (String item : list) {
    if (item != null) {
        filtered.add(item);
    }
}
Stream 문법
List<String> list = Arrays.asList("a", null, "b", null, "c");
List<String> filtered = list.stream()
    .filter(Objects::nonNull)
    .collect(Collectors.toList());
9. 특정 범위 값 필터링
기존 문법
List<Integer> numbers = Arrays.asList(1, 15, 8, 22, 5, 30);
List<Integer> inRange = new ArrayList<>();
for (Integer num : numbers) {
    if (num >= 10 && num <= 25) {
        inRange.add(num);
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 15, 8, 22, 5, 30);
List<Integer> inRange = numbers.stream()
    .filter(num -> num >= 10 && num <= 25)
    .collect(Collectors.toList());
10. 빈 문자열 제거
기존 문법
List<String> strings = Arrays.asList("hello", "", "world", "", "java");
List<String> nonEmpty = new ArrayList<>();
for (String str : strings) {
    if (!str.isEmpty()) {
        nonEmpty.add(str);
    }
}
Stream 문법
List<String> strings = Arrays.asList("hello", "", "world", "", "java");
List<String> nonEmpty = strings.stream()
    .filter(str -> !str.isEmpty())
    .collect(Collectors.toList());

매핑

11. 문자열을 대문자로 변환
기존 문법
List<String> words = Arrays.asList("hello", "world", "java");
List<String> upperWords = new ArrayList<>();
for (String word : words) {
    upperWords.add(word.toUpperCase());
}
Stream 문법
List<String> words = Arrays.asList("hello", "world", "java");
List<String> upperWords = words.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
12. 숫자를 제곱으로 변환
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squares = new ArrayList<>();
for (Integer num : numbers) {
    squares.add(num * num);
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squares = numbers.stream()
    .map(num -> num * num)
    .collect(Collectors.toList());
13. 객체에서 특정 필드 추출
기존 문법
class Person {
    private String name;
    private int age;
    // constructor, getters
}

List<Person> people = Arrays.asList(
    new Person("김철수", 25),
    new Person("이영희", 30)
);
List<String> names = new ArrayList<>();
for (Person person : people) {
    names.add(person.getName());
}
Stream 문법
List<Person> people = Arrays.asList(
    new Person("김철수", 25),
    new Person("이영희", 30)
);
List<String> names = people.stream()
    .map(Person::getName)
    .collect(Collectors.toList());
14. 문자열 길이로 변환
기존 문법
List<String> words = Arrays.asList("java", "stream", "api");
List<Integer> lengths = new ArrayList<>();
for (String word : words) {
    lengths.add(word.length());
}
Stream 문법
List<String> words = Arrays.asList("java", "stream", "api");
List<Integer> lengths = words.stream()
    .map(String::length)
    .collect(Collectors.toList());
15. Double을 Integer로 변환
기존 문법
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
List<Integer> integers = new ArrayList<>();
for (Double d : doubles) {
    integers.add(d.intValue());
}
Stream 문법
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
List<Integer> integers = doubles.stream()
    .map(Double::intValue)
    .collect(Collectors.toList());

정렬

16. 숫자 오름차순 정렬
기존 문법
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
List<Integer> sorted = new ArrayList<>(numbers);
Collections.sort(sorted);
Stream 문법
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
List<Integer> sorted = numbers.stream()
    .sorted()
    .collect(Collectors.toList());
17. 문자열 길이순 정렬
기존 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
List<String> sorted = new ArrayList<>(words);
Collections.sort(sorted, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
});
Stream 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
List<String> sorted = words.stream()
    .sorted(Comparator.comparing(String::length))
    .collect(Collectors.toList());
18. 역순 정렬
기존 문법
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
List<Integer> sorted = new ArrayList<>(numbers);
Collections.sort(sorted, Collections.reverseOrder());
Stream 문법
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
List<Integer> sorted = numbers.stream()
    .sorted(Comparator.reverseOrder())
    .collect(Collectors.toList());
19. 객체 필드로 정렬
기존 문법
List<Person> people = Arrays.asList(
    new Person("김철수", 25),
    new Person("이영희", 30),
    new Person("박민수", 20)
);
List<Person> sorted = new ArrayList<>(people);
Collections.sort(sorted, new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.getAge(), p2.getAge());
    }
});
Stream 문법
List<Person> people = Arrays.asList(
    new Person("김철수", 25),
    new Person("이영희", 30),
    new Person("박민수", 20)
);
List<Person> sorted = people.stream()
    .sorted(Comparator.comparing(Person::getAge))
    .collect(Collectors.toList());
20. 다중 조건 정렬
기존 문법
List<Person> people = Arrays.asList(/*...*/);
List<Person> sorted = new ArrayList<>(people);
Collections.sort(sorted, new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        int ageCompare = Integer.compare(p1.getAge(), p2.getAge());
        return ageCompare != 0 ? ageCompare : p1.getName().compareTo(p2.getName());
    }
});
Stream 문법
List<Person> people = Arrays.asList(/*...*/);
List<Person> sorted = people.stream()
    .sorted(Comparator.comparing(Person::getAge)
            .thenComparing(Person::getName))
    .collect(Collectors.toList());

집계 연산

21. 합계 계산
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (Integer num : numbers) {
    sum += num;
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().mapToInt(Integer::intValue).sum();
22. 평균 계산
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (Integer num : numbers) {
    sum += num;
}
double average = (double) sum / numbers.size();
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
OptionalDouble average = numbers.stream()
    .mapToInt(Integer::intValue)
    .average();
23. 최댓값 찾기
기존 문법
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
Integer max = null;
for (Integer num : numbers) {
    if (max == null || num > max) {
        max = num;
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
Optional<Integer> max = numbers.stream().max(Integer::compareTo);
24. 최솟값 찾기
기존 문법
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
Integer min = null;
for (Integer num : numbers) {
    if (min == null || num < min) {
        min = num;
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
Optional<Integer> min = numbers.stream().min(Integer::compareTo);
25. 개수 세기
기존 문법
List<String> words = Arrays.asList("java", "stream", "api");
int count = 0;
for (String word : words) {
    if (word.length() > 3) {
        count++;
    }
}
Stream 문법
List<String> words = Arrays.asList("java", "stream", "api");
long count = words.stream()
    .filter(word -> word.length() > 3)
    .count();

그룹핑

26. 나이별 그룹핑
기존 문법
List<Person> people = Arrays.asList(/*...*/);
Map<Integer, List<Person>> groupByAge = new HashMap<>();
for (Person person : people) {
    int age = person.getAge();
    if (!groupByAge.containsKey(age)) {
        groupByAge.put(age, new ArrayList<>());
    }
    groupByAge.get(age).add(person);
}
Stream 문법
List<Person> people = Arrays.asList(/*...*/);
Map<Integer, List<Person>> groupByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge));
27. 문자열 길이별 그룹핑
기존 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
Map<Integer, List<String>> groupByLength = new HashMap<>();
for (String word : words) {
    int length = word.length();
    if (!groupByLength.containsKey(length)) {
        groupByLength.put(length, new ArrayList<>());
    }
    groupByLength.get(length).add(word);
}
Stream 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
Map<Integer, List<String>> groupByLength = words.stream()
    .collect(Collectors.groupingBy(String::length));
28. 조건별 분할
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Map<Boolean, List<Integer>> partition = new HashMap<>();
partition.put(true, new ArrayList<>());
partition.put(false, new ArrayList<>());
for (Integer num : numbers) {
    partition.get(num % 2 == 0).add(num);
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Map<Boolean, List<Integer>> partition = numbers.stream()
    .collect(Collectors.partitioningBy(num -> num % 2 == 0));
29. 그룹별 개수 계산
기존 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
Map<Integer, Integer> lengthCount = new HashMap<>();
for (String word : words) {
    int length = word.length();
    lengthCount.put(length, lengthCount.getOrDefault(length, 0) + 1);
}
Stream 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
Map<Integer, Long> lengthCount = words.stream()
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));
30. 그룹별 합계
기존 문법
class Order {
    private String category;
    private int amount;
    // constructor, getters
}

List<Order> orders = Arrays.asList(/*...*/);
Map<String, Integer> categorySum = new HashMap<>();
for (Order order : orders) {
    String category = order.getCategory();
    categorySum.put(category, 
        categorySum.getOrDefault(category, 0) + order.getAmount());
}
Stream 문법
List<Order> orders = Arrays.asList(/*...*/);
Map<String, Integer> categorySum = orders.stream()
    .collect(Collectors.groupingBy(Order::getCategory,
        Collectors.summingInt(Order::getAmount)));

조건 검사

31. 모든 요소가 조건 만족 검사
기존 문법
List<Integer> numbers = Arrays.asList(2, 4, 6, 8);
boolean allEven = true;
for (Integer num : numbers) {
    if (num % 2 != 0) {
        allEven = false;
        break;
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(2, 4, 6, 8);
boolean allEven = numbers.stream().allMatch(num -> num % 2 == 0);
32. 어떤 요소든 조건 만족 검사
기존 문법
List<Integer> numbers = Arrays.asList(1, 3, 5, 8);
boolean anyEven = false;
for (Integer num : numbers) {
    if (num % 2 == 0) {
        anyEven = true;
        break;
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 3, 5, 8);
boolean anyEven = numbers.stream().anyMatch(num -> num % 2 == 0);
33. 모든 요소가 조건 불만족 검사
기존 문법
List<Integer> numbers = Arrays.asList(1, 3, 5, 7);
boolean noneEven = true;
for (Integer num : numbers) {
    if (num % 2 == 0) {
        noneEven = false;
        break;
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 3, 5, 7);
boolean noneEven = numbers.stream().noneMatch(num -> num % 2 == 0);
34. 특정 값 포함 검사
기존 문법
List<String> names = Arrays.asList("김철수", "이영희", "박민수");
boolean containsKim = false;
for (String name : names) {
    if ("김철수".equals(name)) {
        containsKim = true;
        break;
    }
}
Stream 문법
List<String> names = Arrays.asList("김철수", "이영희", "박민수");
boolean containsKim = names.stream().anyMatch("김철수"::equals);
35. 리스트가 비어있는지 검사
기존 문법
List<String> list = Arrays.asList();
boolean isEmpty = list.size() == 0;
Stream 문법
List<String> list = Arrays.asList();
boolean isEmpty = list.stream().count() == 0;

중복 처리

36. 중복 제거
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 4);
Set<Integer> uniqueSet = new HashSet<>(numbers);
List<Integer> unique = new ArrayList<>(uniqueSet);
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 4);
List<Integer> unique = numbers.stream()
    .distinct()
    .collect(Collectors.toList());
37. 객체 특정 필드로 중복 제거
기존 문법
List<Person> people = Arrays.asList(/*...*/);
Map<String, Person> uniqueMap = new HashMap<>();
for (Person person : people) {
    uniqueMap.put(person.getName(), person);
}
List<Person> unique = new ArrayList<>(uniqueMap.values());
Stream 문법
List<Person> people = Arrays.asList(/*...*/);
List<Person> unique = people.stream()
    .collect(Collectors.toMap(Person::getName, 
        Function.identity(), (p1, p2) -> p1))
    .values()
    .stream()
    .collect(Collectors.toList());
38. 중복 요소 찾기
기존 문법
List<String> list = Arrays.asList("a", "b", "a", "c", "b");
Set<String> seen = new HashSet<>();
Set<String> duplicates = new HashSet<>();
for (String item : list) {
    if (!seen.add(item)) {
        duplicates.add(item);
    }
}
Stream 문법
List<String> list = Arrays.asList("a", "b", "a", "c", "b");
Set<String> duplicates = list.stream()
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
    .entrySet().stream()
    .filter(entry -> entry.getValue() > 1)
    .map(Map.Entry::getKey)
    .collect(Collectors.toSet());
39. 첫 번째 중복 요소 찾기
기존 문법
List<String> list = Arrays.asList("a", "b", "a", "c");
Set<String> seen = new HashSet<>();
String firstDuplicate = null;
for (String item : list) {
    if (!seen.add(item)) {
        firstDuplicate = item;
        break;
    }
}
Stream 문법
List<String> list = Arrays.asList("a", "b", "a", "c");
Set<String> seen = new HashSet<>();
Optional<String> firstDuplicate = list.stream()
    .filter(item -> !seen.add(item))
    .findFirst();
40. 중복 개수 계산
기존 문법
List<String> list = Arrays.asList("a", "b", "a", "c", "b", "a");
Map<String, Integer> counts = new HashMap<>();
for (String item : list) {
    counts.put(item, counts.getOrDefault(item, 0) + 1);
}
Stream 문법
List<String> list = Arrays.asList("a", "b", "a", "c", "b", "a");
Map<String, Long> counts = list.stream()
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

객체 처리

41. 객체 리스트에서 특정 필드 추출
기존 문법
class Employee {
    private String name;
    private String department;
    private int salary;
    // constructor, getters
}

List<Employee> employees = Arrays.asList(/*...*/);
List<String> departments = new ArrayList<>();
for (Employee emp : employees) {
    departments.add(emp.getDepartment());
}
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
List<String> departments = employees.stream()
    .map(Employee::getDepartment)
    .collect(Collectors.toList());
42. 조건에 맞는 객체 찾기
기존 문법
List<Employee> employees = Arrays.asList(/*...*/);
Employee found = null;
for (Employee emp : employees) {
    if (emp.getSalary() > 50000) {
        found = emp;
        break;
    }
}
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
Optional<Employee> found = employees.stream()
    .filter(emp -> emp.getSalary() > 50000)
    .findFirst();
43. 객체 필드별 정렬
기존 문법
List<Employee> employees = Arrays.asList(/*...*/);
Collections.sort(employees, new Comparator<Employee>() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return Integer.compare(e1.getSalary(), e2.getSalary());
    }
});
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
List<Employee> sorted = employees.stream()
    .sorted(Comparator.comparing(Employee::getSalary))
    .collect(Collectors.toList());
44. 객체를 Map으로 변환
기존 문법
List<Employee> employees = Arrays.asList(/*...*/);
Map<String, Employee> employeeMap = new HashMap<>();
for (Employee emp : employees) {
    employeeMap.put(emp.getName(), emp);
}
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
Map<String, Employee> employeeMap = employees.stream()
    .collect(Collectors.toMap(Employee::getName, Function.identity()));
45. 객체 필드 합계
기존 문법
List<Employee> employees = Arrays.asList(/*...*/);
int totalSalary = 0;
for (Employee emp : employees) {
    totalSalary += emp.getSalary();
}
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
int totalSalary = employees.stream()
    .mapToInt(Employee::getSalary)
    .sum();

복합 연산

46. 필터링 후 매핑
기존 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
List<String> result = new ArrayList<>();
for (String word : words) {
    if (word.length() > 3) {
        result.add(word.toUpperCase());
    }
}
Stream 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
List<String> result = words.stream()
    .filter(word -> word.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());
47. 매핑 후 정렬
기존 문법
List<String> names = Arrays.asList("김철수", "이영희", "박민수");
List<String> upperNames = new ArrayList<>();
for (String name : names) {
    upperNames.add(name.toUpperCase());
}
Collections.sort(upperNames);
Stream 문법
List<String> names = Arrays.asList("김철수", "이영희", "박민수");
List<String> result = names.stream()
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
48. 필터링, 매핑, 중복제거
기존 문법
List<String> words = Arrays.asList("java", "JAVA", "stream", "STREAM");
Set<String> uniqueUpper = new HashSet<>();
for (String word : words) {
    if (word.length() > 3) {
        uniqueUpper.add(word.toUpperCase());
    }
}
List<String> result = new ArrayList<>(uniqueUpper);
Stream 문법
List<String> words = Arrays.asList("java", "JAVA", "stream", "STREAM");
List<String> result = words.stream()
    .filter(word -> word.length() > 3)
    .map(String::toUpperCase)
    .distinct()
    .collect(Collectors.toList());
49. 두 리스트 합치기
기존 문법
List<String> list1 = Arrays.asList("a", "b", "c");
List<String> list2 = Arrays.asList("d", "e", "f");
List<String> combined = new ArrayList<>(list1);
combined.addAll(list2);
Stream 문법
List<String> list1 = Arrays.asList("a", "b", "c");
List<String> list2 = Arrays.asList("d", "e", "f");
List<String> combined = Stream.concat(list1.stream(), list2.stream())
    .collect(Collectors.toList());
50. 평탄화 (Flatten)
기존 문법
List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d"),
    Arrays.asList("e", "f")
);
List<String> flattened = new ArrayList<>();
for (List<String> list : listOfLists) {
    flattened.addAll(list);
}
Stream 문법
List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d"),
    Arrays.asList("e", "f")
);
List<String> flattened = listOfLists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList());
51. 조건부 매핑
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<String> result = new ArrayList<>();
for (Integer num : numbers) {
    if (num % 2 == 0) {
        result.add("짝수: " + num);
    } else {
        result.add("홀수: " + num);
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<String> result = numbers.stream()
    .map(num -> (num % 2 == 0) ? "짝수: " + num : "홀수: " + num)
    .collect(Collectors.toList());
52. 상위 N개 요소
기존 문법
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9, 3);
Collections.sort(numbers, Collections.reverseOrder());
List<Integer> top3 = new ArrayList<>();
for (int i = 0; i < Math.min(3, numbers.size()); i++) {
    top3.add(numbers.get(i));
}
Stream 문법
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9, 3);
List<Integer> top3 = numbers.stream()
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());
53. 건너뛰기 (Skip)
기존 문법
List<String> list = Arrays.asList("a", "b", "c", "d", "e");
List<String> skipped = new ArrayList<>();
for (int i = 2; i < list.size(); i++) {
    skipped.add(list.get(i));
}
Stream 문법
List<String> list = Arrays.asList("a", "b", "c", "d", "e");
List<String> skipped = list.stream()
    .skip(2)
    .collect(Collectors.toList());
54. 문자열 연결
기존 문법
List<String> words = Arrays.asList("Hello", "Stream", "API");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < words.size(); i++) {
    if (i > 0) sb.append(" ");
    sb.append(words.get(i));
}
String joined = sb.toString();
Stream 문법
List<String> words = Arrays.asList("Hello", "Stream", "API");
String joined = words.stream()
    .collect(Collectors.joining(" "));
55. Optional 처리
기존 문법
List<String> list = Arrays.asList("a", "b", "c");
String first = null;
if (!list.isEmpty()) {
    first = list.get(0);
}
String result = (first != null) ? first.toUpperCase() : "DEFAULT";
Stream 문법
List<String> list = Arrays.asList("a", "b", "c");
String result = list.stream()
    .findFirst()
    .map(String::toUpperCase)
    .orElse("DEFAULT");
56. 인덱스와 함께 처리
기존 문법
List<String> list = Arrays.asList("a", "b", "c");
List<String> indexed = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
    indexed.add(i + ": " + list.get(i));
}
Stream 문법
List<String> list = Arrays.asList("a", "b", "c");
List<String> indexed = IntStream.range(0, list.size())
    .mapToObj(i -> i + ": " + list.get(i))
    .collect(Collectors.toList());
57. 조건부 필터링과 변환
기존 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
List<Integer> lengths = new ArrayList<>();
for (String word : words) {
    if (word.startsWith("s")) {
        lengths.add(word.length());
    }
}
Stream 문법
List<String> words = Arrays.asList("java", "stream", "api", "collection");
List<Integer> lengths = words.stream()
    .filter(word -> word.startsWith("s"))
    .map(String::length)
    .collect(Collectors.toList());
58. 분할 정복 (Reduce)
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int product = 1;
for (Integer num : numbers) {
    product *= num;
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int product = numbers.stream()
    .reduce(1, (a, b) -> a * b);
59. 범위 생성
기존 문법
List<Integer> range = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
    range.add(i);
}
Stream 문법
List<Integer> range = IntStream.rangeClosed(1, 10)
    .boxed()
    .collect(Collectors.toList());
60. 무한 스트림
기존 문법
List<Integer> first10Even = new ArrayList<>();
int current = 0;
while (first10Even.size() < 10) {
    if (current % 2 == 0) {
        first10Even.add(current);
    }
    current++;
}
Stream 문법
List<Integer> first10Even = Stream.iterate(0, n -> n + 1)
    .filter(n -> n % 2 == 0)
    .limit(10)
    .collect(Collectors.toList());
61. 날짜 처리
기존 문법
List<Date> dates = Arrays.asList(/*...*/);
List<Date> recentDates = new ArrayList<>();
Date cutoff = new Date(System.currentTimeMillis() - 7 * 24 * 60 * 60 * 1000);
for (Date date : dates) {
    if (date.after(cutoff)) {
        recentDates.add(date);
    }
}
Stream 문법
List<Date> dates = Arrays.asList(/*...*/);
Date cutoff = new Date(System.currentTimeMillis() - 7 * 24 * 60 * 60 * 1000);
List<Date> recentDates = dates.stream()
    .filter(date -> date.after(cutoff))
    .collect(Collectors.toList());
62. 파일 처리
기존 문법
List<File> files = Arrays.asList(/*...*/);
List<String> fileNames = new ArrayList<>();
for (File file : files) {
    if (file.isFile() && file.getName().endsWith(".txt")) {
        fileNames.add(file.getName());
    }
}
Stream 문법
List<File> files = Arrays.asList(/*...*/);
List<String> fileNames = files.stream()
    .filter(File::isFile)
    .filter(file -> file.getName().endsWith(".txt"))
    .map(File::getName)
    .collect(Collectors.toList());
63. 예외 처리가 있는 매핑
기존 문법
List<String> urls = Arrays.asList("http://example1.com", "http://example2.com");
List<Integer> contentLengths = new ArrayList<>();
for (String url : urls) {
    try {
        URL urlObj = new URL(url);
        contentLengths.add(url.length()); // 단순화된 예제
    } catch (Exception e) {
        contentLengths.add(0);
    }
}
Stream 문법
List<String> urls = Arrays.asList("http://example1.com", "http://example2.com");
List<Integer> contentLengths = urls.stream()
    .map(url -> {
        try {
            return new URL(url).toString().length();
        } catch (Exception e) {
            return 0;
        }
    })
    .collect(Collectors.toList());
64. Set 변환
기존 문법
List<String> list = Arrays.asList("a", "b", "a", "c", "b");
Set<String> set = new HashSet<>();
for (String item : list) {
    set.add(item.toUpperCase());
}
Stream 문법
List<String> list = Arrays.asList("a", "b", "a", "c", "b");
Set<String> set = list.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toSet());
65. 조건부 수집
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = new ArrayList<>();
List<Integer> oddNumbers = new ArrayList<>();
for (Integer num : numbers) {
    if (num % 2 == 0) {
        evenNumbers.add(num);
    } else {
        oddNumbers.add(num);
    }
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Map<Boolean, List<Integer>> partitioned = numbers.stream()
    .collect(Collectors.partitioningBy(num -> num % 2 == 0));
List<Integer> evenNumbers = partitioned.get(true);
List<Integer> oddNumbers = partitioned.get(false);
66. 통계 계산
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0, min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
for (Integer num : numbers) {
    sum += num;
    min = Math.min(min, num);
    max = Math.max(max, num);
}
double average = (double) sum / numbers.size();
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
IntSummaryStatistics stats = numbers.stream()
    .mapToInt(Integer::intValue)
    .summaryStatistics();
67. 임의 요소 선택
기존 문법
List<String> list = Arrays.asList("a", "b", "c", "d");
Random random = new Random();
String randomElement = list.get(random.nextInt(list.size()));
Stream 문법
List<String> list = Arrays.asList("a", "b", "c", "d");
Optional<String> randomElement = list.stream()
    .skip((int) (list.size() * Math.random()))
    .findFirst();
68. 배열로 변환
기존 문법
List<String> list = Arrays.asList("a", "b", "c");
String[] array = new String[list.size()];
for (int i = 0; i < list.size(); i++) {
    array[i] = list.get(i);
}
Stream 문법
List<String> list = Arrays.asList("a", "b", "c");
String[] array = list.stream().toArray(String[]::new);
69. 정규식 필터링
기존 문법
List<String> emails = Arrays.asList("test@email.com", "invalid-email", "user@domain.org");
List<String> validEmails = new ArrayList<>();
Pattern pattern = Pattern.compile("^[A-Za-z0-9+_.-]+@(.+)$");
for (String email : emails) {
    if (pattern.matcher(email).matches()) {
        validEmails.add(email);
    }
}
Stream 문법
List<String> emails = Arrays.asList("test@email.com", "invalid-email", "user@domain.org");
Pattern pattern = Pattern.compile("^[A-Za-z0-9+_.-]+@(.+)$");
List<String> validEmails = emails.stream()
    .filter(email -> pattern.matcher(email).matches())
    .collect(Collectors.toList());
70. 문자열 분할 및 평탄화
기존 문법
List<String> sentences = Arrays.asList("Hello World", "Java Stream API");
List<String> words = new ArrayList<>();
for (String sentence : sentences) {
    String[] splitWords = sentence.split(" ");
    for (String word : splitWords) {
        words.add(word);
    }
}
Stream 문법
List<String> sentences = Arrays.asList("Hello World", "Java Stream API");
List<String> words = sentences.stream()
    .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
    .collect(Collectors.toList());
71. 병렬 처리
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> squares = new ArrayList<>();
// 병렬 처리를 위해서는 별도의 복잡한 코드가 필요
for (Integer num : numbers) {
    squares.add(num * num);
}
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> squares = numbers.parallelStream()
    .map(num -> num * num)
    .collect(Collectors.toList());
72. 조건부 존재 확인
기존 문법
List<Person> people = Arrays.asList(/*...*/);
boolean hasAdult = false;
for (Person person : people) {
    if (person.getAge() >= 18) {
        hasAdult = true;
        break;
    }
}
Stream 문법
List<Person> people = Arrays.asList(/*...*/);
boolean hasAdult = people.stream()
    .anyMatch(person -> person.getAge() >= 18);
73. 다중 조건 필터링
기존 문법
List<Employee> employees = Arrays.asList(/*...*/);
List<Employee> filtered = new ArrayList<>();
for (Employee emp : employees) {
    if (emp.getDepartment().equals("IT") && 
        emp.getSalary() > 50000 && 
        emp.getExperience() > 2) {
        filtered.add(emp);
    }
}
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
List<Employee> filtered = employees.stream()
    .filter(emp -> emp.getDepartment().equals("IT"))
    .filter(emp -> emp.getSalary() > 50000)
    .filter(emp -> emp.getExperience() > 2)
    .collect(Collectors.toList());
74. 조건부 매핑과 필터링
기존 문법
List<String> items = Arrays.asList("apple", "banana", "cherry", "date");
List<String> result = new ArrayList<>();
for (String item : items) {
    if (item.length() > 5) {
        String upper = item.toUpperCase();
        if (upper.contains("A")) {
            result.add(upper);
        }
    }
}
Stream 문법
List<String> items = Arrays.asList("apple", "banana", "cherry", "date");
List<String> result = items.stream()
    .filter(item -> item.length() > 5)
    .map(String::toUpperCase)
    .filter(upper -> upper.contains("A"))
    .collect(Collectors.toList());
75. 최댓값 객체 찾기
기존 문법
List<Employee> employees = Arrays.asList(/*...*/);
Employee highestPaid = null;
for (Employee emp : employees) {
    if (highestPaid == null || emp.getSalary() > highestPaid.getSalary()) {
        highestPaid = emp;
    }
}
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
Optional<Employee> highestPaid = employees.stream()
    .max(Comparator.comparing(Employee::getSalary));
76. 문자열 변환 및 연결
기존 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < numbers.size(); i++) {
    if (i > 0) sb.append(", ");
    sb.append("Number: ").append(numbers.get(i));
}
String result = sb.toString();
Stream 문법
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
String result = numbers.stream()
    .map(num -> "Number: " + num)
    .collect(Collectors.joining(", "));
77. 타입 변환
기존 문법
List<String> stringNumbers = Arrays.asList("1", "2", "3", "4", "5");
List<Integer> integers = new ArrayList<>();
for (String str : stringNumbers) {
    try {
        integers.add(Integer.parseInt(str));
    } catch (NumberFormatException e) {
        // 무시하거나 기본값 사용
    }
}
Stream 문법
List<String> stringNumbers = Arrays.asList("1", "2", "3", "4", "5");
List<Integer> integers = stringNumbers.stream()
    .mapToInt(Integer::parseInt)
    .boxed()
    .collect(Collectors.toList());
78. 조건부 집계
기존 문법
List<Order> orders = Arrays.asList(/*...*/);
int totalAmount = 0;
for (Order order : orders) {
    if (order.getStatus().equals("COMPLETED")) {
        totalAmount += order.getAmount();
    }
}
Stream 문법
List<Order> orders = Arrays.asList(/*...*/);
int totalAmount = orders.stream()
    .filter(order -> order.getStatus().equals("COMPLETED"))
    .mapToInt(Order::getAmount)
    .sum();
79. 중첩 객체 처리
기존 문법
class Department {
    private List<Employee> employees;
    // constructor, getters
}

List<Department> departments = Arrays.asList(/*...*/);
List<Employee> allEmployees = new ArrayList<>();
for (Department dept : departments) {
    allEmployees.addAll(dept.getEmployees());
}
Stream 문법
List<Department> departments = Arrays.asList(/*...*/);
List<Employee> allEmployees = departments.stream()
    .flatMap(dept -> dept.getEmployees().stream())
    .collect(Collectors.toList());
80. 조건부 그룹핑
기존 문법
List<Student> students = Arrays.asList(/*...*/);
Map<String, List<Student>> gradeGroups = new HashMap<>();
for (Student student : students) {
    String grade = student.getScore() >= 90 ? "A" : 
                  student.getScore() >= 80 ? "B" : "C";
    if (!gradeGroups.containsKey(grade)) {
        gradeGroups.put(grade, new ArrayList<>());
    }
    gradeGroups.get(grade).add(student);
}
Stream 문법
List<Student> students = Arrays.asList(/*...*/);
Map<String, List<Student>> gradeGroups = students.stream()
    .collect(Collectors.groupingBy(student -> 
        student.getScore() >= 90 ? "A" : 
        student.getScore() >= 80 ? "B" : "C"));
81. 순차적 처리
기존 문법
List<String> items = Arrays.asList("apple", "banana", "cherry");
List<String> processed = new ArrayList<>();
for (String item : items) {
    String step1 = item.toUpperCase();
    String step2 = step1.replace('A', '*');
    String step3 = step2 + "_PROCESSED";
    processed.add(step3);
}
Stream 문법
List<String> items = Arrays.asList("apple", "banana", "cherry");
List<String> processed = items.stream()
    .map(String::toUpperCase)
    .map(s -> s.replace('A', '*'))
    .map(s -> s + "_PROCESSED")
    .collect(Collectors.toList());
82. 필터링된 합계
기존 문법
List<Product> products = Arrays.asList(/*...*/);
double totalPrice = 0.0;
for (Product product : products) {
    if (product.getCategory().equals("ELECTRONICS") && product.getPrice() > 100) {
        totalPrice += product.getPrice();
    }
}
Stream 문법
List<Product> products = Arrays.asList(/*...*/);
double totalPrice = products.stream()
    .filter(p -> p.getCategory().equals("ELECTRONICS"))
    .filter(p -> p.getPrice() > 100)
    .mapToDouble(Product::getPrice)
    .sum();
83. 최빈값 찾기
기존 문법
List<String> items = Arrays.asList("apple", "banana", "apple", "cherry", "banana", "apple");
Map<String, Integer> counts = new HashMap<>();
for (String item : items) {
    counts.put(item, counts.getOrDefault(item, 0) + 1);
}
String mostFrequent = null;
int maxCount = 0;
for (Map.Entry<String, Integer> entry : counts.entrySet()) {
    if (entry.getValue() > maxCount) {
        maxCount = entry.getValue();
        mostFrequent = entry.getKey();
    }
}
Stream 문법
List<String> items = Arrays.asList("apple", "banana", "apple", "cherry", "banana", "apple");
Optional<String> mostFrequent = items.stream()
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
    .entrySet().stream()
    .max(Map.Entry.comparingByValue())
    .map(Map.Entry::getKey);
84. 조건부 변환
기존 문법
List<Employee> employees = Arrays.asList(/*...*/);
List<String> descriptions = new ArrayList<>();
for (Employee emp : employees) {
    String desc;
    if (emp.getSalary() > 80000) {
        desc = emp.getName() + " (Senior)";
    } else if (emp.getSalary() > 50000) {
        desc = emp.getName() + " (Mid)";
    } else {
        desc = emp.getName() + " (Junior)";
    }
    descriptions.add(desc);
}
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
List<String> descriptions = employees.stream()
    .map(emp -> emp.getName() + " (" + 
        (emp.getSalary() > 80000 ? "Senior" : 
         emp.getSalary() > 50000 ? "Mid" : "Junior") + ")")
    .collect(Collectors.toList());
85. 중복 제거 후 정렬
기존 문법
List<String> words = Arrays.asList("banana", "apple", "cherry", "apple", "banana");
Set<String> uniqueSet = new HashSet<>(words);
List<String> uniqueSorted = new ArrayList<>(uniqueSet);
Collections.sort(uniqueSorted);
Stream 문법
List<String> words = Arrays.asList("banana", "apple", "cherry", "apple", "banana");
List<String> uniqueSorted = words.stream()
    .distinct()
    .sorted()
    .collect(Collectors.toList());
86. 범위별 그룹핑
기존 문법
List<Integer> ages = Arrays.asList(15, 25, 35, 45, 55, 65);
Map<String, List<Integer>> ageGroups = new HashMap<>();
ageGroups.put("Young", new ArrayList<>());
ageGroups.put("Middle", new ArrayList<>());
ageGroups.put("Senior", new ArrayList<>());

for (Integer age : ages) {
    if (age < 30) {
        ageGroups.get("Young").add(age);
    } else if (age < 50) {
        ageGroups.get("Middle").add(age);
    } else {
        ageGroups.get("Senior").add(age);
    }
}
Stream 문법
List<Integer> ages = Arrays.asList(15, 25, 35, 45, 55, 65);
Map<String, List<Integer>> ageGroups = ages.stream()
    .collect(Collectors.groupingBy(age -> 
        age < 30 ? "Young" : age < 50 ? "Middle" : "Senior"));
87. 필터링된 매핑 및 수집
기존 문법
List<String> sentences = Arrays.asList("Hello world", "Java stream", "API programming");
Set<String> longWords = new HashSet<>();
for (String sentence : sentences) {
    String[] words = sentence.split(" ");
    for (String word : words) {
        if (word.length() > 4) {
            longWords.add(word.toLowerCase());
        }
    }
}
Stream 문법
List<String> sentences = Arrays.asList("Hello world", "Java stream", "API programming");
Set<String> longWords = sentences.stream()
    .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
    .filter(word -> word.length() > 4)
    .map(String::toLowerCase)
    .collect(Collectors.toSet());
88. 조건부 수집과 변환
기존 문법
List<Order> orders = Arrays.asList(/*...*/);
List<String> expensiveOrderIds = new ArrayList<>();
for (Order order : orders) {
    if (order.getAmount() > 1000) {
        expensiveOrderIds.add("ORD-" + order.getId());
    }
}
Stream 문법
List<Order> orders = Arrays.asList(/*...*/);
List<String> expensiveOrderIds = orders.stream()
    .filter(order -> order.getAmount() > 1000)
    .map(order -> "ORD-" + order.getId())
    .collect(Collectors.toList());
89. 문자열 처리 및 집계
기존 문법
List<String> texts = Arrays.asList("Hello", "World", "Java", "Stream");
int totalLength = 0;
int wordCount = 0;
for (String text : texts) {
    if (text.length() > 3) {
        totalLength += text.length();
        wordCount++;
    }
}
double averageLength = wordCount > 0 ? (double) totalLength / wordCount : 0;
Stream 문법
List<String> texts = Arrays.asList("Hello", "World", "Java", "Stream");
OptionalDouble averageLength = texts.stream()
    .filter(text -> text.length() > 3)
    .mapToInt(String::length)
    .average();
90. 복합 조건 검사
기존 문법
List<Product> products = Arrays.asList(/*...*/);
boolean hasExpensiveElectronics = false;
for (Product product : products) {
    if (product.getCategory().equals("ELECTRONICS") && 
        product.getPrice() > 500 && 
        product.isInStock()) {
        hasExpensiveElectronics = true;
        break;
    }
}
Stream 문법
List<Product> products = Arrays.asList(/*...*/);
boolean hasExpensiveElectronics = products.stream()
    .anyMatch(product -> product.getCategory().equals("ELECTRONICS") &&
                        product.getPrice() > 500 &&
                        product.isInStock());
91. 커스텀 정렬
기존 문법
List<Student> students = Arrays.asList(/*...*/);
Collections.sort(students, new Comparator<Student>() {
    @Override
    public int compare(Student s1, Student s2) {
        int gradeCompare = s2.getGrade().compareTo(s1.getGrade()); // 역순
        if (gradeCompare != 0) return gradeCompare;
        return s1.getName().compareTo(s2.getName()); // 이름 오름차순
    }
});
Stream 문법
List<Student> students = Arrays.asList(/*...*/);
List<Student> sorted = students.stream()
    .sorted(Comparator.comparing(Student::getGrade).reversed()
            .thenComparing(Student::getName))
    .collect(Collectors.toList());
92. 조건부 평균 계산
기존 문법
List<Employee> employees = Arrays.asList(/*...*/);
int totalSalary = 0;
int count = 0;
for (Employee emp : employees) {
    if (emp.getDepartment().equals("IT")) {
        totalSalary += emp.getSalary();
        count++;
    }
}
double averageSalary = count > 0 ? (double) totalSalary / count : 0;
Stream 문법
List<Employee> employees = Arrays.asList(/*...*/);
OptionalDouble averageSalary = employees.stream()
    .filter(emp -> emp.getDepartment().equals("IT"))
    .mapToInt(Employee::getSalary)
    .average();
93. 다중 리스트 처리
기존 문법
List<List<Integer>> numberLists = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);
List<Integer> evenNumbers = new ArrayList<>();
for (List<Integer> list : numberLists) {
    for (Integer num : list) {
        if (num % 2 == 0) {
            evenNumbers.add(num);
        }
    }
}
Stream 문법
List<List<Integer>> numberLists = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);
List<Integer> evenNumbers = numberLists.stream()
    .flatMap(List::stream)
    .filter(num -> num % 2 == 0)
    .collect(Collectors.toList());
94. 조건부 문자열 연결
기존 문법
List<Person> people = Arrays.asList(/*...*/);
StringBuilder sb = new StringBuilder();
boolean first = true;
for (Person person : people) {
    if (person.getAge() > 18) {
        if (!first) sb.append(", ");
        sb.append(person.getName());
        first = false;
    }
}
String adultNames = sb.toString();
Stream 문법
List<Person> people = Arrays.asList(/*...*/);
String adultNames = people.stream()
    .filter(person -> person.getAge() > 18)
    .map(Person::getName)
    .collect(Collectors.joining(", "));
95. 계층 구조 처리
기존 문법
class Category {
    private String name;
    private List<Category> subcategories;
    // constructor, getters
}

List<Category> categories = Arrays.asList(/*...*/);
List<String> allCategoryNames = new ArrayList<>();
for (Category category : categories) {
    allCategoryNames.add(category.getName());
    for (Category sub : category.getSubcategories()) {
        allCategoryNames.add(sub.getName());
    }
}
Stream 문법
List<Category> categories = Arrays.asList(/*...*/);
List<String> allCategoryNames = categories.stream()
    .flatMap(category -> Stream.concat(
        Stream.of(category.getName()),
        category.getSubcategories().stream().map(Category::getName)
    ))
    .collect(Collectors.toList());
96. 시간 기반 필터링
기존 문법
List<Event> events = Arrays.asList(/*...*/);
List<Event> recentEvents = new ArrayList<>();
long weekAgo = System.currentTimeMillis() - (7 * 24 * 60 * 60 * 1000);
for (Event event : events) {
    if (event.getTimestamp() > weekAgo) {
        recentEvents.add(event);
    }
}
Stream 문법
List<Event> events = Arrays.asList(/*...*/);
long weekAgo = System.currentTimeMillis() - (7 * 24 * 60 * 60 * 1000);
List<Event> recentEvents = events.stream()
    .filter(event -> event.getTimestamp() > weekAgo)
    .collect(Collectors.toList());
97. 가중 평균 계산
기존 문법
class WeightedValue {
    private double value;
    private double weight;
    // constructor, getters
}

List<WeightedValue> values = Arrays.asList(/*...*/);
double totalWeightedSum = 0;
double totalWeight = 0;
for (WeightedValue wv : values) {
    totalWeightedSum += wv.getValue() * wv.getWeight();
    totalWeight += wv.getWeight();
}
double weightedAverage = totalWeight > 0 ? totalWeightedSum / totalWeight : 0;
Stream 문법
List<WeightedValue> values = Arrays.asList(/*...*/);
double totalWeightedSum = values.stream()
    .mapToDouble(wv -> wv.getValue() * wv.getWeight())
    .sum();
double totalWeight = values.stream()
    .mapToDouble(WeightedValue::getWeight)
    .sum();
double weightedAverage = totalWeight > 0 ? totalWeightedSum / totalWeight : 0;
98. 페이지네이션
기존 문법
List<Item> items = Arrays.asList(/*...*/);
int pageSize = 5;
int pageNumber = 2; // 0-based
List<Item> page = new ArrayList<>();
int start = pageNumber * pageSize;
int end = Math.min(start + pageSize, items.size());
for (int i = start; i < end; i++) {
    page.add(items.get(i));
}
Stream 문법
List<Item> items = Arrays.asList(/*...*/);
int pageSize = 5;
int pageNumber = 2; // 0-based
List<Item> page = items.stream()
    .skip(pageNumber * pageSize)
    .limit(pageSize)
    .collect(Collectors.toList());
99. 복잡한 변환 체인
기존 문법
List<String> rawData = Arrays.asList("  Apple  ", "  BANANA  ", "  cherry  ");
List<String> processed = new ArrayList<>();
for (String data : rawData) {
    String trimmed = data.trim();
    if (!trimmed.isEmpty()) {
        String normalized = trimmed.toLowerCase();
        String capitalized = Character.toUpperCase(normalized.charAt(0)) + 
                           normalized.substring(1);
        processed.add(capitalized);
    }
}
Stream 문법
List<String> rawData = Arrays.asList("  Apple  ", "  BANANA  ", "  cherry  ");
List<String> processed = rawData.stream()
    .map(String::trim)
    .filter(s -> !s.isEmpty())
    .map(String::toLowerCase)
    .map(s -> Character.toUpperCase(s.charAt(0)) + s.substring(1))
    .collect(Collectors.toList());
100. 통합 리포트 생성
기존 문법
class Sale {
    private String product;
    private String region;
    private double amount;
    // constructor, getters
}

List<Sale> sales = Arrays.asList(/*...*/);
Map<String, Map<String, Double>> report = new HashMap<>();
for (Sale sale : sales) {
    if (!report.containsKey(sale.getRegion())) {
        report.put(sale.getRegion(), new HashMap<>());
    }
    Map<String, Double> regionSales = report.get(sale.getRegion());
    regionSales.put(sale.getProduct(), 
        regionSales.getOrDefault(sale.getProduct(), 0.0) + sale.getAmount());
}
Stream 문법
List<Sale> sales = Arrays.asList(/*...*/);
Map<String, Map<String, Double>> report = sales.stream()
    .collect(Collectors.groupingBy(Sale::getRegion,
        Collectors.groupingBy(Sale::getProduct,
            Collectors.summingDouble(Sale::getAmount))));
반응형
저작자표시 (새창열림)

'개발 > java' 카테고리의 다른 글

주요 함수형 인터페이스  (0) 2024.05.19
java.lang.nullpointerexception 오류 예방  (0) 2023.03.28
Java Generics  (0) 2022.02.25
Stream 예제  (0) 2022.02.06
JSch를 사용한 JAVA SFTP 업로드 다운로드 예제 (개인키, 패스워스)  (3) 2021.08.18

관련글

댓글

티스토리툴바