Stream

• 스트림은 java8부터 추가된 배열이나 컬렉션의 요소(List, Map, Set)들을 더 편리하게 가공하고 처리하도록 해주는 반복자
  
  
• 장점: 람다식 사용과 연산 과정에서 불필요한 변수를 남기지 않기 때문에 코드가 간결해짐,
           내부 반복자를 사용해 병렬처리가 쉬움.
• Java 8 API에 새로 추가된 기능
• 스트림을 이용하면 선언형으로 컬렉션 데이터를 처리할 수 있다
• 멀티스레드 코드를 구현하지 않아도 데이터를 투명하게 병렬로 처리할 수 있다.
  
  

 

 

스트림 사용 전

@ToString
@Getter
@AllArgsConstructor
public class Cake {
    private String name; // 케익 이름
    private Integer price; // 가격
}

// 케이크 목록
List<Cake> cakes = Arrays.asList(
    new Cake("딸기케익", 20000),
    new Cake("초코케익", 30000),
    new Cake("치즈케익", 40000)
);

// 3만원 이하 케이크 필터링
List<Cake> lowPriceCakes = new ArrayList<>();
for (Cake cake : cakes) {
    if (cake.getPrice() <= 30000) {
        lowPriceCakes.add(cake);
    }
}

// 비싼 케이크부터 정렬
Collections.sort(lowPriceCakes, new Comparator<Cake>() {
    @Override
    public int compare(Cake c1, Cake c2) {
        return Integer.compare(c2.getPrice(), c1.getPrice());
    }
});

// 케이크 이름 필터링
List<String> lowPriceCakesName = new ArrayList<>();
for (Cake lowPriceCake : lowPriceCakes) {
    lowPriceCakesName.add(lowPriceCake.getName());
}

System.out.println(lowPriceCakesName);
// 출력 결과 : [초코케익, 딸기케익]

 

스트림 사용

// 케이크 목록
List<Cake> cakes = Arrays.asList(
    new Cake("딸기케익", 20000),
    new Cake("초코케익", 30000),
    new Cake("치즈케익", 40000)
);

List<String> lowPriceCakesNames = cakes.stream()
    .filter(c -> c.getPrice() <= 30000) // 3만원 이하 케이크 필터링
    .sorted((c1, c2) -> c2.getPrice().compareTo(c1.getPrice())) // 비싼 케이크부터 정렬, compareTo : 비교대상이 같으면 0을 반환, 크면 내림차순 정렬
    .map(Cake::getName) // 자동차 이름 필터링
    .collect(Collectors.toList());

System.out.println(lowPriceCakesNames);
// 출력 결과 : [초코케익, 딸기케익]

 

 

주요메서드

 

filter(Predicate<T> predicate): 주어진 조건을 만족하는 요소만을 포함하는 스트림을 반환

List<Integer> evenNumbers = numbers.stream()
                                    .filter(n -> n % 2 == 0)
                                    .collect(Collectors.toList());

 

map(Function<T, R> mapper): 각 요소에 함수를 적용하여 새로운 값을 생성하는 스트림을 반환합니다.

List<String> upperCaseNames = names.stream()
                                  .map(String::toUpperCase)
                                  .collect(Collectors.toList());

 

flatMap(Function<T, Stream<R>> mapper): 각 요소에 대해 매핑 함수를 적용하고, 생성된 각각의 스트림을 평면화하여 하나의 스트림으로 만듭니다.

List<String> flatMapResult = list.stream()
                                 .flatMap(str -> Arrays.stream(str.split("")))
                                 .collect(Collectors.toList());

 

forEach(Consumer<T> action): 각 요소에 대해 주어진 동작을 수행합니다.

numbers.stream()
       .forEach(System.out::println);

 

sorted(): 요소를 기본 정렬 순서로 정렬한 스트림을 반환합니다.

List<Integer> sortedNumbers = numbers.stream()
                                    .sorted()
                                    .collect(Collectors.toList());

 

distinct(): 중복된 요소를 제거한 스트림을 반환합니다.

List<Integer> distinctNumbers = numbers.stream()
                                      .distinct()
                                      .collect(Collectors.toList());

 

reduce(BinaryOperator<T> accumulator): 모든 요소를 하나의 값으로 줄이는 연산을 수행합니다.

Optional<Integer> sum = numbers.stream()
                              .reduce((a, b) -> a + b);

 

collect(Collector<T, A, R> collector): 스트림의 요소를 컬렉션으로 수집합니다.

List<String> collectedList = strings.stream()
                                   .collect(Collectors.toList());

 

 

---

    if (multipartFiles != null && !multipartFiles.isEmpty()) {
      multipartFiles.stream()
              .filter(file -> file.getSize() > 0)
              .forEach(multipartFile ->
                      notice.addNoticeAttach(ncpObjectStorageService.uploadFile(new Attach(),
                              "bleuauction-bucket", "notice/", multipartFile))
              );
    }