Stream流体系

概述

• 得益于Lambda所带来的函数式编程
• 用于简化集合和数组操作的API

Stream流式思想的核心

1. 得到集合或者数组的Stream流(相当于一根传送带)
2. 把元素放上去
3. 利用Stream流简化的API方便的操作元素

Tips:Stream只能使用一次

Stream流的三类方法

• 获取Stream流
  • 创建一条流水线，并把数据放到流水线上准备进行操作
• 中间方法
  • 流水线上的操作。一次操作完毕之后，还可以进行其他操作(支持链式编程)
• 终结方法
  • 一个Stream流只能有一个终结方法，是流水线上的最后一个操作
  • count() forEach() 都是终结方法

集合获取Stream流

使用Collection接口中的默认方法stream()生成流

名称	说明
default Stream stream()	获取当前集合对象的Stream流

数组获取获取Stream流

名称	说明
public static Stream stream(T[] array )	获取当前数组的Stream流
public static Stream of(T… values )	获取当前数组/可变数据的Stream流

package com.test;

import com.sun.xml.internal.ws.fault.SOAPFaultBuilder;

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

public class StreamDemo {
    public static void main(String[] args) {
        /**
         * Collection 集合获取Stream流
         */
        List<String> list = new ArrayList<>();
        Stream<String> ListStream = list.stream();

        /**
         * Map 集合获取Stream流
         */
        Map<String,Integer> map = new HashMap<>();

        // 键流
        Stream<String> keyStream = map.keySet().stream();

        // 值流
        Stream<Integer> valueStream = map.values().stream();
        
        // 键值对流 map 转 set
        Stream<Map.Entry<String, Integer>> keyAndValueStream= map.entrySet().stream();

        /**
         * Array 数组获取Stream流
         *
         */
        String[] names = {"JOJO","Ray"};
        Stream<String> ArrayStream = Arrays.stream(names);
        Stream<String> ArrayStream2 = Stream.of(names);
    }
}

Stream流的常用API

package com.test;

import javax.jws.soap.SOAPBinding;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"张三丰","张无忌","周芷若","赵敏","张靖");
        System.out.println(names);

        // 以张开头的名字
        List<String> ZhangList = new ArrayList<>();
        for (String name:names) {
            if(name.startsWith("张")){
                ZhangList.add(name);
            }
        }
        System.out.println(ZhangList);

        // 以张开头三个字的名字
        List<String> ZhangThreeList = new ArrayList<>();
        for (String name:ZhangList) {
            if(name.length() == 3){
                ZhangThreeList.add(name);
            }
        }
        System.out.println(ZhangThreeList);

        // 使用Stream流实现
        names.stream()
                .filter(name -> name.startsWith("张"))
                .filter(name -> name.length() == 3)
                .forEach(System.out::println);

        // 截取前2个张姓名字 limit
        // names.stream().filter(name -> name.startsWith("张")).limit(2).forEach(name -> System.out.println(name));
        names.stream().filter(name -> name.startsWith("张")).limit(2).forEach(System.out::println);// 方法引用

        // 跳过前2个张姓名字 skip
        // names.stream().filter(name -> name.startsWith("张")).limit(2).forEach(name -> System.out.println(name));
        names.stream().filter(name -> name.startsWith("张")).skip(2).forEach(System.out::println);// 方法引用

        // 三个字名字的个数
        long count = names.stream().filter(name -> name.length() == 3).count();
        System.out.println(count);

        // map 加工方法
        names.stream().map(name->"smart"+name).forEach(System.out::println);

        // map 加工成对象
        //names.stream().map(name -> new User(name)).forEach(System.out::println);
        names.stream().map(User::new).forEach(user -> System.out.println(user.getName())); // 构造器引用

        // 合并流
        Stream<String> stringStream = names.stream().filter(name -> name.startsWith("张"));
        Stream<String> stringStream1 = Stream.of("Java1", "Java2");
        Stream<String> concat = Stream.concat(stringStream, stringStream1);
        concat.forEach(System.out::println);
    }
}

Stream流收集

package com.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("周芷若");
        list.add("郭靖");
        list.add("张流");

        /*
          Stream流 收集到 List 集合
         */
        Stream<String> zhangStream = list.stream().filter(name -> name.startsWith("张"));
        List<String> zhangList = zhangStream.collect(Collectors.toList());
        System.out.println(zhangList);

        /*
          Stream流 收集到 Set 集合
         */
        Set<String> set = list.stream().filter(name -> name.length() == 3).collect(Collectors.toSet());
        System.out.println(set);

        /*
         * Stream流 收集到 Array 数组
         */
        /**
         * 接受全部类型
         */
        //Object[] array = list.stream().filter(name -> name.startsWith("张")).toArray();
        /**
         * 单种类型原始写法
         */
//        String[] array = list.stream().filter(name -> name.startsWith("张")).toArray(new IntFunction<String[]>() {
//            @Override
//            public String[] apply(int value) {
//                return new String[value];
//            }
//        });
        /**
         * 单种类型 lambda 简化
         */
        //String[] array = list.stream().filter(name -> name.startsWith("张")).toArray(length -> new String[length]);
        /**
         * 单种类型 方法引用 简化
         */
        String[] array = list.stream().filter(name -> name.startsWith("张")).toArray(String[]::new);
        System.out.println(Arrays.toString(array));
    }
}