List<Dish> vegetarianMenu = menu.stream()
                                 .filter(Dish::isVegetarian)
                                 .collect(toList());

 List<Integer> numbers = Arrays.asList(1,2,1,3,3,2,6);
 numbers.stream()
        .filter(i->i%2 == 0)
        .distinct()
        .forEach(System.out::println);

 List<Dish> slicedMenu1 = specialMenu.stream()
                                     .takeWhile(dish -> dish.getCalories() < 320)
                                     .collect(toList());

 List<Dish> slicedMenu2 = specialMenu.stream()
                                     .dropWhile(dish -> dish.getCalories() < 320)
                                     .collect(toList());

 List<Dish> slicedMenu3 = specialMenu.stream()
                                     .filter(dish -> dish.getCalories() > 300)
                                     .limit(3)
                                     .collect(toList());

 List<Dish> slicedMenu4 = specialMenu.stream()
                                     .filter(dish -> dish.getCalories() > 300)
                                     .skip(2)
                                     .collect(toList());

// map 메서드의 출력 스트림은 Stream<String>
List<String> dishNames = menu.stream()
                             .map(Dish::getName)
                             .collect(toList());

 String[] arrayOfWords = {"Hello", "World"};
 Stream<String> streamOfWords = Arrays.stream(arrayOfWords);
 
 words.stream()
      .map(word -> word.split("");
      .map(Arrays::stream)
      .distinct()
      .collect(toList();

 List<String> uniqueCharacters = words.stream()
                                      .map(word -> word.split("");
                                      .flatMap(Arrays::stream)
                                      .distinct()
                                      .collect(toList());

 if(menu.stream().anyMatch(Dish::isVegetarian)
    System.out.println("The menu is (somewhat) vegetarian friendly!!");

 boolean isHealthy = menu.stream()
                         .allMatch(dish -> dish.getCalories() < 1000);

 boolean isHealthy = menu.stream()
                         .noneMatch(dish -> dish.getCalories() >= 1000);

 Optional<Dish> dish = menu.stream()
                           .filter(Dish::isVegetarian)
                           .findAny();

 List<Integer> someNumbers = Arrays.asList(1,2,3,4,5);
 Optional<Integer> firstSquareDivisibleByThree 
 = someNumbers.stream()
              .map(n -> n*n)
              .filter(n -> n%3 == 0)
              .findFirst();

 menu.stream()
     .filter(Dish::isVegetarian)
     .findAny()     <- Optional<Dish> 반환
     .ifPresent(dish -> System.out.println(dish.getName());

 int product = numbers.stream().reduce(1, (a, b) -> a*b);

 int sum = numbers.stream().reduce(0, Integer::sum);

 int clories = menu.stream()    <- Stream<Dish> 반환 
                   .mapToInt(Dish::getcalories)      <- IntStream 반환
                   .sum();

 IntStream intStream = menu.stream().mapToInt(Dish::getCalories);       <- 스트림을 숫자 스트림으로 변환
 Stream<Integer> stream = intStream.boxed();            <- 숫자 스트림을 스트림으로 변환

 OptionalInt maxCalories = menu.stream()
                               .mapToInt(Dish::geCalories)
                               .max();
 int max = maxCalories.orElse(1);

 IntStream evenNumbers = IntStream.rangeClosed(1, 100)
                                  .filter(n -> n%2 == 0);
 System.out.println(evenNumbers.count());

 // 스트림의 모든 문자열을 대문자로 변환한 후 문자열을 하나씩 출력
 Stream<String> stream = Stream.of("Modern", "Java", "In", "Action");
 stream.map(String::toUpperCase).forEach(System.out::println);
 
 // 스트림을 비움
 Stream<String> emptyStream = Stream.empty();

 String homeValue = System.getProperty("home");
 Stream<String> homeValueStream = homeValue == null ? Stream.empty() : Stream.of(value);
 
 Stream<String> homeValueStream = Stream.ofNullable(System.getProperty("home"));
 
 Stream<String> values = Stream.of("config", "home", "user")
                               .flatMap(key -> Stream.ofNullable(System.getProperty(key)));

 int[] numbers = {2,3,5,7,11,13};
 int sum = Arrays.stream(numbers).sum();

 long uniqueWords = 0;
 try(Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {
                                uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
                                                   .distinct()
                                                   .count();
 } catch(IOException e) {
                                
 }

 Stream.iterate(0, n -> n+2)
       .limit(10)
       .forEach(System.out::println);

 IntStream.iterate(0, n -> n < 100, n -> n+4)
          .forEach(System.out::println);

 IntStream.iterate(0, n -> n+4)
          .filter(n -> n < 100)     // 불가능!
          .forEach(System.out::println);
          
 IntStream.iterate(0, n -> n+4)
          .takeWhile(n -> n < 100)
          .forEach(System.out::println);

 Stream.generate(Math::random)
       .limit(5)
       .forEach(System.out::println);

 // IntStream의 generate 메서드는 Supplier<T> 대신에 IntSupplier를 인수로 받음
 IntStream ones = IntStream.generate(() -> 1);
 
 IntStream twos = IntStream.generate(new IntSupplier(){
    public int getAsInt(){
        return 2;
    }
 });

 IntSupplier fid = new IntSupplier() {
    private int previous = 0;
    private int current = 1;
    public int getAsInt() {
        int oldPrevious = this.previous;
        int nextValue = this.previous + this.current;
        this.previous = this.current;
        this.current = nextValue;
        return oldPrevious;
    }
 };
 IntStream.generate(fib)
          .limit(10)
          .forEach(System.out::println());