jdk8新特性-Stream流详解及使用样例(Stream创建、使用、收集、并行流、注意事项)

jdk8新特性-Stream流详解及使用样例(Stream创建、使用、收集、并行流、注意事项)

文章目录

• 前言
• 一、Stream创建及注意事项
• 二、Stream常用处理方法
• 三、并行Stream流创建及使用
• 结尾

---

前言

注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！
Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工
处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。
Stream API能让我们快速完成许多复杂的 *** 作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。

---

一、Stream创建及注意事项

• Stream只能 *** 作一次
• Stream方法返回的是新的流
• Stream不调用终结方法，中间的 *** 作不会执行

package stream;

import java.util.*;
import java.util.stream.Stream;


public class StreamGetAndNotice {
    
    public void testGet() {
        // 方式1 : 根据Collection获取流
        // Collection接口中有一个默认的方法: default Stream stream()
        List list = new ArrayList<>();
        Stream stream1 = list.stream();

        Set set = new HashSet<>();
        Stream stream2 = set.stream();

        Map map = new HashMap<>();
        Stream stream3 = map.keySet().stream();
        Stream stream4 = map.values().stream();
        Stream> stream5 = map.entrySet().stream();

        // 方式2 : Stream中的静态方法of获取流
        // static Stream of(T... values)
        Stream stream6 = Stream.of("aa", "bb", "cc");

        String[] strs = {"aa", "bb", "cc"};
        Stream stream7 = Stream.of(strs);

        // 基本数据类型的数组行不行?不行的,会将整个数组看做一个元素进行 *** 作.
        int[] arr = {11, 22, 33};
        Stream stream8 = Stream.of(arr);
    }

    
    public void notice() {
        Stream stream = Stream.of("aa", "bb", "cc");
        // 1. Stream只能 *** 作一次
        // long count = stream.count();
        // long count2 = stream.count();

        // 2. Stream方法返回的是新的流
        // Stream limit = stream.limit(1);
        // System.out.println("stream" + stream);
        // System.out.println("limit" + limit);

        // 3. Stream不调用终结方法，中间的 *** 作不会执行
        stream.filter((s) -> {
            System.out.println(s);
            return true;
        }).count();
    }
}

---

二、Stream常用处理方法

package stream;

import stream.entity.Person;

import java.util.Optional;
import java.util.stream.IntStream;
import java.util.stream.Stream;


public class StreamCommonFunc {
    Stream stream = Stream.of("1111", "222", "333", "44", "55", "55");

    
    public void testForeach() {
        stream.forEach(System.out::println);
    }

    
    public void testCount() {
        System.out.println(stream.count());
    }

    
    public void testFilter() {
        stream.filter(s -> s.length() == 3).forEach(System.out::println);
    }

    
    public void testLimit() {
        stream.limit(3).forEach(System.out::println);
    }

    
    public void testSkip() {
        stream.skip(3).forEach(System.out::println);
    }

    
    public void testMap() {
        Stream s = stream.map(Integer::parseInt);
        s.forEach(System.out::println);
    }

    
    public void testSorted() {
        Stream s = stream.map(Integer::parseInt);
        s.sorted((i1, i2) -> i2 - i1).forEach(System.out::println);
    }

    

    public void testDistinct() {
        stream.distinct().forEach(System.out::println);
    }

    
    public void testMatch() {
        System.out.println(stream.allMatch(s -> s.length() > 2));
        System.out.println(stream.anyMatch(s -> s.length() > 2));
        System.out.println(stream.noneMatch(s -> s.length() > 2));
    }

    
    public void testFind() {
        System.out.println(stream.findFirst().get());
    }

    
    public void testMax_Min() {
        // 获取最大值
        // 1, 3, 5, 6
        Optional max = Stream.of(5, 3, 6, 1).max((o1, o2) -> o1 - o2);
        System.out.println("最大值: " + max.get());

        // 获取最小值
        // 1, 3, 5, 6
        Optional min = Stream.of(5, 3, 6, 1).min((o1, o2) -> o1 - o2);
        System.out.println("最小值: " + min.get());
    }


    public void testReduce() {
        // T reduce(T identity, BinaryOperator accumulator);
        // T identity: 默认值
        // BinaryOperator accumulator: 对数据进行处理的方式
        // reduce如何执行?
        // 第一次, 将默认值赋值给x, 取出集合第一元素赋值给y
        // 第二次, 将上一次返回的结果赋值x, 取出集合第二元素赋值给y
        // 第三次, 将上一次返回的结果赋值x, 取出集合第三元素赋值给y
        // 第四次, 将上一次返回的结果赋值x, 取出集合第四元素赋值给y
        int reduce = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
            System.out.println("x = " + x + ", y = " + y);
            return x + y;
        });
        System.out.println("reduce = " + reduce); // 21

        // 获取最大值
        Integer max = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
            return x > y ? x : y;
        });
        System.out.println("max = " + max);
    }

    public void testMapReduce() {
        // 求出所有年龄的总和
        // 1.得到所有的年龄
        // 2.让年龄相加
        Integer totalAge = Stream.of(
                        new Person("刘德华", 58),
                        new Person("张学友", 56),
                        new Person("郭富城", 54),
                        new Person("黎明", 52))
                .map((p) -> p.getAge()).reduce(0, Integer::sum);

        System.out.println("totalAge = " + totalAge);


        // 找出最大年龄
        // 1.得到所有的年龄
        // 2.获取最大的年龄
        Integer maxAge = Stream.of(
                        new Person("刘德华", 58),
                        new Person("张学友", 56),
                        new Person("郭富城", 54),
                        new Person("黎明", 52))
                .map(p -> p.getAge())
                .reduce(0, Math::max);
        System.out.println("maxAge = " + maxAge);

        // 统计 a 出现的次数
        //                          1    0     0    1    0    1
        Integer count = Stream.of("a", "c", "b", "a", "b", "a")
                .map(s -> {
                    if (s == "a") {
                        return 1;
                    } else {
                        return 0;
                    }
                })
                .reduce(0, Integer::sum);
        System.out.println("count = " + count);
    }

    public void testNumericStream() {
        // Integer占用的内存比int多,在Stream流 *** 作中会自动装箱和拆箱
        Stream stream = Stream.of(1, 2, 3, 4, 5);
        // 把大于3的打印出来
        // stream.filter(n -> n > 3).forEach(System.out::println);

        // IntStream mapToInt(ToIntFunction mapper);
        // IntStream: 内部 *** 作的是int类型的数据,就可以节省内存,减少自动装箱和拆箱

        IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt(Integer::intValue);
        intStream.filter(n -> n > 3).forEach(System.out::println);
    }

    
    public void testContact() {
        Stream streamA = Stream.of("张三");
        Stream streamB = Stream.of("李四");

        // 合并成一个流
        Stream newStream = Stream.concat(streamA, streamB);
        // 注意:合并流之后,不能 *** 作之前的流啦.
        // streamA.forEach(System.out::println);

        newStream.forEach(System.out::println);
    }
}

---

三、并行Stream流创建及使用

package com.cloud.jdk8.stream;

import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;


public class StreamParallel {

    
    @Test
    public void testGetParallelStream() {
        // 掌握获取并行Stream流的两种方式
        // 方式一:直接获取并行的Stream流
        List list = new ArrayList<>();
        Stream stream = list.parallelStream();

        // 方式二:将串行流转成并行流
        Stream parallel = list.stream().parallel();
    }

    
    @Test
    public void testParallel() {
        Stream.of(4, 5, 3, 9, 1, 2, 6)
                .parallel() // 转成并行流
                .filter(s -> {
                    System.out.println(Thread.currentThread() + "::" + s);
                    return s > 3;
                })
                .count();
    }

    
    @Test
    public void parallelStreamNotice() {
        ArrayList list = new ArrayList<>();
        

        // 解决parallelStream线程安全问题方案一: 使用同步代码块
        

        // 解决parallelStream线程安全问题方案二: 使用线程安全的集合
        // Vector v = new Vector();
        

        // 解决parallelStream线程安全问题方案三: 调用Stream流的collect/toArray
        List collect = IntStream.rangeClosed(1, 1000)
                .parallel()
                .boxed()
                .collect(Collectors.toList());
        System.out.println("collect.size = " + collect.size());
    }

}

---

结尾

• 感谢大家的耐心阅读，如有建议请私信或评论留言。
• 如有收获，劳烦支持，关注、点赞、评论、收藏均可，博主会经常更新，与大家共同进步