java8 stream学习

java8 stream学习

package com.test.learnnew4java8.stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import com.google.common.collect.Lists;

public class LearnStream {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //Lists是Guava中的一个工具类
        List<Integer> nums=Lists.newArrayList(1,null,3,4,null,6);
        //计算过滤后长度 filter利是保留条件
        long num=nums.stream().filter(e -> e != null).count();
        System.out.println("过滤后数组长度："+num);
        //过滤后生成新List filter利是保留条件
        List<Integer> num2s=nums.stream().filter(e -> e != null).collect(Collectors.toList());
        System.out.println("过滤后数组长度："+num2s.toArray().toString());
        /**
         * of方法：有两个overload方法，一个接受变长参数，一个接口单一值  
         */
        Stream<Integer> integerStream = Stream.of(1,2,3,45,5);
        Stream<String> stringStream = Stream.of("mljr");
        /**
         * generator方法：生成一个无限长度的Stream，其元素的生成是通过给定的Supplier 
         */
        Stream.generate( new Supplier<Double>() {

            @Override
            public Double get() {
                // TODO Auto-generated method stub
                return Math.random();
            }

        });
        Stream<Double> numdouble1=Stream.generate(()->Math.random());
        Stream<Double> numdouble2=Stream.generate(Math::random);
//      System.out.println("numdouble1："+numdouble1.toArray());
//      System.out.println("numdouble2："+numdouble2.toArray());

        Stream.iterate(1, e->e+1).limit(10).forEach(System.out::println);
        /**
         * distinct: 对于Stream中包含的元素进行去重操作（去重逻辑依赖元素的equals方法），新生成的Stream中没有重复的元素；
         */
        System.out.println("Stream.distinct");
        List<String> distinctString=Lists.newArrayList("","1","","222","3","3","3","2","0");
        distinctString=distinctString.stream().distinct().collect(Collectors.toList());
        distinctString.forEach(System.out::println);


        /**
         * 2. filter: 对于Stream中包含的元素使用给定的过滤函数进行过滤操作，新生成的Stream只包含符合条件的元素
         */
        System.out.println("Stream.filter");
        List<String> distinctString2=Lists.newArrayList("","1","","222","3","3","3","2","0");
        distinctString2=distinctString2.stream().filter(e -> e.length()==1).collect(Collectors.toList());
        distinctString2.forEach(System.out::println);
        /**
         * 3. map: 对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素。
         * 这个方法有三个对于原始类型的变种方法，分别是：mapToInt，mapToLong和mapToDouble。
         * 这三个方法也比较好理解，比如mapToInt就是把原始Stream转换成一个新的Stream，
         * 这个新生成的Stream中的元素都是int类型。
         * 之所以会有这样三个变种方法，可以免除自动装箱/拆箱的额外消耗； 
         */

        System.out.println("Stream.map");
        List<Integer> mapInteger=Lists.newArrayList(1,2,3,4,55,67,89,9);
        mapInteger.stream().map( e -> {e++;e+=2;return e;}).forEach(System.out::println);
        /**
         * 4. flatMap：和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中；
         */
        System.out.println("Stream.flatMap");
        List<Integer> together=Stream.of(Arrays.asList(1,2),Arrays.asList(3,4)).flatMap(Collection::stream)
            .collect(Collectors.toList());
        together.forEach(System.out::println);

        List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
        System.out.println("ints sum is:" + ints.stream().reduce(0, (sum, item) -> sum + item));
        System.out.println("ints count is:" + ints.stream().count());

        System.out.println("Stream.peek");
        List<String> peekList = Lists.newArrayList("","1","","222","3","3","3","2","0");
        peekList.stream().distinct().peek(e -> System.out.println(e+":"+e.length())).count();
        List<Integer> nums2=Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);

        List<Integer> numsWithoutNull = nums2.stream().filter(e-> e != null).collect(() -> new ArrayList<Integer>(),(list,item) -> list.add(item),(list1,list2)->list1.addAll(list2));

}

}