Stream01 定义、迭代、操作、惰性求值

1 Stream

　　Stream 是 Java 8 提供的一系列对可迭代元素处理的优化方案，使用 Stream 可以大大减少代码量，提高代码的可读性并且使代码更易并行。

2 迭代

　　2.1 需求

　　　　随机创建int类型的数组，计算数组中各个元素的总和

　　2.2 思路

　　　　2.2.1 外部迭代

　　　　　　通过for循环迭代数组

　　　　2.2.2 内部迭代

　　　　　　先将数组转化成流 -> 在通过流的相关操作来实现

　　　　2.2.3 外部迭代和内部迭代

　　　　　　外部迭代式串行的，如果要实现并行需要自己编写代码实现；内部迭代实现并行操作只需要调用一个parallel()操作即可以啦

　　2.3 代码实现

package demo01_iteration;

import org.junit.Before;
import org.junit.Test;

import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;

/**
 * @author 王杨帅
 * @create 2018-06-24 22:48
 * @desc 外部迭代和内部迭代
 **/
public class Case01 {

    private int [] nums;
    private int count = 4;
    private Random random;

    @Before
    public void init() {
        random = new Random();
        nums = new int[count];
        for (int i = 0; i < nums.length; i++) { // 随机产生数组元素
            nums[i] = random.nextInt(30);
        }
    }

    /**
     * 外部迭代：自己利用for训话实现
     */
    @Test
    public void test01() {
        int sum = 0;
        for (int i : nums) {
            sum += i;
        }
        System.out.println(Arrays.toString(nums) + " 各个元素的累加和为：" + sum);
    }

    /**
     * 内部迭代：利用流的相关方法实现
     */
    @Test
    public void test02() {
        int sum = 0;
        sum = IntStream.of(nums).parallel().sum();
        System.out.println(Arrays.toString(nums) + " 各个元素的累加和为：" + sum);
    }

}

3 操作

　　3.1 分类

　　　　3.1.1 中间操作

　　　　　　返回一个Stream流的操作

　　　　3.1.2 终止操作

　　　　　　返回一个结果的操作

　　3.2 代码体验

package demo02_operation;

import org.junit.Before;
import org.junit.Test;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;

/**
 * @author 王杨帅
 * @create 2018-06-24 23:04
 * @desc 中间操作、终止操作、惰性求值
 **/
public class Case01 {

    private int [] nums;
    private int count = 5;
    private Random random;

    @Before
    public void init() {
        random = new Random();
        nums = new int[count];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = random.nextInt(30);
        }
    }

    /**
     * 终止操作: 返回一个结果的操作
     */
    @Test
    public void test01() {
        int sum = IntStream.of(nums).sum();
        System.out.println(Arrays.toString(nums) + " 各个元素之和为： " + sum);
    }

    /**
     * 中间操作：返回一个流的操作【例如：Map操作】
     */
    @Test
    public void test02() {
        System.out.println("老的数组为：" + Arrays.toString(nums));
        int [] newNums = IntStream.of(nums).map(s -> s + 2).toArray();
        System.out.println("新的数组为：" + Arrays.toString(newNums));
    }

}

4 惰性求值

　　如果流的操作中没有执行终止操作也不会执行中间操作

　　4.1 代码体验

package demo02_operation;

import org.junit.Before;
import org.junit.Test;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;

/**
 * @author 王杨帅
 * @create 2018-06-24 23:04
 * @desc 中间操作、终止操作、惰性求值
 **/
public class Case01 {

    private int [] nums;
    private int count = 5;
    private Random random;

    @Before
    public void init() {
        random = new Random();
        nums = new int[count];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = random.nextInt(30);
        }
    }

    /**
     * 惰性求值
     */
    @Test
    public void test01() {
        System.out.println("老的数组为：" + Arrays.toString(nums));
//        IntStream.of(nums).map(Case01::addFive); // 没有终止操作，map操作不会执行
        IntStream.of(nums).map(Case01::addFive).sum(); // 有中间操作，map操作会执行
    }

    public static Integer addFive(Integer num) {
        System.out.println("中间操作执行了");
        return num + 5;
    }

}

原文地址：https://www.cnblogs.com/NeverCtrl-C/p/9222265.html