4장 스트림 : 1부

public class Dish { public enum Type{ MEAT, FISH, OTHER } private final String name; private final boolean vegetarian; private final int calories; private final Type type; public Dish(String name, boolean vegetarian, int calories, Type type) { this.name = name; this.vegetarian = vegetarian; this.calories = calories; this.type = type; } public String getName() { return name; } public boolean isVegetarian() { return vegetarian; } public int getCalories() { return calories; } public Type getType() { return type; } @Override public String toString() { return "Dish{" + "name='" + name + '\'' + ", vegetarian=" + vegetarian + ", calories=" + calories + ", type=" + type + '}'; } }

public class Menu { private final static List<Dish> DISHES = Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT), new Dish("beef", false, 700, Dish.Type.MEAT), new Dish("chicken", false, 400, Dish.Type.MEAT), new Dish("rice", true, 350, Dish.Type.OTHER), new Dish("season fruit", true, 120, Dish.Type.OTHER), new Dish("pizza", true, 550, Dish.Type.OTHER), new Dish("prawns", false, 300, Dish.Type.FISH), new Dish("salmon", false, 450, Dish.Type.FISH) ); public static void main(String[] args) { /*기존 자바 8버전 이전 코드*/ List<Dish> lowCaloricDishs = new ArrayList<>(); for (Dish dish : DISHES) { if (dish.getCalories() >= 400){ lowCaloricDishs.add(dish); } } lowCaloricDishs.sort(new Comparator<Dish>() { @Override public int compare(Dish d1, Dish d2) { return Integer.compare(d2.getCalories(), d1.getCalories()); } }); for (Dish dish : lowCaloricDishs){ System.out.println(dish.toString()); } /*자바 8버전 이후 코드*/ List<Dish> lowCaloricDishs = DISHES.stream() .filter(dish -> dish.getCalories() >= 400) .sorted(comparing(Dish::getCalories).reversed()) .collect(Collectors.toList()); lowCaloricDishs.forEach(dish -> System.out.println(dish.getCalories())); } } /* result Dish{name='pork', vegetarian=false, calories=800, type=MEAT} Dish{name='beef', vegetarian=false, calories=700, type=MEAT} Dish{name='pizza', vegetarian=true, calories=550, type=OTHER} Dish{name='salmon', vegetarian=false, calories=450, type=FISH} Dish{name='chicken', vegetarian=false, calories=400, type=MEAT} */

public static void main(String[] args) { /* 자바 8버전 이전 코드 외부반복 */ Iterator<Dish> dishes = DISHES.iterator(); while (dishes.hasNext()){ Dish dish = dishes.next(); System.out.println(dish.toString()); } /* 자바 8버전 이후 코드 내부반복 */ DISHES.stream().forEach(dishe -> System.out.println(dishe.toString()) ); }

//필터링 예제 public class Filtering { static List<Dish> dishes = Dish.DISHES; public static void main(String[] args) { vefitarianFiltering(); uniqueFiltering(); } // Predicate Filtering public static List<Dish> vefitarianFiltering(){ return dishes.stream() .filter(Dish::isVegetarian) // Filter .collect(Collectors.toList()); } // 고유 요소 필터링 중복제거 public static List<Dish.Type> uniqueFiltering(){ return dishes.stream() .filter(Dish::isVegetarian) .map(Dish::getType) .distinct() .collect(Collectors.toList()); } }

// takeWhile 을 이용한 스트림 슬라이싱 방법 // dropWhile 을 이용한 스트림 슬라이싱 방법 // limit 를 이용한 스트림 축소 방법 // skip 을 이용한 요소 건너 뛰기 방법 public class TakeAndDropWhile { static List<Dish> dishes = Dish.DISHES.stream() .sorted(Comparator.comparing(Dish::getCalories)) .collect(Collectors.toList()); public static void main(String[] args) { takewhile(); dropwhile(); limit(); skip(); } /* 주목해야할 점은 takeWhile에서의 동작이다. loop에서 300이상인 값을 만나면 그대로 종료된다. // 거짓인 순간 참을 반환 이를 활용할 수 있는 방법이 무엇일까? 바로 정렬이다. 정렬했을때는 내가 지정한 값을 순차적으로 접근할 수 있다. 그럼 결국 내가 찾고자 하는 값에 인접하면 바로 종료가 되면 되는 것이다. // 거짓인 순간 if break 와 같은 기능이다. */ // 말그대로 참인것만 가져감 public static List<Dish> takewhile(){ // takeWhile 자바 9버전 이상 return dishes.stream() .takeWhile(dish -> { // 참 인것만 반환 System.out.println(dish.toString()); return dish.getCalories() < 300; // 거짓이 되는 시점 종료 }) .collect(Collectors.toList()); } // 말그대로 거짓인건 버림 public static List<Dish> dropwhile(){ // dropWhile 자바 9버전 이상 return dishes.stream() .dropWhile(dish -> { // 참 인것만 반환 System.out.println(dish.toString()); return dish.getCalories() < 300; // 참이되는 순간종료 거짓은버림 }) .collect(Collectors.toList()); } // 스트림 축소 public static List<Dish> limit() { return dishes.stream() .limit(3) // 3개까지만 반환 0~2 라는 생각이든다 .collect(Collectors.toList()); } // 요소 건너 뛰기 public static List<Dish> skip() { return dishes.stream() .skip(2) //배열 인덱스 0,1 번을 건너뛰고 스트림 반환 .collect(Collectors.toList()); } }

public static void main(String[] args) { List<Dish> meatFilterSizeTwo = example(); meatFilterSizeTwo .forEach(s -> System.out.println(s.toString())); } // 처음 두 고기 요리를 필터링 하시오! public static List<Dish> example() { return dishes.stream() .filter(dish -> dish.getType() == Dish.Type.MEAT) .limit(2) .collect(Collectors.toList()); }

// 만약 우리의 dishs 에서 이름 메뉴이름의 길이만 들어있는 list를 생성하고 싶다면? public static List<Integer> map() { return dishes.stream() .map(Dish::getName) // String 형태의 버전 .map(String::length) // Integer 형태의 버전 .collect(Collectors.toList()); }

/* [Hello, World]를 나는 [H,e,l,o,W,r,d] 의 형식으로 출력하고 싶다. 하지만 이렇게 만들면 문제가 생긴다. return형을 잘보자 List<String[]> 이다. 이렇게 return 이 이루어진다면 어떤일이 벌어질까? [ [H, e, l, l, o],[W, o, r, l, d] ] 아마 이렇게 출력될 것이다. 그럼 우리가 원하는 방식으로 가능하려면 어떻게 해야할까? 정답은 flatMap이다. 플랫맵은 필자의 이해로는 오선지의 플랫과 같은 역활인 것 같다. map은 앞에 플랫, 샾이 없다 말그대로 같은 선상의 변경이다. 앞서말한 버전이 변경되는 것이다. 잘못 이해한 부분 ------------------------------------------------------------- flatMap의 경우에는 음악시간을 생각해보자 플랫이 들어가면 어떤가? 반음이 내려간다. 이렇듯 List<String[]> 의 반음을 내리는 것이라고 판단했다. 여기서 반 즉, List안에서 반을 내리면 string[] 이 존재한다. 그럼 flatMap에서 존재하는 반음은 Stream<String[]>이 아닌 String[] 이 된다. 왜 Stream이 붙는지 이해 못했다. 그래서 찾아들어가보니 <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mappe r); <R> Stream<R> map(Function<? super T, ? extends R> mapper); 이렇게 둘다 stream 형태로 반환한다. 이렇게 보면 map은 말그대로 T 를 R 로 변환하여 stream을 감싼 것이고 flatMap의 경우에는 잘못 이해한 부분 ------------------------------------------------------------- 제대로 된 이해 앞서 설명한 것은 초기에 잘못이해한 부분이다. T R 관계에 대해서 제대로 이해 못했던것 같다. 말그대로 String[]이라서 String[]의 작은 단위 String을 반환하는 것이 였다. 그래서 최종타입이 결정되는 것은 List<String>인 것이다. */ public static List<String[]> splitStringArrays() { String[] StringArray = {"Hello","World"}; return Arrays.stream(StringArray) .map(s -> s.split("")) //.flatMap(Arrays::steam) 리턴 Stream<String> 최종 리턴 List<String> .distinct() .collect(toList()) ; }

// 검색 // anyMatch 를 이용한 방법 // allMatch 를 이용한 방법 // noneMatch 를 이용한 방법 public class SearchAndMatching { public static List<Dish> dishs = Dish.DISHES; public static void main(String[] args) { vegetarianAnyMatch(); vegetarianAllMatch(); vegetarianNoneMatch(); if (vegetarianAnyMatch()){ System.out.println("Yes"); }else { System.out.println("No"); } } public static boolean vegetarianAnyMatch() { // anyMatch 를 이용한 방법 System.out.println("dishs List 안에는 채식주의자가 존재합니까?"); return dishs.stream() .anyMatch(Dish::isVegetarian); // 적어도 하나 이상 일치하는 요소가 있는지 검색 } public static boolean vegetarianAllMatch() { // allMatch 를 이용한 방법 System.out.println("dishs List 안에는 채식주의자만 있습니까?"); return dishs.stream() .allMatch(Dish::isVegetarian); // 모든 요소가 일치 하는지 검사 } public static boolean vegetarianNoneMatch() { // noneMatch 를 이용한 방법 System.out.println("dishs List 안에는 채식주의자가 없습니까?"); return dishs.stream() .noneMatch(Dish::isVegetarian); // 모든요소가 불일치 하는지 검사 } } /* !쇼트서킷! 신기한 개념이다. 근데 유용하다. 만약 답지가 있다고 가정해보자! 답지는 뭘 하는 것인가? 정답만 가진 리스트다. 근데 만약 답지에 오답이 있다면 그 답지는 답지라고 불릴 수 있는가? 아니다. 답지가 아닌 답이 많이 적혀 있는 종이다. 모든 리스트의 정답이 곧 객체의 평가 요소가 된다면 차근차근 하나씩 검사하며 틀린 것이 나오면 그 객체는 틀린 객체로 평가하는 것이다. 이러한 방법을 쇼트 서킷이라고 한다. 그럼 이것이 왜 좋을까? 필자의 생각으로는 객체검사에 있어서 최악의 경우 n번만 검사 하면 되기 때문이다. 1. [1,2,3, .... 100] 최악의 경우 100번까지 돌아가는것 2. 그럼 리스트의 크기 만큼만 돌면 된다. 유용하게 쓰일만한곳 1. 정렬이 안된 리스트 : 객체를 전체로 평가할때 선정렬 후검색은 2번연산을 거침 2. 정렬을 못하는 리스트 : 리스트의 크기가 너무 클 경우 */

// 검색 // findAny 를 이용한 방법 public class SearchAndMatching { public static List<Dish> dishs = Dish.DISHES; public static void main(String[] args) { System.out.println(findAnyDish().get().getName()); } public static Optional<Dish> findAnyDish() { Optional<Dish> vegetarianDish = dishs.stream() .filter(Dish::isVegetarian) .findAny(); // 임의의 요소를 반환한다. // 그런데 Optional<Dish>는 뭘까? return vegetarianDish; } } /* Optional<T> 클래스는 값의 존재나 부재 여부를 표현하는 컨테이너 클래스다. 쉽게 말해 만약 findAny가 아무것도 찾지못하는 상황을 가정해보고 코드를 보자. 아래 이렇듯 null은 쉽게 에러를 일으킬 수 있다. 그래서 자바 8 라이브러리 설계자는 Optional<T> 를 만든것이다. */ public static void main(String[] args) { // null.getName(); 을 참조하게된다. 그럼 NullPointException 발생 System.out.println(noOptional().getName()); } public static Dish noOptional() { // 메뉴리스트에는 채식주의자 메뉴가 하나도 없다. List<Dish> noneVegetarianMenuList = Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT), new Dish("beef", false, 700, Dish.Type.MEAT), ); Dish vegetarianMenu = null; for (Dish dish : noneVegetarianMenuList) { if (dish.isVegetarian()){ //채식 메뉴를 찾는다. vegetarianMenu = dish; } } return vegetarianMenu; //그럼 뭘 반환하는가? null 이다. } // Optional의 간단한 활용 public static void main(String[] args) { System.out.println(findAnyDish().isPresent()); // 만약 내부 값이 null 이라면 true 아니라면 false 반환 findAnyDish().ifPresent(dish -> System.out.println("값이 없습니다.")); // 값이 있으면 실행되고 없다면 만약 내부 값이 null 실행되지않음 System.out.println(findAnyDish().get().toString()); // 값이 존재하면 값을 반환하고 없다면 noSuchElementException 반환 System.out.println(findAnyDish() .orElse(new Dish("pizza", true, 550, Dish.Type.MY_DISH)) ); // 값이 있다면 값을 반환 값이 null이라면 기본,지정 값을 반환 } // findAny, findFirst를 왜 사용하는 것일까? public static void main(String[] args) { findFirstItemReturnSet().collect(Collectors.toSet()).forEach(System.out::println); System.out.println(findFirstItem().get()); } // limit 을 이용한 public static Set<Integer> findFirstItemReturnSet() { List<Integer> numbers = Arrays.asList(1,2,5,4,3); Set<Integer> limit = numbers.stream() .map(n -> n * n) .filter(n -> n % 3 == 0) .limit(1) .collect(Collectors.toSet()); return limit; } // findFirst를 이용한 public static Optional<Integer> findFirstItem() { List<Integer> numbers = Arrays.asList(1,2,5,4,3); Optional<Integer> firstSquareDivisibleByThree = numbers.stream() .map(n -> n * n) .filter(n -> n % 3 == 0) .findFirst(); return firstSquareDivisibleByThree; } /* 이러한 예제는 findFirst 와 같다. 말그대로 첫번째 요소를 반환한다. 그런데 왜? findFirst 가 생겨난 것일까? 바로 병렬성이다. 병렬실행에서는 첫번째요소를 찾기 힘들다. 그래서 findFirst가 생겨난 것이다. 그럼 findAny는? 일치하는 임의의 요소를 반환한다. 이말인 즉, 논리적 순서를 가진 것이 아니라면 주로 findAny를 사용한다. */

public class reducing { public static void main(String[] args) { sum(); } // 1~10까지의 합을 구하는 문제 public static void sum() { List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10); int sum = numbers.stream() .reduce(0, (a,b) -> a+b); /* reduce(초기 값, (파라미터1,파라미터2) -> 초기값에 할당 ); 흐름 1번 루프 a = 초기값 0 b = 요소의 첫번째 값 1 초기값 = reduce 결과 값 1 대입연산 */ System.out.println(sum); } // 같은 예제 다른 반환 public static void sum() { List<Integer> numbers = Arrays.asList(); // stream 없음 Optional<Integer> sum = numbers.stream() .reduce((a,b) -> a+b); // 초기 값 없음 System.out.println(sum); } /* 왜 reduce에 초기값 설정을 안한다면 Optinal을 반환할까? 스트림에 아무요소도 없고 초기값이 없는 상황이라면 reduce는 아무것도 반환하지 못한다. 그래서 초기값이 없는 상황에서는 이를 대비해서 optional을 반환한다. */ } // 연습문제 // 메뉴가 몇개 인지 카운트 하세요 public static void dishCount(){ Optional<Integer> count = Dish.DISHES.stream() .map(menu -> 1) .reduce(Integer::sum); System.out.println(count.get()); } /* reduce의 장점? 가변 누적자 패턴 즉, 아까와 같은 상황 sum에 합을 구해야하는 경우에는 병렬처리가 힘 들다. 그래서 fork,join 방식을 사용해야했다. 근데 이러한 처리를 reduce를 이용하면 간단히 해결할 수 있다. */

int calories = Dish.DISHES.stream() .mapToInt(Dish::getCalories) // IntStream 반환 .sum(); /* 궁금증 그럼 map에서는? 당연히 stream<Integer>로 반환 그럼 래핑이 된 상태 하지만 mapToInt의 경우 IntStream int 형으로 반환 */ IntStream calories = Dish.DISHES.stream() .mapToInt(Dish::getCalories); Stream<Integer> stream = calories.boxed(); // 박싱도 가능 /* 궁금증 그럼 여기서 IntStream이 잘못작동된다면? 예를 들어 1~10 까지의 리스트의 합계를 구한다면 55다. 0인 리스트에서 합계를 구한다면 0이다. 그럼 null인 리스트에서 max를 구한다면? 0이되어야할까? null이 되어야할까? 그래서 OptionalInt 가 존재한다. 기본특화형의 3가지버전 만약에 찾는 값이 없다면 동일하게 noSuchElementException을 발생시킨다 */ List<String> numbers = Arrays.asList(); OptionalInt optionalInt = numbers.stream() .mapToInt(Integer::parseInt) .max(); System.out.println(optionalInt.getAsInt()); //숫자범위 지정 IntStream evenNumbers = IntStream .range(1,100) // 범위 지정 가능 .filter(n -> n%2==0); System.out.println(evenNumbers.count());

Stream<Integer> stream = Stream.of(1,2,3,4); // Stream<Integer> Stream<Integer> streamEmpty = Stream.empty(); // 빈 스트림 Stream<String> var = Stream.ofNullable(System.getProperty("nullProperty")); // null 일수 있는 stream 만들기 그럼 반환이 empty() 빈 스트림이 된다.

Stream.iterate(new int[]{0,1}, t -> new int[]{t[1], t[0]+t[1]}) .limit(10) .collect(Collectors.toList()) .forEach(s -> System.out.println(s[0]+" "+s[1])); /* iterate 메서드는 초깃값 new int[]{0,1}과 람다를 인수로 받아 새로운 값을 끊임없이 생산한다. 그래서 람다 t -> new int[]{t[1], t[0]+t[1]} 에서 람다는 초깃값에 계속 대입된다. 이러한 무한스트림은 언바운드 스트 림이라한다. */

IntSupplier fb = new IntSupplier() { private int pre = 0; private int crr = 1; @Override public int getAsInt() { int old = this.pre; int next = this.pre + this.crr; this.pre = this.crr; this.crr = next; return old; } } ; IntStream.generate(fb).limit(10).forEach(System.out :: println); /* 이렇게도 생성할 수 있다. 근데 이게 iterate를 사용할때와 무엇이 다른가? generate는 연속적으로 값을 계산하지않는다. 또한 supplier<T> 를 인수로 받아 값을 생성한다. 또한 supplier의 특성으로 가변성이 존재한다는 것이다. 그말인즉 supplier는 내부 필드정의가 가능하다. 그의미는 객체처럼 사용이가능하다는 것이다. 그럼 무슨문제?라 고 생각할 수 있다. 근데 다음과 같이 한번 출력했을경우 문제가 없다. 두번출력해도 동일한 결과가 나와야한다. 하지만 다음을 두번출력한다면 1번호출 0 1 1 2 3 5 8 13 21 34 2번호출 55 89 144 233 377 610 987 1597 2584 4181 다음과 같은 결과가 생성된다. 이의미는 매우크다 병렬처리과정에서 값이변 환될 위험이 존재한다는 점이다. */