2017년 1월 팀에서 발표한 스터디 자료

1. 스트림API 스터디
2일 - 박병선

2. 스트림API의 소개
List<Dish> lowCaloricDishes = new ArrayList<>();
for (Dish d : menu) {
if (d.getCalories() < 400) {
lowCaloricDishes.add(d);
}
}
Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
@Override
public int compare(Dish d1, Dish d2) {
return Integer.compare(d1.getCalories(), d2.getCalories());
}
});
List<String> lowCaloricDishesName = new ArrayList<>();
for (Dish d : lowCaloricDishes) {
lowCaloricDishesName.add(d.getName());
}
컬렉션을 다뤄야 할 일이 많지만..

3. 스트림API의 소개
SELECT name FROM dishes WHERE calorie < 400 ORDER BY calorie;
List<String> lowCaloricDishesName = menu.stream()
.filter(d -> d.getCalories() > 400)
.sorted(comparing(Dish::getCalories))
.map(Dish::getName)
.collect(toList());

4. 함수형 스타일 코드는
변수의 명시적인 변경이나 재할당 문제를 피할 수 있다
서술적인 코드 작성이 가능하다
간결하다
직관적이다
명령형 -> 서술형

5. 스트림API의 특징은
List<String> lowCaloricDishesName = menu.parallelStream()
.filter(d -> d.getCalories() > 400)
.sorted(comparing(Dish::getCalories))
.map(Dish::getName)
.collect(toList());
선언형
조립할 수 있음
병렬화

6. 스트림과 컬렉션
컬렉션 : 모든 값을 메모리에 저장하는 자료구조
스트림 : 요청할 때만 요소를 계산
예) 스트리밍 영화, 소수 계산
1) 딱 한 번만 탐색할 수 있다
List<String> title = Arrays.asList(...);
Stream<String> s = title.stream();
s.forEach(System.out::println);
s.forEach(System.out::println); //java.lang.IllegalStateException
LSA에서는 예외는 발생하지 않는다. 그러
나 다시 반복되지 않고 바로 연산이 끝나기
때문에 한 번만 탐색할 수 있는 것은 동일하
다

7. 스트림과 컬렉션
2) 외부 반복과 내부 반복
내부에서 병렬 처리가 가능해 지고
최적화된 순서로 처리할 수 있다

8. 스트림 연산
중간 연산
- 다른 스트림을 반환
- 게으르다
최종 연산

9. 중간 연산
List<String> dishes = Arrays.asList("pork", "beef", "chicken", "fish", "shoes");
List<String> names = dishes.stream()
.filter(d -> {
System.out.println("filtering " + d);
return d.length() > 2;
})
.map(d -> {
System.out.println("mapping " + d);
return d;
})
.limit(3).collect(Collectors.toList());
System.out.println(names);
filtering pork
mapping pork
filtering beef
mapping beef
filtering chicken
mapping chicken
[pork, beef, chicken]

10. 실습

11. 스트림 생성과 forEach
Collection.stream()
Iterable.forEach()
Stream.forEach()
아래 리스트를 forEach()로 출력해 보세요 (System.out.println)
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
LSA에서는 Stream.of()를 사용

12. 스트림 생성과 forEach
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
System.out.println("JAVA8");
list.forEach(System.out::println);
list.stream().forEach(System.out::println);
System.out.println("LSA");
Stream.of(list).forEach(System.out::println);

13. filter(), distinct(), limit(), skip()
Stream<T> Stream<T>.filter(Predicate<? super T> var1)
- boolean 반환하는 람다
아래 리스트에서 처음 3개는 무시, 그 다음 20개만, 짝수인 것만, 중복 제거해서
System.out.println으로 출력해 보세요
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1);

14. filter(), distinct(), limit(), skip()
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1);
System.out.println("JAVA8");
list.stream().skip(3).limit(20).filter(v -> v % 2 == 0).distinct()
.forEach(System.out::println);
System.out.println("LSA");
Stream.of(list).skip(3).limit(20).filter(v -> v % 2 == 0).distinct()
.forEach(System.out::println);

15. map()
Stream<R> Stream<T>.map(Function<? super T, ? extends R> var1)
- T를 R로 만들어 주는 람다
아래 리스트에서 짝수만 골라서 각각 제곱한 결과를 System.out.println으로 출력해
보세요 (System.out.println)
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

16. map()
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
System.out.println("JAVA8");
list.stream().filter(v -> v % 2 == 0).map(v -> v * v).forEach(System.out::println);
System.out.println("LSA");
Stream.of(list).filter(v -> v % 2 == 0).map(v -> v * v).forEach(System.out::println);

17. flatMap()

18. flatMap()

19. anyMatch(), allMatch(), noneMatch()
Predicate를 확인해서 boolean 리턴
아래 리스트를 이용해서 *Match()를 확인해 보세요
List<Integer> list = Arrays.asList(0, 1);

20. findAny()
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
Optional<Integer> optional = list.stream().filter(v -> v % 2 == 0).findAny();
optional.ifPresent(v -> System.out.println("JAVA8: " + v));
int ret = list.stream().filter(v -> v < 0).findAny().orElse(-1);

21. findFirst()
반환 순서가 상관없다면 병렬 스트림에서는 findAny()
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
Optional<Integer> optional = list.stream().filter(v -> v % 2 == 0).findAny();
optional.ifPresent(v -> System.out.println("JAVA8: " + v));
병렬 스트림으로 실행해 봅시다

22. findAny()
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
Optional<Integer> optional = list.stream().filter(v -> v % 2 == 0).findAny();
optional.ifPresent(v -> System.out.println("JAVA8: " + v));
위의 코드를 LSA로 작성해 보세요
병렬 스트림을 지원하지 않는다!!!

23. reduce()
함수형 프로그래밍에서는 폴드 (fold)

24. reduce()
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
reduce()로 최소값을 찾아 보세요
초기값이 없으면?

25. reduce()
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
int min = list.stream().reduce(100, Math::min);
System.out.println("JAVA8: " + min);
min = Stream.of(list).reduce(100, Math::min);
System.out.println("LSA: " + min);

26. 다음 시간에 봐요