Java8InAction_Chapter05

import static java.util.stream.Collectors.toList;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.function.IntSupplier;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 在这里编写类的功能描述
 *
 * @author shangjinyu
 * @created 2017/10/4
 */
public class Notes {
    //使用流
    //过滤：filter() 去重：distinct() 取前几：limit() 去掉前几：skip() 转换：map() 转换合并：flatMap()
    //查找：anyMatch(), allMatch(), noneMatch(), findAny(), findFirst()
    /**
     * 操作         类型           返回类型            使用的类型/函数式接口             函数描述符
     * filter       中间           Stream<T>          Predicate<T>                    T -> boolean
     * distinct     中间           Stream<T>
     * skip         中间           Stream<T>          long
     * limit        中间           Stream<T>          long
     * map          中间           Stream<R>          Function<T,R>                   T -> R
     * flatMap      中间           Stream<R>          Function<T, Stream<R>>          T -> Stream<R>
     * sorted       中间           Stream<T>          Comparator<T>                   (T, T) -> int
     * anyMatch     终端           boolean            Predicate<T>                    T -> boolean
     * noneMatch    终端           boolean            Predicate<T>                    T -> boolean
     * allMatch     终端           boolean            Predicate<T>                    T -> boolean
     * findAny      终端           Optional<T>
     * findFirst    终端           Optional<T>
     * forEach      终端           void               Consumer<T>                     T -> void
     * collect      终端           R                  Collector<T,A,R>
     * reduce       终端           Optional<T>        BinaryOperator<T>               (T,T) -> T
     * count        终端           long
     */
    public static void main(String...args) throws IOException {
        //获取"Goodbye", "World" 中出现的字母
        String[] arrayOfWords = {"Goodbye", "World"};
        Arrays.stream(arrayOfWords)
                .flatMap((String line) -> Arrays.stream(line.split("")))
                .distinct()
                .forEach(System.out::println);

        //选出number1和number2中元素组成的所有数对中可以被3整除的数对
        List<Integer> numbers1 = Arrays.asList(1,2,3,4,5);
        List<Integer> numbers2 = Arrays.asList(6,7,8);
        List<int[]> pairs1 =
                numbers1.stream()
                        .flatMap(i -> numbers2.stream()
                                .map(j -> new int[]{i, j})
                        )
                        .filter(pair -> (pair[0] + pair[1]) % 3 == 0)
                        .collect(toList());
        List<int[]> pairs2 =
                numbers1.stream()
                        .flatMap(i -> numbers2.stream()
                                .filter(j -> (i + j) % 3 == 0)
                                .map(j -> new int[]{i, j})
                        )
                        .collect(toList());
        pairs1.forEach(pair -> System.out.println("(" + pair[0] + ", " + pair[1] + ")"));
        /**
         *  流的构建方式
         */
        // Stream.of
        Stream<String> stream = Stream.of("Java 8", "Lambdas", "In", "Action");
        stream.map(String::toUpperCase).forEach(System.out::println);

        // Stream.empty
        Stream<String> emptyStream = Stream.empty();

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

        // fibonnaci with iterate
        Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1],t[0] + t[1]})
                .limit(10)
                .forEach(t -> System.out.println("(" + t[0] + ", " + t[1] + ")"));

        // random stream of doubles with Stream.generate
        Stream.generate(Math::random)
                .limit(10)
                .forEach(System.out::println);

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

        //数值流
        Stream<int[]> pythagoreanTriples =
                IntStream.rangeClosed(1, 100).boxed()
                        .flatMap(a -> IntStream.rangeClosed(a, 100)
                                .filter(b -> Math.sqrt(a*a + b*b) % 1 == 0).boxed()
                                .map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)}));
    }
}