java8 Stream api详解

Stream3个阶段

1. 创建Stream
2. Stream中间处理
3. 终止Steam

创建Stream方式

        List<String> list = new ArrayList<>();
        list.stream();
        Stream.of(list);
        list.parallelStream();
        Stream.builder();
        //generate返回无限连续流，为了限制流中元素的数量，我们可以使用Stream.limit方法
        Stream.generate();

函数式基础接口

Stream中间处理

终止Steam

案例

public class XStream {

    public static void main(String[] args) {
        List<String> a = new ArrayList<String>();
        a.add("1");
        a.add("2");
        a.add("2");
        a.add("4");
        a.add("3");

        List<String> b = new ArrayList<String>();
        b.add("a");
        b.add("b");
        b.add("c");
        b.add("d");


        List<User> users = new ArrayList<>();

        User user1=new User("马超",18);
        User user2=new User("小乔",16);
        User user3=new User("典韦",27);
        User user4=new User("诸葛亮",24);
        User user5=new User("刘备",23);
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        users.add(user5);


        new XStream().maxUser(users);
    }

    public void create(){
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        Stream<String> stream = list.stream();
        Stream<List<String>> list1 = Stream.of(list);
        Stream<String> stringStream = list.parallelStream();
        Stream.Builder<String> builder = Stream.builder();
        builder.add("1");
        builder.add("2");
        builder.add("3");
        builder.add("4");
        Stream<String> build = builder.build();
        Supplier<String> supplier=()->"aaaa";
        Stream<String> generate = Stream.generate(supplier).limit(3);
        generate.forEach(System.out::println);
    }

    public void filter(List<String> list){
        Predicate<String> predicate=a->!a.equals(2);
        Stream<String> stream = list.stream().filter(predicate);
    }

    public void map(List<String> list){
        Function<String,Integer> function=x->Integer.valueOf(x);
        Stream<Integer> stream = list.stream().map(function);
    }

    public void mapToInt(List<String> list){
        ToIntFunction<String> function= x->Integer.valueOf(x);
        IntStream intStream = list.stream().mapToInt(function);
    }

    public void flatMap(List<String> a,List<String> b){
        List<List<String>> ab=new ArrayList<>();
        ab.add(a);
        ab.add(b);
        List<String> collect = ab.stream().flatMap(Collection::stream).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

    public void flatMapToInt(List<String> a,List<String> b){
        List<List<String>> ab=new ArrayList<>();
        ab.add(a);
        ab.add(b);
        ArrayList<Integer> collect = ab.stream().flatMapToInt(i -> i.stream().mapToInt(Integer::valueOf)).collect(ArrayList::new, List::add, List::addAll);
        collect.forEach(System.out::println);

    }
    public void distinct(List<String> a){
        List<String> collect = a.stream().distinct().collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

    public void sorted(List<String> a){
        List<String> collect = a.stream().sorted().collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
    public void sorted2(List<String> a){
        List<String> collect = a.stream().sorted(Comparator.comparing(x->!x.equals("2"))).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
    public void peek(List<String> a){
        List<String> collect = a.stream().peek(System.out::println).sorted(Comparator.comparing(x->!x.equals("2"))).peek(System.out::println).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
    public void limit(List<String> a){
        List<String> collect = a.stream().limit(2).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
    public void skip(List<String> a){
        List<String> collect = a.stream().skip(2).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }



    public void forEach(List<String> a){
        a.stream().forEach(System.out::println);
    }

    public void forEachOrdered(List<String> a){
        a.parallelStream().forEachOrdered(System.out::println);
        System.out.println("-------------");
        a.parallelStream().forEach(System.out::println);
    }

    public void toArray(List<String> a){
        Object[] objects = a.stream().toArray();
        System.out.println(objects);
    }

    public void toArray2(List<String> a){
        String[] oarrs = a.stream().toArray(String[]::new);
        System.out.println(oarrs);
    }

    public void reduce(List<String> a){
        Optional<String> reduce = a.stream().reduce((x, y) -> x.concat(y));
        System.out.println(reduce.get());
    }

    public void reduce2(List<String> a){
        String reduce = a.stream().reduce("a",(x, y) -> x.concat(y));
        System.out.println(reduce);
    }

    public void reduce3(List<String> a){
        String reduce1 = a.stream().reduce("a",(x, y) -> x.concat(y),(x, y) -> x.concat(y));
        System.out.println(reduce1);
        String reduce2 = a.parallelStream().reduce("a",(x, y) -> x.concat(y),(x, y) -> x.concat(y));
        System.out.println(reduce2);
    }

    public void collect(List<String> a){
        List<String> collect = a.stream().collect(Collectors.toList());
    }

    public void collect2(List<String> a){
        BiConsumer<List<String>, String> accumulator=(x,y)->{
            if(y.equals("2")){
                x.add(y);
            }
        };
        BiConsumer<List<String>, List<String>> combiner=(x,y)->{
            List<String> collect = y.stream().map(m -> "a" + m).collect(Collectors.toList());
            x.addAll(collect);
        };
        List<String> collect = a.parallelStream().collect(ArrayList::new,accumulator,combiner);
        collect.stream().forEach(System.out::println);
    }


    public void min(List<String> a){
        List<Integer> collect = a.stream().mapToInt(Integer::valueOf).collect(ArrayList::new,ArrayList::add,ArrayList::addAll);
        Optional<Integer> min = collect.stream().min(Comparator.comparing(x -> x));
        System.out.println(min.get());
    }

    public void max(List<String> a){
        List<Integer> collect = a.stream().mapToInt(Integer::valueOf).collect(ArrayList::new,ArrayList::add,ArrayList::addAll);
        Optional<Integer> max = collect.stream().max(Comparator.naturalOrder());
        System.out.println(max.get());
    }

    public void maxUser(List<User> a){
        Optional<User> max = a.stream().max(Comparator.comparing(x -> x.getAge()));
        System.out.println(max.get());
    }

    public void count(List<String> a){
        List<Integer> collect = a.stream().mapToInt(Integer::valueOf).collect(ArrayList::new,ArrayList::add,ArrayList::addAll);
        long count = collect.stream().count();
        System.out.println(count);
    }

    public void anyMatch(List<String> a){
        boolean b = a.stream().anyMatch(m -> m.equals("2"));
        System.out.println(b);
    }

    public void allMatch(List<String> a){
        boolean b = a.stream().allMatch(m -> !m.equals("3"));
        System.out.println(b);
    }

    public void noneMatch(List<String> a){
        boolean b = a.stream().noneMatch(m -> m.equals("7"));
        System.out.println(b);
    }

    public void findFirst(List<String> a){
        Optional<String> first = a.stream().findFirst();
        System.out.println(first.get());
    }

    public void findAny(List<String> a){
        Optional<String> first = a.stream().findAny();
        System.out.println(first.get());
    }
}