# java_base

**Repository Path**: FlowersDance/java_base

## Basic Information

- **Project Name**: java_base
- **Description**: java基础 
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-01-28
- **Last Updated**: 2024-01-29

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Stream

将要处理元素集合看做一种流使用流的过程中，使用StramAPI对流中的元素进行操作，例如筛选、排序、聚合等操作

- stream 不存储数据 按照特定的规则对数据进行计算，一般会输出结果
- stream 不改变数据源 在通常情况下会产生一个新的集合或值
- stream具有延迟执行的特性 只要调用终端操作时 中间操作才会执行

![](assetes/73063862340e4cfcbb31fb53b3f5db0d.png)

## Stream的创建

```java
public class Main {
    private static List<Integer> list = Arrays.asList(1, 4, 2, 3);
    private static int[] nums = {1, 5, 3};

    public static void main(String[] args) {
        functionToStream();
    }


    public static void listToStream() {
        //创建顺序流
        Stream<Integer> stream = list.stream();

        //创建并行流
        Stream<Integer> integerStream = list.parallelStream();
    }

    public static void arrayToStream() {
        //通过数组创建stream
        IntStream intStream = Arrays.stream(nums);
    }

    /**
     * @description: iterate方法接受两个参数，第一个为初始化值，第二个为进行的函数操作，因为iterator生成的流为无限流，通过limit方法对流进行了截断，只生成5个偶数
     * @description: generate方法接受一个参数，方法参数类型为Supplier ，由它为流提供值。generate生成的流也是无限流，因此通过limit对流进行了截断
     */
    public static void functionToStream() {
        Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(5);
        stream.forEach(System.out::print);//打印出0,2,4,6,8

        Stream<Integer> stream1 = Stream.generate(() -> 1).limit(5);
        stream1.forEach(System.out::print);//打印出11111
    }
}

```

## Stream的操作

### 中间操作符

对源数据进行的计算只有在需要的时候才会执行，一个流可以跟随一个或多个中间操作，主要目的是打开流。某种程度上的数据映射/过滤 返回一个新的流 交给下一个操作使用

- filter //通过设置的条件过滤出元素
- map //修改每个元素的值
- distinct //去重
- sorted //排序 顺序排序
- limit //限制流的大小 指定元素的个数
- skip  //跳过前3个元素
- flatMap 把元素的每个值变成一个流 再把所有的流合成一个流

```java
List<String> list=Arrays.asList("1,2,3.5","78+8,87。4");
Stream<String> stringStream = list.stream().flatMap(s ->Stream.of(s.split(",")));//把流中的每一个值都变成一个流 再把所有流合成一个流
stringStream.forEach(System.out::print);//输出1 2 3.5 78+8 87。4
```

- peek 消费 查看元素的值

```java
stream.peek(System.out::println).collect(Collectors.toList());
```

### 终端操作符

Stream执行完毕之后的终端操作 无法再继续执行其他动作，否则报状态异常

- collect 收集器 把流转为其他形式
- forEach 遍历
- findFirst 返回第一个元素
- findAny 返回任意一个元素
- count 返回元素个数
- sum 求和
- max 最大值
- min 最小值
- anyMatch 检查是否至少有一个元素匹配
- allMatch 检查所有元素是否都匹配
- noneMatch 检查所有元素是否都不匹配
- reduce 将流中的元素结合起来和到一个值

```java
public class EndMain {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

        // 1. 用collect方法将流转换为List
        List<Integer> list = stream.collect(Collectors.toList());
        Set<Integer> set = stream.collect(Collectors.toSet());

        // 2. 用forEach方法遍历流中的元素
        stream.forEach(System.out::println);

        // 3. 用findAny方法获取流中的任意一个元素
        Integer integer = stream.findAny().get();

        // 4. 用count方法获取流中的元素个数
        long count = stream.count();

        // 5. 用mapToInt方法将流中的元素转换为int类型，然后求和
        int sum = stream.mapToInt(Integer::intValue).sum();

        // 6. 用min方法获取流中的最小值
        Integer min = stream.min(Comparator.comparing(Integer::intValue)).get();

        // 7. 用max方法获取流中的最大值
        Integer max = stream.max(Comparator.comparing(Integer::intValue)).get();

        // 8. 用anyMatch方法判断流中是否有元素满足条件
        boolean anyMatch = stream.anyMatch(i -> i == 1);

        // 9. 用allMatch方法判断流中是否所有元素都满足条件
        boolean allMatch = stream.allMatch(i -> i > 2);

        // 10. 用noneMatch方法判断流中是否没有元素满足条件
        boolean noneMatch = stream.noneMatch(i -> i > 2);

        // 11. 用reduce方法将流中的元素合并为一个元素
        Optional<Integer> reduce = stream.reduce((i, j) -> i - j);

    }
}

```

## Collect 收集

collector 将指定元素累加存放到结果容器中的能力 在collectors工具中提供collector接口的实现类

```java
public class CollectMain {
    public static void main(String[] args) {
        Stream<User> stream = Stream.of(
                new User("张三", 18, "男"),
                new User("李四", 20, "男"),
                new User("王五", 18, "女"));

        //把名字映射成名字列表
        List<String> stringList = stream.map(User::getName).collect(Collectors.toList());

        //把名字和性别映射成名字和性别映射的Map
        Map<String, String> stringStringMap = stream.collect(Collectors.toMap(User::getName, User::getSex));

        //把年龄大于18的年龄求和
        long sum = stream.filter(user -> user.getAge() > 18).collect(Collectors.summarizingInt(User::getAge)).getSum();
        

        String collect = stream.map(User::getSex).collect(Collectors.joining(","));
        System.out.println(collect);//男,男,女

        //分组
        Map<String, List<User>> stringListMap = stream.collect(Collectors.groupingBy(User::getSex));
        System.out.println(stringListMap);//{女=[User(name=王五, age=18, sex=女)], 男=[User(name=张三, age=18, sex=男), User(name=李四, age=20, sex=男)]}


    }
}

```