Stream--流编程

其他 2020-03-25 19:22:46 阅读次数: 0

Stream流编程

Stream不是集合元素，也不是数据结构，它相当于一个 高级版本的 Iterator，不可以重复遍历里面的数据，像水一样，流过了就一去不复返。它和普通的 Iterator 不同的是，它可以并行遍历，普通的 Iterator 只能是串行，在一个线程中执行。

外部迭代与内部迭代

使用for等进行迭代我们叫做外部迭代，使用stream流迭代叫做内部迭代。

public class StreamDemo {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        //外部迭代
        int sum = 0;
        for (int i : nums)
            sum += i;
        System.out.println("结果为：" + sum);

        //内部迭代
        int sum1 = IntStream.of(nums).sum();
        System.out.println("结果为：" + sum1);
    }
}

中间操作/终止操作和惰性求值

  • 中间操作：返回stream的操作
  • 终止操作：得到特定的结果
  • 惰性求值：终止没有调用的情况下，中间操作不会执行
public class StreamDemo {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        //外部迭代
        int sum = 0;
        for (int i : nums)
            sum += i;
        System.out.println("结果为：" + sum);

        //内部迭代
        //map就是中间操作（返回stream的操作）
        //sum就是终止操作
        int sum1 = IntStream.of(nums).map(StreamDemo::doubleNum).sum();
        System.out.println("结果为：" + sum1);
        System.out.println("惰性求值就是终止操作没用调用的情况下，中间操作不会执行");

        IntStream.of(nums).map(StreamDemo::doubleNum);//未调用终止操作，中间操作不会执行
    }

    public static int doubleNum(int i) {
        System.out.println("执行了乘以2");
        return i * 2;
    }
}

创建

相关方法
集合 Collection.stream/parallelStream
数组 Arrays.stream
数字Stream IntStream/LongStream.range/rangeClosed
Random.ints/longs/doubles
自己创建 Stream.generate/iterate 
public class StreamDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        
        //从集合创建
        list.stream();
        list.parallelStream();
        
        //从数组创建
        Arrays.stream(new int[]{2, 3, 5});
        
        //创建数字流
        IntStream.of(1, 2, 3);
        IntStream.rangeClosed(1, 10);
        
        //使用random创建一个无线流
        new Random().ints().limit(10);
        
        //自己创建
        Random random = new Random();
        Stream.generate(() -> random.nextInt()).limit(20);
    }
}

中间操作

  • 有状态操作：当前操作与其他操作有依赖关系。(一般而言有状态操作都是有2个参数传入)
  • 无状态操作：当前操作与其他操作没有依赖关系。
相关方法
无状态操作 map/mapToXxx
flatMap/flatMapToXxx
filter
peek
unordered
有状态操作 distinct
sorted
limit/skip		 
public class StreamDemo3 {
    public static void main(String[] args) {
        String str = "my name is 007";

        //打印每个单词的长度
        Stream.of(str.split(" "))
                .map(s -> s.length())
                .forEach(System.out::println);

        //长度大于2
        Stream.of(str.split(" "))
                .filter(s -> s.length() > 2)
                .map(s -> s.length())
                .forEach(System.out::println);

        //flatMap A -> B属性（是个集合），最终得到所有的A元素里面的所有B属性集合
        //intStream/longStream并不是Stream的子类，所以要进行装箱boxed
        Stream.of(str.split(" "))
                .flatMap(s -> s.chars().boxed())
                .forEach(i -> System.out.print((char)i.intValue()));

        System.out.println("");

        //peek用于debug，是个中间操作，用法和forEach基本一致，但forEach是终止操作
        Stream.of(str.split(" ")).peek(System.out::print).forEach(System.out::print);//打印两次


        System.out.println("");

        //limit使用，主要用于无线流
        new Random().ints()
                .filter(i -> i > 100 && i < 10000)
                .limit(10)
                .forEach(System.out::println);

    }
}

终止操作

  • 非短路操作：需要等待所有结果都计算完毕才终止流
  • 短路操作：不需要等待所有结果都计算完毕才终止流
相关方法
非短路操作 forEach/forEachOrdered
collect/toArray
reduce
min/max/count
短路操作 findFirst/findAny
allMatch/anyMatch/noneMatch		 
public class StreamDemo4 {
    public static void main(String[] args) {
        String str = "my name is 007";

        //并行流使用forEach
        str.chars().parallel().forEach(i -> System.out.print((char)i));
        System.out.println();
        //并行流使用forEachOrdered,保证了顺序
        str.chars().parallel().forEachOrdered(i -> System.out.print((char)i));

        System.out.println();
        //收集到list
        List<String> list = Stream.of(str.split(" ")).collect(Collectors.toList());
        System.out.println(list);

        //使用reduce拼接字符串
        Optional<String> optional = Stream.of(str.split(" ")).reduce((s1, s2) -> s1 + "|" + s2);
        System.out.println(optional.orElse(""));

        //带初始值的reduce
        String reduce = Stream.of(str.split(" ")).reduce("", (s1, s2) -> s1 + "|" + s2);
        System.out.println(reduce);

        //求所有单词总长度
        Integer length = Stream.of(str.split(" ")).map(s -> s.length())
                .reduce(0, (s1, s2) -> s1 + s2);
        System.out.println(length);

        //求最长单词
        Optional<String> max = Stream.of(str.split(" ")).max((s1, s2) -> s1.length() - s2.length());
        System.out.println(max.get());


        OptionalInt first = new Random().ints().findFirst();
        System.out.println(first.getAsInt());
    }

并行流

并行流使用的线程池: ForkJoinPool.commonPool
默认的线程数是 当前机器的cpu个数
使用这个属性可以修改默认的线程数

IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();

public class StreamDemo5 {
    public static void main(String[] args) {
        //调用parallel产生一个并行流
        //IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();

        //现在要实现一个这样的效果：
        // IntStream.range(1, 100)
        //         //调用parallel产生并行流
        //         .parallel().peek(StreamDemo5::debug)
        //         //调用sequential产生串行流
        //         .sequential().peek(StreamDemo5::debug2)
        //         .count();
        //结论：多次调用parallel/sequential，以最后一次调用为准

        //并行流使用的线程池：ForkJoinPool.commonPool
        //默认线程数：当前机器的cpu个数
        //IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();

        //使用自己的线程池，放置任务阻塞
        ForkJoinPool pool = new ForkJoinPool(20);
        pool.submit(() -> IntStream.range(1, 100)
                .parallel()
                .peek(StreamDemo5::debug)
                .count());
        pool.shutdown();

        //防止主线程退出
        synchronized (pool) {
            try {
                pool.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }


    public static void debug(int i) {
        System.out.println(Thread.currentThread().getName() + "debug " + i);
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void debug2(int i) {
        System.err.println("debug " + i);
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

收集器

将处理后的流收集到集合中

package pers.zhang.stream;

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

/**
 * @Author: acton_zhang
 * @Date: 2020/3/24 5:06 下午
 * @Version 1.0
 */
public class StreamDemo6 {
    public static void main(String[] args) {
        // 测试数据
        List<Student> students = Arrays.asList(
                new Student("小明", 10, Gender.MALE, Grade.ONE),
                new Student("大明", 9, Gender.MALE, Grade.THREE),
                new Student("小白", 8, Gender.FEMALE, Grade.TWO),
                new Student("小黑", 13, Gender.FEMALE, Grade.FOUR),
                new Student("小红", 7, Gender.FEMALE, Grade.THREE),
                new Student("小黄", 13, Gender.MALE, Grade.ONE),
                new Student("小青", 13, Gender.FEMALE, Grade.THREE),
                new Student("小紫", 9, Gender.FEMALE, Grade.TWO),
                new Student("小王", 6, Gender.MALE, Grade.ONE),
                new Student("小李", 6, Gender.MALE, Grade.ONE),
                new Student("小马", 14, Gender.FEMALE, Grade.FOUR),
                new Student("小刘", 13, Gender.MALE, Grade.FOUR));


        //得到所有学生的年龄列表
        //s -> s.getAge() -----> Student::getAge,不会多生成一个类似lambda$0这样的函数
        Set<Integer> collect = students.stream()
                .map(Student::getAge)
                //.collect(Collectors.toList());
                .collect(Collectors.toCollection(TreeSet::new));//可以指定集合类型
        System.out.println(collect);


        //统计汇总信息
        IntSummaryStatistics collect1 = students.stream().collect(Collectors.summarizingInt(Student::getAge));
        System.out.println(collect1);

        //分块
        Map<Boolean, List<Student>> collect2 = students.stream().collect(Collectors.partitioningBy(s -> s.getGender() == Gender.MALE));
        System.out.println(collect2);

        //分组
        Map<Grade, List<Student>> collect3 = students.stream().collect(Collectors.groupingBy(Student::getGrade));
        System.out.println(collect3);

        //得到所有班级学生的个数
        Map<Grade, Long> collect4 = students.stream()
                .collect(Collectors.groupingBy(Student::getGrade, Collectors.counting()));
        System.out.println(collect4);
    }
}

/**
 * 学生 对象
 */
class Student {
    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private int age;

    /**
     * 性别
     */
    private Gender gender;

    /**
     * 班级
     */
    private Grade grade;

    public Student(String name, int age, Gender gender, Grade grade) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

    public Gender getGender() {
        return gender;
    }

    public void setGender(Gender gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "[name=" + name + ", age=" + age + ", gender=" + gender
                + ", grade=" + grade + "]";
    }

}

/**
 * 性别
 */
enum Gender {
    MALE, FEMALE
}

/**
 * 班级
 */
enum Grade {
    ONE, TWO, THREE, FOUR;
}
吴声子夜歌
发布了861 篇原创文章 · 获赞 2275 · 访问量 30万+
他的留言板 关注

猜你喜欢

转载自blog.csdn.net/cold___play/article/details/105072405
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022