Stream API中间类型的转换（IntStream，Stream＜Integer＞，OptionalInt和Optional＜Integer＞）

在Java 8及以上版本中，Stream API的使用场景中，常见的是生成IntStream以及Stream<Integer>这样的中间流类型。这些流类型在数据处理过程中，常常会作为中间步骤，用于执行诸如sum、average等聚合操作。这些操作执行完毕后，通常会返回OptionalInt和Optional<Integer>这样的特殊类型，以处理可能的结果值缺失情况。

为了理解IntStream与Stream，以及它们与OptionalInt和Optional之间的差异，并掌握它们之间的转换机制，本文进行了一系列总结。

---

目录

一、创建 IntStream 和 Stream

二、IntStream 和 Stream 的相互转换

三、Stream 向 Optional 的转换

四、int[], Integer[] 和 List 的相互转换

1. int[] 向 Integer[] 转换

2. Integer[] 向 int[] 转换

3. int[] 向 List 转换

4. List 向 int[] 转换

5. Integer[] 向 List 转换

 6. List 向 Integer[] 转换

---

前置知识：Stream API

可参考 Stream API 详解和25道练习题-CSDN博客

一、创建 IntStream 和 Stream<Integer>

• 集合通过 Collection.stream() 创建
• 数组通过 Arrays.stream(arr) 创建

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

public class Main {
    public static void main(String[] args) {

        // IntStream 和 Stream<Integer> 的创建
        List<Integer> ListArr = Arrays.asList(1, 2, 3, 4, 5);
        Integer[] IntegerArr = {1, 2, 3, 4, 5};
        int[] IntArr = {1, 2, 3, 4, 5};

        Stream<Integer> integerStream1 = ListArr.stream();             // Stream<Integer>类型
        Stream<Integer> integerStream2 = Arrays.stream(IntegerArr);    // Stream<Integer>类型
        IntStream intStream = Arrays.stream(IntArr);                   // IntStream类型


        integerStream1.forEach(s -> System.out.print(s + " "));        // 1 2 3 4 5
        System.out.println();

        integerStream2.forEach(s -> System.out.print(s + " "));        // 1 2 3 4 5
        System.out.println();

        intStream.forEach(s -> System.out.print(s + " "));             // 1 2 3 4 5
        System.out.println();

    }
}

二、IntStream 和 Stream<Integer> 的相互转换

• IntStream => Stream<Integer> 需要通过boxed()转换
• Stream<Integer> => IntStream 需要通过mapToInt(Integer::intvalue)转换

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

public class Main {
    public static void main(String[] args) {
        
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> collect = list.stream()                // Stream<Integer>类型
                .mapToInt(Integer::intValue)                 // IntStream类型
                .boxed()                                     // Stream<Integer>类型
                .collect(Collectors.toList());
        System.out.println(collect);                         // [1, 2, 3, 4, 5]
      
    }
}

三、Stream 向 Optional 的转换

• IntStream 和 Stream<Integer> 向 OptionalInt 和 Optional<Integer> 转换通常是依赖于聚合函数，如 sum 和 average 等。

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

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        OptionalInt MaxOptionalInt = list.stream()               // Stream<Integer>类型
                .mapToInt(Integer::intValue)                     // IntStream类型
                .max();                                          // OptionalInt类型
        //getAsInt或ifPresent输出
        System.out.println(MaxOptionalInt.getAsInt());           // 5

        Optional<Integer> MaxOptionalInteger = list.stream()     // Stream<Integer>类型
                .max(Integer::compareTo);                        // Optional<Integer>类型
        //get或ifPresent输出
        System.out.println(MaxOptionalInteger.get());            // 5
    }
}

四、int[], Integer[] 和 List<Integer> 的相互转换

1. int[] 向 Integer[] 转换

• int[]向Integer[]转换：int[] -> IntStream -> Stream<Integer> -> Integer[]

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

public class Main {
    public static void main(String[] args) {
        int[] IntArr = {1, 2, 3, 4, 5};

        // int[] -> IntStream -> Stream<Integer> -> Integer[]
        Integer[] IntegerArr = Arrays.stream(IntArr)
                .boxed()
                .toArray(Integer[]::new);

        System.out.println(Arrays.toString(IntegerArr)); //[1, 2, 3, 4, 5]

    }
}

2. Integer[] 向 int[] 转换

• Integer[]向int[]转换：Integer[] -> Stream<Integer> -> IntStream -> int[]

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

public class Main {
    public static void main(String[] args) {
        Integer[] IntegerArr = {1, 2, 3, 4, 5};

        // Integer[] -> Stream<Integer> -> IntStream -> int[]
        int[] IntArr = Arrays.stream(IntegerArr)
                .mapToInt(Integer::intValue)
                .toArray();

        System.out.println(Arrays.toString(IntArr)); //[1, 2, 3, 4, 5]

    }
}

3. int[] 向 List<Integer> 转换

• int[]向List<Integer>转换：int[] -> IntStream -> Stream<Integer> -> List<Integer>

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

public class Main {
    public static void main(String[] args) {
        int[] IntArr = {1, 2, 3, 4, 5};

        // int[] -> IntStream -> Stream<Integer> -> List<Integer>
        List<Integer> ListArr = Arrays.stream(IntArr)
                .boxed()
                .collect(Collectors.toList());

        System.out.println(ListArr); //[1, 2, 3, 4, 5]

    }
}

4. List<Integer> 向 int[] 转换

• List<Integer>向int[]转换：List<Integer> -> Stream<Integer> -> IntStream -> int[]

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

public class Main {
    public static void main(String[] args) {
        List<Integer> ListArr = Arrays.asList(1, 2, 3, 4, 5);

        // List<Integer> -> Stream<Integer> -> IntStream -> int[]
        int[] IntArr = ListArr.stream()
                .mapToInt(Integer::intValue)
                .toArray();

        System.out.println(Arrays.toString(IntArr));
        
    }
}

5. Integer[] 向 List<Integer> 转换

• Integer[]向List<Integer>转换：Integer[] -> Stream<Integer> -> List<Integer>

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Integer[] IntegerArr = {1, 2, 3, 4, 5};

        // Integer[] -> Stream<Integer> -> List<Integer>
        List<Integer> ListArr = Arrays.stream(IntegerArr)
                .collect(Collectors.toList());

        System.out.println(ListArr); //[1, 2, 3, 4, 5]

    }
}

 6. List<Integer> 向 Integer[] 转换

• List<Integer>向Integer[]转换：List<Integer> -> Stream<Integer> -> Integer[]

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> ListArr = Arrays.asList(1, 2, 3, 4, 5);

        // Integer[] -> Stream<Integer> -> List<Integer>
        Integer[] array = ListArr.stream()
                .toArray(Integer[]::new);

        System.out.println(Arrays.toString(array)); //[1, 2, 3, 4, 5]
        
    }
}