stream java 跳出map java stream()

1、java strem 流

目录

1、java strem 流

2、一些方法的使用

---

  流，是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算。

        (1)对于开发人员来说，使用处理流进行输入、输出操作更简单；

        (2)使用处理流执行效率更高。

2、一些方法的使用

package com.xhstudy.xh.java.stream;

import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

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

/**
 * @ClassName StreamJava
 * @Description java 流操作 一些方法使用
 *      (1)对于开发人员来说，使用处理流进行输入、输出操作更简单；(2)使用处理流执行效率更高。
 * @Author wy
 * @Version 1. 0
 **/
public class StreamJava {
    /*
    * 流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。
    * 流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算
    * */
    public static void main(String[] args) throws IOException {

        //列表生成
        List<Integer> integerList= Arrays.asList(1,1,2,3,4,5,6);
        Stream<Integer> integerStream=integerList.stream();

        //数组生成
        /*
         * Stream API提供了mapToInt、mapToDouble、mapToLong三种方式将对象流【即Stream 】转换成对应的数值流
         * 同时提供了boxed方法将数值流转换为对象流.
         * */
        int[] ints={1,2,3,4,5,6};
        IntStream intStream=Arrays.stream(ints);//使用Arrays.stream生成的是数值流并非stream，避免拆箱装箱，提高性能

        //值生成
        Stream<Integer> integerStream1=Stream.of(1,2,3,4,5,6);
        //文件生成
//        Stream<String> lines= Files.lines(Paths.get("/file"), Charset.defaultCharset());
        //函数生成
        Stream<Integer> integerStream2=Stream.iterate(0,n->n+12).limit(5);
        Stream<Double> doubleStream=Stream.generate(Math::random).limit(5);

        /*
        * 流的操作分为两种
        * 1、中间操作
        *   一个流可以后面跟随零个或多个中间操作。
        *   其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。
        *   这类操作都是惰性化的，仅仅调用到这类方法，并没有真正开始流的遍历，真正的遍历需等到终端操作时
        *   常见的中间操有filter、map 等
        * 2、终端操作
        *   一个流有且只能有一个终端操作，当这个操作执行后，流就被关闭了，无法再被操作
        *   因此一个流只能被遍历一次，若想再遍历需要通过源数据在生成流。
        *   终端操作的执行，才会真正开始流的遍历。 count、collect 等。
        * */

        //中间操作
        integerStream=integerStream.filter(i->i<5);//筛选i>5的值
        integerStream=integerStream.distinct();//去重
        integerStream=integerStream.limit(3);//限制返回流个数
        integerStream=integerStream.skip(2);//跳过流中前两个
            //map 流映射
            //所谓流映射就是将接受的元素映射成另外一个元素。
        List<String> seventhNight= Arrays.asList("I","love","you ~");
        List<Integer> seventhNightLength=seventhNight.stream()
                .map(String::length)
                .collect(Collectors.toList());
            //flatMap 流转换
            //将一个流中的每个值都转换为另一个流
        List<String > seventhNightNotE=seventhNight.stream()
                .map(m->m.split(" "))
                .flatMap(Arrays::stream)
                .collect(Collectors.toList());

        if (integerList.stream().allMatch(i->i>7)){ //allMatch 匹配所有元素
            System.out.println("所有元素都大于7");
        }
        if(integerList.stream().anyMatch(i->i>3)){//anyMatch匹配其中一个
            System.out.println("存在元素大于3");
        }
        if (integerList.stream().noneMatch(i->i>3)) {//不存在大于3的元素，即都小雨3
            System.out.println("所有元素小于3");
        }

        //终端操作
        integerList.stream().count();//流中元素总数

        Optional<Integer> integerOptional= integerList.stream().findFirst();//查找第一个
        Optional<Integer> integerOptional1 = integerList.stream().findAny();//随便查找一个
        System.out.println(integerOptional.orElse(-1));

        int sum=integerList.stream().reduce(0,Integer::sum);//求和

        Optional<Integer> min = integerList.stream()//获取最小值
                .min(Integer::compareTo);
        Optional<Integer> max = integerList.stream()//获取最大值
                .max(Integer::compareTo);

        Optional<Integer> min1 = integerList.stream().reduce(Integer::min);
        Optional<Integer> max1 = integerList.stream().max(Integer::max);
        double average = seventhNight.stream()
                .collect(averagingInt(String::length));//平均值

        integerList.stream().forEach(System.out::println);//输出

        List<Integer> intList = seventhNight.stream()
                .map(String::length)
                .collect(Collectors.toList());//转list

        //joining 拼接流中的元素
        String result=seventhNight.stream().collect(Collectors.joining("-"));
        System.out.println(result);
        //分组
        Map<Integer, List<String>> collect = seventhNight.stream()
                                .collect(groupingBy(String::length));//长度分组

        Map<Integer, Map<String, List<String>>> c = seventhNight.stream()//分组2
                .collect(groupingBy(
                        String::length,
                        groupingBy(item -> {
                            if (item.length() <= 2) {
                                return "level1";
                            } else if (item.length() <= 6) {
                                return "level2";
                            } else {
                                return "level3";
                            }
                        })
                ));

        //分区
        Map<Boolean, List<String>> collect1 = seventhNight.stream()
                .collect(partitioningBy(String::isEmpty));//按照是否为null分区

    }
}