JAVA8 特性stream api的示例，利用stream转化list＜Integer＞和数组int[]转换

package com.example.springsourcelearn;

import org.junit.jupiter.api.Test;

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

/**
 * @author :yhc
 * @date :2021/8/24
 **/
//@SpringBootTest(classes = MockServletContext.class)
public class StreamTest {
    @Test
    public void test001(){
        System.out.println("---------");
    }

    //stream流的创建
    @Test
    public void createStream(){
        //方式一： 通过数组Arrays
        int[] arr = new int[]{1,2,3,4,5};
        IntStream stream = Arrays.stream(arr);
        //方式二： 通过List
        List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());
        Stream listStream = list.stream();
        //方式三： 通过Stream的of()
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
        //方式四：创建无限流
        //4-1 : 迭代
        Stream.iterate(0,t -> t+2).limit(10).forEach(System.out::println);
        //4-2 : 生成
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

    // 筛选与切片
    //  filter(Predicate p)    接收lambda，从流中筛选数据
    //  limit(n)               截断流，限制数量
    //  skip(n)                跳过元素，跳过前n个元素的流
    //  distinct()             去重，根据 hashCode() 和 equals() 去除重复元素
    @Test
    public void streamFilter(){
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        List<String> filtered = strings.stream().filter(str -> !str.isEmpty()).collect(Collectors.toList());
        //
        filtered.forEach(System.out::println);
    }

    //映射 map
    @Test
    public void streamMap(){
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee");
        list.stream().map(s -> s.toUpperCase()).forEach(System.out::println);
        System.out.println("----------------");

        // flatMap(Function f)把流中每个值都转化成另一个流，然后把所有流连接成一个流。
        Stream<Stream<Character>> streamStream = list.stream().map(StreamTest::strToStream);
        streamStream.forEach(s -> s.forEach(System.out::println));
        System.out.println("----------------");
        //flatMap
        Stream<Character> characterStream = list.stream().flatMap(StreamTest::strToStream);
        characterStream.forEach(System.out::println);
    }
    //映射  flatMap
    @Test
    public static Stream<Character> strToStream(String str){
        // String str = "HelloWorld!";
        ArrayList<Character> list = new ArrayList<>();
        for (Character c:str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
    //排序 sorted()
    @Test
    public void streamSort(){
        //sorted()  自然排序 类需要实现Comparable接口
        List<Integer> list = Arrays.asList(12, 56, 48, 41, 98, 11, 24, 52, 86, -6, 7);
        list.stream().sorted().forEach(System.out::println);
        System.out.println("----------------");
        // sorted(Comparator com) --定制排序
        list.stream().sorted((e1,e2) -> -Integer.compare(e1,e2)).forEach(System.out::println);
    }

    //终止操作
    // allMatch(Predicate e) ---检查是否匹配所有元素
    // noneMatch(Predicate e) --检查是否没有匹配一个元素
    // findFirst              --返回第一个元素
    // findAny                --返回当前流中的任意元素
    // count                  --返回元素中的总个数
    // max(Comparator con)    --返回流中最大值
    // min(Comparator con)    --返回流中最小值
    // forEach(Consumer c)    --内部迭代

    @Test
    public void streamFinal(){
        Comparator<String> strCom = String::compareTo;
        Comparator<Integer> intCom = Integer::compareTo;
        List<Integer> list = Arrays.asList(12, 56, 48, 41, 98, 11, 24, 52, 86, -6, 7);
        // findAny
        Optional<Integer> any = list.parallelStream().findAny();
        System.out.println(any);
        // max
        Optional<Integer> max = list.stream().max(intCom);
        System.out.println(max);
    }

    //归约
    // reduce
    // T reduce(T identity, BinaryOperator<T> accumulator);   BinaryOperator
    // Optional<T> reduce(BinaryOperator<T> accumulator);
    /**
     *     使用：BiFunction、BinaryOperator
     *     <U> U reduce(U identity,
     *                  BiFunction<U, ? super T, U> accumulator,
     *                  BinaryOperator<U> combiner);
     */
    @Test
    public void streamReduce(){
        List<Integer> list = Arrays.asList(12, 56, 48, 41, 98, 11, 24, 52, 86, -6, 7);
        Integer reduce = list.stream().reduce(0, Integer::sum);
        System.out.println(reduce);
    }

    // 收集
    // collect(Collector c)
    @Test
    public void streamCollect(){
        List<Integer> list = Arrays.asList(12, 56, 48, 41, 98, 11, 24, 52, 86, -6, 7);
        List<Integer> collect = list.stream().filter(integer -> integer >= 50).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

    // Optional 避免空指针的容器（包装类）
    @Test
    public void optionalTest(){
        Optional<Integer> integer = Optional.of(5);  // 创建Optional实例 （必须非空）
        Optional<Object> empty = Optional.empty();   // 创建空的Optional 实例
        Optional<Object> o = Optional.ofNullable(null);  // 创建可以哦为null 的实例 （可以为空）
        // 如果o包装的类非空返回o拆箱实体，空则返回替代
        Object oo = o.orElse("空则替代");
        System.out.println(o);
        System.out.println(oo);
    }



    // 利用stream流做转换

    /**
     *     boxed()
     *
     *     @Override
     *     public final Stream<Integer> boxed() {
     *         return mapToObj(Integer::valueOf);
     *     }
     *
     *     作用：boxed的作用就是将int类型的stream转成了Integer类型的Stream。
     *      （装箱）
     *      IntStream -> Stream<Integer>
     *
     */



    /**
     * 1.list<Integer>和数组int[]转换
     * 2.List<String>和String[]同理
     */
    @Test
    public void streamConvert(){
        int[] data = {4, 5, 3, 6, 2, 5, 1};

        // int[] -> List<Integer>
        List<Integer> list = Arrays.stream(data).boxed().collect(Collectors.toList());
         //list.forEach(System.out::println);

        //int[]  -> Integer[]
        Integer[] integers = Arrays.stream(data).boxed().toArray(Integer[]::new);

        // List<Integer> -> Integer[]
        Integer[] integers2 = list.toArray(new Integer[0]);

        //List<Integer> -> int[]
        int[] arr1 = list.stream().mapToInt(Integer::valueOf).toArray();

        //Integer[] -> int[]
        int[] arr2 = Arrays.stream(integers).mapToInt(Integer::valueOf).toArray();

        // Integer[] -> List<Integer>
        List<Integer> list2 = Arrays.asList(integers);


        // 同理
        String[] strings1 = {"a", "b", "c"};
        // String[] 转 List<String>
        List<String> list3 = Arrays.asList(strings1);
        // List<String> 转 String[]
        String[] strings2 = list3.toArray(new String[0]);

    }


    @Test
    public void fore() {
        int[] data = {4, 5, 3, 6, 2, 5, 1};
        // int[] -> List<Integer>
        List<Integer> list = Arrays.stream(data).boxed().collect(Collectors.toList());

        for (Integer item:list) {
            list.remove(item);
        }
        System.out.println(list.size());
    }
}