Java的stream流相关方法

//通过实现predicate接口来对stream流中的所有元素进行自定义匹配，当所有匹配成功时，返回true
boolean allMatch(Predicate<? super T> predicate);

        ArrayList<String> strings = new ArrayList<>(Arrays.asList("13","aa","88"));

        boolean result = strings.stream().allMatch(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                if(s == "13")return true;
                return false;
            }
        });
        System.out.println(result);

//有任意元素匹配就会返回true
boolean anyMatch(Predicate<? super T> predicate);

//当没有元素匹配时返回true
boolean noneMatch(Predicate<? super T> predicate);

//通过collector将流中的元素创建一个新的List并返回，Collectors中有JDK定义好的Collector可以直接使用
<R, A> R collect(Collector<? super T, A, R> collector);

//supplier用于生成存放元素的容器，accumulator遍历所有的元素进行操作，combiner用于对多线程产生的不同容器进行合并    
<R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);

//常规写法
List<Integer> result2 = list.stream().collect(
                new Supplier<List<Integer>>() {
                    @Override
                    public List<Integer> get() {
                        return new ArrayList<>();
                    }
                },
                new BiConsumer<List<Integer>, Integer>() {
                    @Override
                    public void accept(List<Integer> integers, Integer integer) {
                        integers.add(integer);
                    }
                },
                new BiConsumer<List<Integer>, List<Integer>>() {
                    @Override
                    public void accept(List<Integer> integers, List<Integer> integers2) {
                        integers.addAll(integers2);
                    }
                }
        );


//Lamda表达式

        List<Integer> result = list.stream().collect(
                ArrayList::new,
                (tempList,obj)->{
                    tempList.add(obj);
                },
                List::addAll
        );

//返回去除了重复元素后的流
Stream<T> distinct();

        List<Integer> list = new ArrayList<>(Arrays.asList(1,1,1,1,2,3,4,5));

        List<Integer> result = list.stream().distinct().collect(Collectors.toList());

        System.out.println(result);

//对流中的元素进行自定义过滤，返回true的才能通过过滤
Stream<T> filter(Predicate<? super T> predicate);

        List<Integer> list = new ArrayList<>(Arrays.asList(1,1,1,1,2,3,4,5));

        List<Integer> result = list.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                if(integer > 2){
                    return true;
                }
                return false;
            }
        }).collect(Collectors.toList());

        System.out.println(result);

//从流中返回一个经过Optional类包装后的值，是显式不确定的，为了在并行操作中实现最大性能。
Optional<T> findAny();

System.out.println(list.stream().findAny().get());

//返回流中第一个元素
Optional<T> findFirst();

//对流内的元素进行重映射，并且对原来的一个一个元素可以映射为多个元素
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));

        List<Object> result = list.stream().flatMap(new Function<Integer, Stream<?>>() {
            @Override
            public Stream<?> apply(Integer integer) {
                if(integer == 2){
                    return new ArrayList<Integer>(Arrays.asList(99,99,99)).stream();
                }
                else{
                    return new ArrayList<Integer>(Arrays.asList(integer)).stream();
                }
            }
        }).collect(Collectors.toList());

        System.out.println(result);

//遍历流中所有元素
void forEach(Consumer<? super T> action);

        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));

        list.stream().forEach(element->{
            System.out.println(element);
        });

//返回无限连续无序流，其中的元素都是由Supplier生成。
public static<T> Stream<T> generate(Supplier<T> s) 

        Stream.generate(()->{
            try {
                Thread.sleep(1000);
                return new Random().nextInt(99) + 1;
            }catch (Exception e){
                e.printStackTrace();
            }
            return null;
        }).forEach(element->{
            System.out.println(element);
        });

//返回最大元素个数的流
Stream<T> limit(long maxSize);

        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));

        list.stream().limit(2).forEach(el->{
            System.out.println(el);
        });

//对流中的元素进行重映射
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));

        list.stream().map(el->{
            if(el < 3){
                return -1;
            }
            return el;
        }).forEach(el->{
            System.out.println(el);
        });

//通过传入的比较器返回流中最大的元素
Optional<T> max(Comparator<? super T> comparator);

        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));

        System.out.println(list.stream().max(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if (o1 == o2) {
                    return 0;
                }
                return o1 > o2 ? 1 : -1;
            }
        }).get());

//获取流中最小的元素
Optional<T> min(Comparator<? super T> comparator);

//通过传入的比较器对流的元素进行排序
Stream<T> sorted(Comparator<? super T> comparator);

        List<Integer> list = new ArrayList<>(Arrays.asList(2,4,1,3,5));

        list.stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if(o1 == o2){
                    return 0;
                }
                return o1 > o2 ? 1 : -1;
            }
        }).forEach(el->{
            System.out.println(el);
        });

//将流转换成数组
Object[] toArray();

        List<Integer> list = new ArrayList<>(Arrays.asList(2,4,1,3,5));

        Object[] result = list.stream().toArray();

        System.out.println(new ArrayList<Object>(Arrays.asList(result)));