codesche’s blog

/

/

/

Database & Infra

codesche’s blog

/

/

/

Share

Database & Infra

stream

stream

Search

•게시판 관련 기능을 담은 인터페이스 구현 로직
package com.practice;

import java.util.List;
import java.util.Map;

public interface PostSystem {
    // 특정 작성자(author)가 작성한 게시물들을 필터링하여 반환하는 메소드
    List<Post> filterPostsByAuthor(List<Post> posts, String author);

    // 모든 게시물의 댓글을 추출하여 리스트로 반환하는 메소드
    List<Comment> getAllComments(List<Post> posts);

    // 모든 게시물의 제목을 추출하여 리스트로 반환하는 메소드
    List<String> getAllPostTitles(List<Post> posts);

    // 특정 키워드(keyword)를 포함하는 게시물들을 필터링하여 반환하는 메소드
    List<Post> filterPostsByKeyword(List<Post> posts, String keyword);

    // 각 게시물의 댓글 수를 계산하여 맵 형태로 반환하는 메소드
    // 게시물 ID를 키로 하고 댓글 수를 값으로 하는 맵
    Map<Integer, Integer> getCommentCountByPost(List<Post> posts);

    // 최신 게시물 3개를 추출하여 리스트로 반환하는 메소드
    List<Post> getLatestPosts(List<Post> posts);

    // 게시물 번호 중 가장 높은 게시물 번호를 반환하는 메소드
    int getHighestPostId(List<Post> posts);

    // 게시물 입력 받기 메소드
    void insertPost(List<Post> pList);
}
•인터페이스에서 구현한 메소드의 구체적인 동작 구현을 정리한 코드
package com.practice;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

public class PostSystemImpl implements PostSystem {
		
		// 특정 작성자(author)가 작성한 게시물들을 필터링하여 반환하는 메소드
    @Override
    public List<Post> filterPostsByAuthor(List<Post> posts, String author) {
        return posts
                .stream()
                .filter(post -> post.getAuthor().equals(author))
                .collect(Collectors.toList());
    }

		// 모든 게시물의 댓글을 추출하여 리스트로 반환하는 메소드 - flatMap 활용하여 stream 변환
    @Override
    public List<Comment> getAllComments(List<Post> posts) {
        return posts
                .stream()
                .flatMap(post -> post.getComments().stream())  // stream으로 변환
                .collect(Collectors.toList());
    }

		// 모든 게시물의 제목을 추출하여 리스트로 반환하는 메소드
    @Override
    public List<String> getAllPostTitles(List<Post> posts) {
        return posts.stream()
                .map(Post::getTitle)
                .collect(Collectors.toList());
    }

		// 특정 키워드(keyword)를 포함하는 게시물들을 필터링하여 반환하는 메소드 - 제목 or 내용 포함
    @Override
    public List<Post> filterPostsByKeyword(List<Post> posts, String keyword) {
        return posts.stream()
                .filter(post -> post.getContent().contains(keyword) || post.getTitle().contains(keyword))
                .collect(Collectors.toList());
    }
		
		// 각 게시물의 댓글 수를 계산하여 맵 형태로 반환하는 메소드
    // 게시물 ID를 키로 하고 댓글 수를 값으로 하는 맵
    @Override
    public Map<Integer, Integer> getCommentCountByPost(List<Post> posts) {
        return posts
                .stream()
                .collect(Collectors.toMap(
                        post -> post.getId(),
                        post -> post.getComments().size()
                ));
    }
		
		// 최신 게시물 3개를 추출하여 리스트로 반환하는 메소드
    @Override
    public List<Post> getLatestPosts(List<Post> posts) {
        return posts
                .stream()
//                .sorted((p1, p2) -> p2.getCreatedAt().compareTo(p1.getCreatedAt()))
                .sorted(Comparator.comparing(Post::getCreatedAt).reversed())
                .limit(3)                         // 페이지 검색 조회 수 제한
                .collect(Collectors.toList());
    }
		
		// 게시물 번호 중 가장 높은 게시물 번호를 반환하는 메소드
    @Override
    public int getHighestPostId(List<Post> posts) {
        Optional<Post> optMaxPost = posts
                .stream()
                .max(Comparator.comparing(Post::getId));

        Post p = optMaxPost.orElse(null);
        return p == null ? 0 : p.getId();
    }
		
		// 게시물 입력 받기 메소드
    @Override
    public void insertPost(List<Post> pList) {
        System.out.println("게시물 작성");
        Scanner sc = new Scanner(System.in);
        System.out.println("제목 입력 : ");
        String title = sc.nextLine();
        System.out.println("내용 입력 : ");
        String content = sc.nextLine();
        System.out.println("이름 입력 : ");
        String author = sc.nextLine();
        pList.add(new Post(getHighestPostId(pList) + 1, title, content,
                author, LocalDateTime.now(), new ArrayList<Comment>()));
        sc.close();
    }
}

게시판 관련 메소드 정리

필터링(filtering)
Stream은 컬렉션의 요소를 필터링하는 기능을 제공한다. 
filter() 메서드를 사용하여 조건에 맞는 요소만 선택할 수 있다.
// 예시
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                    .filter(n -> n % 2 == 0)
                                    .collect(Collectors.toList());
// evenNumbers: [2, 4]
매핑(mapping)
Stream은 컬렉션의 요소를 다른 값으로 변환하는 매핑 기능을 제공한다. 
map() 메서드를 사용하여 각 요소를 원하는 값으로 변환할 수 있다.
// 예시
List<String> names = Arrays.asList("John", "Paul", "George", "Ringo");
List<Integer> nameLengths = names.stream()
                                  .map(String::length)
                                  .collect(Collectors.toList());
// nameLengths: [4, 4, 6, 5]

java stream 사용법 정리

•Order
package com.stream;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.List;

@Data
@AllArgsConstructor
public class Order {
    private List<Product> products;
}
•Product
package com.stream;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Product {
    private String name;
}
•User
package com.stream;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Product {
    private String name;
}
•PracticeExample

stream 예제 코드 1

•병렬 스트림(parallelStream) 관련 코드 예제
package com.stream1;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamExample {
    public static void main(String[] args) {
        List<String> languageList = new ArrayList<>();
        languageList.add("Java");
        languageList.add("JavaScript");
        languageList.add("Python");
        languageList.add("C");

        // 병렬 스트림 얻기
        Stream<String> parallelStream = languageList.parallelStream();
        parallelStream.forEach(name -> {
            System.out.println(name + " : " + Thread.currentThread().getName());
        });

        System.out.println("===============================================");

        // for 문으로 동작시키기
        for (String name : languageList) {
            System.out.println(name + " : " + Thread.currentThread().getName());
        }
    }
}

stream 예제 코드 2 - 병렬 스트림

•Student.java
package com.stream2;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Student {
    private String name;
    private int score;
}
•StreamExample.java
package com.stream2;

import java.util.Arrays;
import java.util.List;
import java.util.OptionalDouble;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamExample {
    public static void main(String[] args) {
        List<Student> sList = Arrays.asList(
             new Student("Alice", 90),
             new Student("Bob", 80),
             new Student("Jonathan", 85),
             new Student("David", 95)
        );

//        Stream<Student> originalStream = sList.stream();
//        IntStream intStream = originalStream.mapToInt(Student::getScore);
//        OptionalDouble optAverage = intStream.average();
//        double avg = optAverage.getAsDouble();

        double avg = sList.stream()
                .mapToInt(Student::getScore).  // s -> s.getScore()
                .average()
                .getAsDouble();

        System.out.println(avg);
    }
}

stream 예제 코드 3 - mapToInt, average()

•Product.java
package com.stream3;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Product {
    private int pno, price;
    private String name, company;
}
•ProductExample.java
package com.stream3;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class ProductExample {
    public static void main(String[] args) {
        List<Product> pList = new ArrayList<>();

        for (int i = 1; i <= 5; i++) {
            Product p = new Product(i, (int) (10000 * Math.random()), "상품" + i, "회사명");
            pList.add(p);
        }

//        Stream<Product> stream = pList.stream();
        double proWithAvg = pList.stream()
                        .mapToInt(Product::getPrice)
                        .average()
                        .getAsDouble();
        pList.stream().forEach(System.out::println);
        System.out.println(proWithAvg);
    }
}

stream 예제 코드 4

•배열로부터 스트림 얻는 방법 정리
package com.stream4;

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamExample {
    public static void main(String[] args) {
        String[] strArr = {"맥북", "이어폰", "에어팟"};
        // 배열로부터 스트림 얻는 두 가지 방법
        Stream<String> strStream1 = Stream.of(strArr);
        Stream<String> strStream2 = Arrays.stream(strArr);

        strStream1.forEach(i -> System.out.print(i + ", "));
        System.out.println();
        strStream2.forEach(i -> System.out.print(i + ", "));

        System.out.println("\n");

        int[] intArr = { 3, 1, 4, 1, 5, 9, 2 };
        // 배열로부터 스트림 얻는 두 가지 방법
        IntStream intStream1 = IntStream.of(intArr);
        IntStream intStream2 = Arrays.stream(intArr);

        intStream1.forEach(i -> System.out.print(i + ", "));
        System.out.println();
        intStream2.forEach(i -> System.out.print(i + ", "));
    }
}

stream 예제 코드 5 - 배열로부터 스트림 얻는 방법

•Product.java
package com.stream6;

import lombok.AllArgsConstructor;
import lombok.Data;

@AllArgsConstructor
@Data
public class Product {
    private int pno;
    private String pname;
    private String pCompany;
    private int price;
}
•StreamExample.java
package com.stream6;

import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class StreamExample {
    public static void main(String[] args) throws IOException {
        String absolutePath = "/Users/haminsung/Desktop/test/java/data.txt";
        Path path = Paths.get(absolutePath);

        Stream<String> stream = Files.lines(path, Charset.defaultCharset());
//        stream.forEach(line -> System.out.println(line));
        stream.forEach(l -> {
            String[] productInfo = l.split(" ");
            int pno = Integer.parseInt(productInfo[0]);
            String pName = productInfo[1];
            String pCompany = productInfo[2];
            int price = Integer.parseInt(productInfo[3]);
            Product p = new Product(pno, pName, pCompany, price);
            System.out.println(p);
        });
        stream.close();
    }
}

stream 예제 코드 6 - Stream 활용하여 파일 읽어오기

•Student.java
package com.stream8;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Student {
    private String name;
    private int score;
}
•MappingExample.java
package com.stream8;

import java.util.Arrays;
import java.util.List;

public class MappingExample {
    public static void main(String[] args) {
        List<Student> sList = Arrays.asList(
              new Student("James", 90),
              new Student("Paul", 80),
              new Student("John", 85),
              new Student("Kane", 95)
        );

        sList
            .stream()
//                .map(s -> s.getName())
//                .forEach(name -> System.out.println(name));
            .map(Student::getName)
            .forEach(System.out::println);
    }
}

stream 예제 코드 7 - map 활용

package com.stream9;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class MappingExample {
    public static void main(String[] args) {
        // 스트림으로 소수만 포함하는 새로운 리스트로 반환
        // 필터링된 새로운 리스트 출력
        List<Integer> primeList = IntStream.rangeClosed(1, 1000)
                .filter(x -> isPrime(x))         // 필터링
                .boxed()
                .collect(Collectors.toList());   // 리스트로 반환

        System.out.println(primeList);
        System.out.println();

        // 1부터 5까지의 IntStream 생성.. Double stream 타입으로 변환하고 출력하기
        IntStream
                .range(1, 6)
                .asDoubleStream()
                .forEach(v -> System.out.println(v));

        // 1부터 5까지의 IntStream 생성.. double 타입으로 변환하고 출력하기
        List<Double> doubleList = IntStream
                .range(1, 6)
                .asDoubleStream()
                .boxed()
                .collect(Collectors.toList());
        System.out.println(doubleList);
    }

    public static boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }

        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
}
package com.stream7;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamFilterExample {
    public static void main(String[] args) {
        List<String> nameList = Arrays.asList("우상혁", "황선우", "김우민", "서채현", "신유빈", "우상혁");

        // distinct로 중복이 제거되었다!
        nameList.stream()
                .distinct()
                .forEach(n -> System.out.print(n + ", "));
        System.out.println();

        // filter로 "우"가 들어간 이름만 나온다.
        nameList.stream()
                .filter(n -> n.contains("우"))
                .forEach(n -> System.out.print(n + ", "));

        System.out.println();
        System.out.println("=======================================");
        // distinct로 중복된 요소가 제거하고, filter로 "우"가 들어간 이름만 나오게 하기
//        nameList.stream()
//                .distinct()
//                .filter(n -> n.contains("우"))
//                .forEach(n -> System.out.print(n + ", "));

        // 리스트 형태로 출력됨
        List<String> filteredList = nameList
                .stream()
                .distinct()
                .filter(n -> n.contains("우"))
                .collect(Collectors.toList());      // 리스트 형태로 변환
        System.out.println(filteredList);
    }
}
package com.stream7;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamFilterExample2 {
    public static void main(String[] args) {
        // 1부터 1000까지 숫자 생성
        IntStream intStream = IntStream.rangeClosed(1, 1000);
        intStream.forEach(System.out::println);

        // 스트림으로 소수만 포함하는 새로운 리스트로 반환
        // 필터링된 새로운 리스트 출력
        IntStream
                .rangeClosed(1, 1000)
                .filter(x -> isPrime(x))
                .forEach(i -> System.out.print(i + ", "));

    }

    public static boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }

        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
            return true;
        }
        return false;
    }

}

stream 예제 코드 8 - 필터링, IntStream

•FlatMap
package com.stream10;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class FlatMappingExample {
    public static void main(String[] args) {
        List<String> msgList = new ArrayList<>();
        msgList.add("안녕? 난 xxx야");
        msgList.add("우리 같이 xx 하고 놀자");
        msgList.add("Hello World!");

        msgList.stream()                                                
            .flatMap(msg -> Arrays.stream(msg.split(" ")))      // flatMap         
            .forEach(word -> System.out.println(word));         // foreach로 반환

        System.out.println();

        List<String> strNums = Arrays.asList("10, 20, 30", "40, 50", "60");
        strNums.stream()
                .flatMapToInt(e -> {
                    String[] strArr = e.split(",");
                    int[] intArr = new int[strArr.length];
                    for (int i = 0; i < strArr.length; i++) {
                        intArr[i] = Integer.parseInt(strArr[i].trim());
                    }
                    return Arrays.stream(intArr);
//                    return IntStream.of(intArr);
        })
                .forEach(i -> System.out.println(i));                   // IntStream
    }
}

stream 예제 코드 9 - flatMap

•Student.java
package com.stream11;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Student implements Comparable<Student> {
    private String name;
    private int score;

    @Override
    public int compareTo(Student o) {
        return Integer.compare(score, o.score);
//        return score - o.score;
    }
}
•Student.java
package com.stream11;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Student implements Comparable<Student> {
    private String name;
    private int score;

    @Override
    public int compareTo(Student o) {
        return Integer.compare(score, o.score);
//        return score - o.score;
    }
}
•SortExample.java

stream 예제 코드 10 - sort(정렬)

•Employee
package com.assignment;

import lombok.Data;

@Data
public class Employee {
    private int id;
    private String name;
    private String department;
    private double salary;
    private String email;

    // 생성자, getter, setter 메소드들을 작성하세요

    public Employee(int id, String name, String department, double salary, String email) {
        this.id = id;
        this.name = name;
        this.department = department;
        this.salary = salary;
        this.email = email;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}
•EMSystem.java
package com.assignment;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

public class EMSystem {
    // 부서별 직원 필터링 - 특정 부서(department)에 속한 직원들을 필터링하여 반환하는 메소드를 작성하세요.
    public List<Employee> filterByDepartment(List<Employee> employees, String department) {
//        return employees.stream()
//                    .filter(employee -> department.contains(employee.getDepartment()))
//                    .collect(Collectors.toList());

        return employees.stream()
                    .filter(employee -> employee.getDepartment().equals(department))
                    .toList();
    }

    // 직원 이메일 목록 추출 - 모든 직원의 이메일 주소를 추출하여 리스트로 반환하는 메소드를 작성하세요.
    public List<String> getEmailAddresses(List<Employee> employees) {
        return employees.stream()
                    .map(employee -> employee.getEmail())
                    .collect(Collectors.toList());
    }

    // 직원 급여 합계 계산 - 모든 직원의 급여 합계를 계산하여 반환하는 메소드를 작성하세요.
    public double getTotalSalary(List<Employee> employees) {
        return employees.stream()
                    .mapToDouble(Employee::getSalary)
                    .sum();
    }

    // 특정 급여 이상의 직원 필터링 - 특정 급여(salary) 이상을 받는 직원들을 필터링하여 반환하는 메소드를 작성하세요.
    public List<Employee> filterBySalary(List<Employee> employees, double salary) {
        return employees.stream()
                    .filter(employee -> employee.getSalary() >= salary)
                    .collect(Collectors.toList());
    }

    // // 부서별 평균 급여 계산 - 각 부서별로 평균 급여를 계산하여 맵 형태로 반환하는 메소드를 작성하세요. 부서 이름을 키로 하고 평균
    // 급여를 값으로 하는 맵을 반환하세요.
     public Map<String, Double> getAverageSalaryByDepartment(List<Employee> employees) {
        return employees.stream()
                .collect(Collectors.groupingBy(
                Employee :: getDepartment,          // e -> e.getDepartment()
                Collectors.averagingDouble(Employee :: getSalary)));        // e -> e.getSalary()
     }

    // // 직원 이름 정렬 - 직원들의 이름을 알파벳 순서로 정렬하여 반환하는 메소드를 작성하세요.
     public List<Employee> sortEmployeesByName(List<Employee> employees) {
        return employees.stream()
                .sorted((emp1, emp2) -> emp1.getName().compareTo(emp2.getName()))
                .toList();
     }

    // // 직원 ID로 직원 찾기 - 직원 ID로 특정 직원을 찾아 반환하는 메소드를 작성하세요. 직원이 존재하지 않으면
    // Optional.empty()를 반환하세요.
     public Optional<Employee> findEmployeeById(List<Employee> employees, int id) {
        return employees.stream()
                    .filter(employee -> employee.getId() == id)
                    .findFirst();
     }
}
•EmployeeExample.java

stream 예제 코드 11 - EmployeeSystem

•stream을 활용하여 조건에 부합한 총합 구하기
package com.stream;

import java.util.Arrays;

public class LoopExample {
    public static void main(String[] args) {
        int[] intArr = {1, 2, 3, 4, 5};
        int total = Arrays
                .stream(intArr)
                .filter(i -> i % 2 == 0)
                .peek(System.out::println)
                .sum();
        System.out.println("총합 : " + total);

        Arrays
                .stream(intArr)
                .filter(i -> i % 2 == 1)
                .forEach(System.out::println);
    }
}
•stream 활용하여 짝수, 홀수 판별 및 배수 판별
package com.stream2;

import java.util.Arrays;
import java.util.stream.IntStream;

public class MatchExample {
    public static void main(String[] args) {
        int[] intArr1 = { 2, 4, 6, 8 };
        int[] intArr2 = { 2, 3, 4, 6, 8 };

        // 모두 2의 배수이면 true를 반환
        boolean allEvenResult1 = Arrays.stream(intArr1).allMatch(i -> i % 2 == 0);
        boolean allEvenResult2 = IntStream.of(intArr2).allMatch(i -> i % 2 == 0);

        System.out.println("1번 배열이 모두 짝수인가? " + allEvenResult1);
        System.out.println("2번 배열이 모두 짝수인가? " + allEvenResult2);

        // 하나라도 홀수가 있으면 true를 반환
        boolean anyOddResult1 = Arrays.stream(intArr1).anyMatch(i -> i % 2 == 1);
        boolean anyOddResult2 = IntStream.of(intArr2).anyMatch(i -> i % 2 == 1);

        System.out.println("1번 배열 중 하나라도 홀수가 있는가? " + anyOddResult1);
        System.out.println("2번 배열 중 하나라도 홀수가 있는가? " + anyOddResult2);

        // 10의 배수가 없으면 true를 반환
        boolean notInTenTimes1 = Arrays.stream(intArr1).noneMatch(i -> i % 10 == 1);
        boolean notInTenTimes2 = IntStream.of(intArr2).noneMatch(i -> i % 10 == 1);

        System.out.println("1번 배열 중에는 10의 배수가 없는가?" + notInTenTimes1);
        System.out.println("2번 배열 중에는 10의 배수가 없는가?" + notInTenTimes2);
    }
}
•요소의 곱 

stream 예제 코드 12

•집계값 없는 경우 대비하는 방법
package com.stream3;

import java.util.Arrays;
import java.util.OptionalDouble;

public class ReductionExample {
    public static void main(String[] args) {
        int[] intArr = { 2, 4, 6, 8, 10 };

        // 집계값이 없는 경우 대비하는 방법 1
        OptionalDouble optAvg = Arrays.stream(intArr).average();
        if (optAvg.isPresent()) {
            System.out.println("평균 : " + optAvg.getAsDouble());
        } else {
//            System.out.println("값이 없습니다.");
            System.out.println("평균 : " + 0.0);
        }

        // 집계값이 없는 경우 대비하는 방법 2
        double avg = Arrays.stream(intArr).average().orElse(0.0);
        System.out.println("평균 : " + avg);

        System.out.println();

        // 집계값이 없는 경우 대비하는 방법 3
        Arrays.stream(intArr).average().ifPresent(a -> System.out.println(a));
    }
}
package com.stream3;

import java.util.ArrayList;
import java.util.List;
import java.util.OptionalDouble;

public class ReductionExample2 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        OptionalDouble optAvg = list
                .stream()
                .mapToInt(i -> i.intValue())
                .average();

        // .isPresent() -> 평균 1) : 0.0
        if (optAvg.isPresent()) {
            System.out.println("평균 1) : " + optAvg.getAsDouble());
        } else {
            System.out.println("평균 1) : " + 0.0);
        }

        // .orElse() -> 평균 2) : 0.0
        System.out.println("평균 2) : " + optAvg.orElse(0.0));

        // .ifPresent -> 평균 3) :
        optAvg.ifPresent(a -> System.out.println("평균 3) : " + a));
    }
}

stream 예제 코드 13 - Optional

•Beverage.java
package com.stream4;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Beverage {
    private String name;
    private int price;
    private boolean isIce;
}
•CollectExample
package com.stream4;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CollectExample {
    public static void main(String[] args) {
        List<Beverage> bList = new ArrayList<>();
        bList.add(new Beverage("아이스 아메리카노", 1500, true));
        bList.add(new Beverage("아이스 아메리카노", 1500, true));
        bList.add(new Beverage("따뜻한 바닐라 라떼", 3500, false));
        bList.add(new Beverage("제로콜라", 2000, true));
        bList.add(new Beverage("솔의눈", 2000, true));
        bList.add(new Beverage("실론티", 1500, true));

        // 2000원의 음료
        List<Beverage> two$List = bList.stream().filter(b -> b.getPrice() == 2000).collect(Collectors.toList());
//        bList.stream().filter(b -> b.getPrice() == 2000).toList();

        System.out.println(two$List);
        System.out.println();
        
        // 음료수 이름 길이가 3인 것들
        Set<Beverage> threeSet = bList.stream().filter(b -> b.getName().length() == 3).collect(Collectors.toSet());
        System.out.println(threeSet);
        
        // 음료 이름, 가격으로 구성된 것들
        Map<String, Integer> iceMap = bList.stream()
                .distinct()
                .filter(b -> b.isIce()).collect(Collectors.toMap(b -> b.getName(), b -> b.getPrice()));
        System.out.println();
        System.out.println(iceMap);
    }
}
package com.stream4;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

// 카테고리 상품 코드에 참고
public class CollectExample2 {
    public static void main(String[] args) {
        List<Beverage> bList = new ArrayList<>();
        bList.add(new Beverage("따뜻한 아메리카노", 1500, false));
        bList.add(new Beverage("따뜻한 바닐라 라떼", 3500, false));
        bList.add(new Beverage("핫초코", 3500, false));
        bList.add(new Beverage("제로콜라", 2000, true));
        bList.add(new Beverage("솔의눈", 2000, true));
        bList.add(new Beverage("실론티", 2000, true));

        Map<String, Boolean> newBList = bList.stream()
                                            .distinct()
                                            .collect(Collectors.toMap(b -> b.getName(), b -> b.isIce()));
        System.out.println(newBList);
        System.out.println("============");
				
				// 여기서 활용한 로직을 잘 이해해야 함
        Map<Boolean, List<Beverage>> isIceMap = bList.stream()
                .collect(Collectors.groupingBy(b -> (Boolean) b.isIce()));
				
				// 여기서 활용한 로직을 잘 이해해야 함
        for (Map.Entry<Boolean, List<Beverage>> entry : isIceMap.entrySet()) {
            System.out.println(entry.getKey() + " : ");
            for (Beverage b : entry.getValue()) {
                System.out.println("\t" + b);
            }
        }

        List<Beverage> iceList = isIceMap.get(true);
        List<Beverage> hotList = isIceMap.get(false);

        System.out.println(iceList);
        System.out.println(hotList);
        System.out.println();

        Map<Boolean, Double> isIceAvgPriceMap = bList.stream()
                        .collect(Collectors.groupingBy(
                        b -> b.isIce(),
//                        Collectors.counting()
                        Collectors.averagingDouble(b -> b.getPrice()
                        )));

        System.out.println(isIceAvgPriceMap);
    }
}

stream 예제 코드 14

•https://velog.io/@mooh2jj/Java-람다식-표현들

stream 예제 참고 사이트