@Test

    public void test1(){

        // 创建Stream对象的第一种方式

        List<String> list = Lists.newArrayList("A", "B", "C");

        Stream<String> stream1 = list.stream();

        // 创建Stream对象的第二种方式

        String[] arr = {"A", "B"};

        Stream<String> stream2 = Arrays.stream(arr);

        // 创建Stream对象的第三种方式

        Stream<String> stream3 = Stream.of("A", "B");

        // 创建Stream对象的第四种方式

        // iterate会无限执行，所以limit只取前5个

        Stream<Integer> stream4 = Stream.iterate(0, x -> x * x).limit(5);

        // 创建Stream对象的第五种方式

        // generate也会无限执行，所以limit只取前5个

        Stream<Double> stream5 = Stream.generate(Math::random).limit(5);

    }

 @Test

    public void test2() {

        List<String> list = Lists.newArrayList("abc", "bcd", "efg", "a12", "bcd");

        // 1.过滤

        list.stream().filter(x -> x.contains("b")).forEach(System.out::println);

        // 2.取前n

        list.stream().limit(1).forEach(System.out::println);

        //3. 跳过前n个

        list.stream().skip(2).forEach(System.out::println);

        //4. distinct 去重

        list.stream().distinct().forEach(System.out::println);

        //5. map映射

        list.stream().map(x -> x.toUpperCase()).forEach(System.out::println);

        System.out.println("-----------------------");

        //6. flatMap映射（与scala中的map,flatMap一样的）,返回的是个Stream

        list.stream().flatMap(x -> Stream.of(x.toUpperCase())).forEach(System.out::println);

        //7.排序  sorted() ---> 自然排序

        List<Integer> list1 = Lists.newArrayList(12, 1, 0, -1, 2, 56, 34);

        list1.stream().sorted().forEach(System.out::println);

        //8.排序 sorted(Comparator com)  --> 按指定规则排序

        list1.stream().sorted((e1, e2) -> -Integer.compare(e1, e2)).forEach(System.out::println);

        //9. 匹配与查找

        // list中的所有元素都含有"a"

        boolean ret = list.stream().allMatch(x -> x.contains("a"));

        System.out.println(ret);

        // list只要有一个元素包含有"a",就true

        ret = list.stream().anyMatch(x -> x.contains("a"));

        System.out.println(ret);

        //list中没有以"A"开头的元素

        ret = list.stream().noneMatch(x -> x.startsWith("A"));

        System.out.println(ret);

        //第一个元素

        Optional<String> first = list.stream().findFirst();

        System.out.println(first.get());

        //找任意一个元素

        Optional<String> any = list.parallelStream().findAny();

        System.out.println(any.get());

        // 找最大值

        Optional<Integer> max = list1.stream().max(Integer::compareTo);

        // 上面这行代码是下面代码的简写

//        Optional<Integer> max1 = list1.stream().max((e1, e2) -> Integer.compare(e1, e2));

        System.out.println(max.get());

        //10 , 归约

        Optional<Integer> reduce = list1.stream().reduce((x, y) -> x + y);  // list1中元素求和

        System.out.println(reduce.get());

        Integer sum = list1.stream().reduce(0, Integer::sum);  // list1中元素求和

        System.out.println(sum);

        Integer sum2 = list1.stream().reduce(10, Integer::sum);  // 10 + list1中元素求和

        System.out.println(sum2);

        //11. collect--> 将stream转成list集合

        List<Integer> collect = list1.stream().map(x -> x * 2).collect(Collectors.toList());

        collect.forEach(System.out::println);

    }