Stream流：生成操作，中间操作，终结操作，收集操作以及它们的常用方法

Stream流作为函数式编程风格的体现，它将这种风格真正的引入到Java当中，我们可以通过直接阅读字面的意思来完美理解代码中的意思而无关逻辑，下面跟着示例一起练习学习，轻松搞定Stream流！

第一步：生成操作

Stream流生成的方式有以下几种，它是后续操作的基石。

Collection体系集合
使用默认方法stream()生成流， default Stream stream()
Map体系集合
把Map转成Set集合，间接的生成流
数组
通过Stream接口的静态方法of(T… values)生成流

package com.csf.streamIO;
import java.util.*;
import java.util.stream.Stream;

public class StreamDemo {
//    Stream流常见的生成方式
public static void main(String[] args) {
    //    集合体系下刘生成方式
    //list
    List<String> list = new ArrayList<String>();
    Stream<String> listStream = list.stream();
    //set
    HashSet<String> set = new HashSet<>();
    Stream<String> setStream = set.stream();
//    map体系下集合间接生成流
    Map<String, Integer> hashMap = new HashMap<>();
    Stream<String> key = hashMap.keySet().stream();
    Stream<Integer> valueStream = hashMap.values().stream();
    Stream<Map.Entry<String, Integer>> setS = hashMap.entrySet().stream();
//   数组通过of方法生成流
    String[] str ={"z","x","e"};
    Stream<String> str1 = Stream.of(str);
//    直接的方式
    Stream<Integer> integerStream = Stream.of(10, 20, 30);
    Stream<String> z = Stream.of("z", "x", "e");
}
}

第二步：中间操作

概念

中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。

常见方法

Stream filter(Predicate predicate) :用于对流中的数据进行过滤
Stream limit(long maxSize): 返回此流中的元素组成的流，截取前指定参数个数的数据
Stream skip(long n): 跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static Stream concat(Stream a, Streamb):合并a和b两个流为一个流
Stream distinct(): 返回由该流的不同元素（根据Object.equals(Object) ）组成的流
Stream sorted(): 返回由此流的元素组成的流，根据自然顺序排序
Stream sorted(Comparatorcomparator):返回由该流的元素组成的流，根据提供的Comparator进行排序
Stream map(Function mapper): 返回由给定函数应用于此流的元素的结果组成的流
IntStream mapToInt(ToIntFunctionmapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果

package com.csf.streamIO;
import java.util.ArrayList;
import java.util.stream.Stream;

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

        ArrayList<String> strings = new ArrayList<>();
        strings.add("周恩来");
        strings.add("周瑜儿");
        strings.add("大乔");
        strings.add("小乔");
        strings.add("周围");
        strings.add("诸葛亮");
        strings.add("关羽");

        //过滤
        strings.stream().filter(s -> s.startsWith("周")).forEach(System.out::println);
        System.out.println("----------");
        strings.stream().filter(s -> s.length()==3).forEach(System.out::println);
        System.out.println("----------");
        strings.stream().filter(s -> s.startsWith("周")).filter(s -> s.length()==3).forEach(System.out::println);
        limit:按顺序取出对应数据的参数
        strings.stream().limit(2).forEach(System.out::println);

//        skip:跳过几个元素，去除后面所有的元素
        strings.stream().skip(5).forEach(System.out::println);

//        跳过三个元素去后面的两个元素
        System.out.println("=====================");
        strings.stream().skip(3).limit(2).forEach(System.out::println);

//        concat:跟数据库concat一个意思，进行合并操作
//        获取list中的前4个数据组成的流
        System.out.println("=====================");
        Stream<String> limit = strings.stream().limit(4);
//        获取list中的跳过三个参数组成的流
        Stream<String> skip = strings.stream().skip(3);
//        进行合并操作
//        Stream.concat(limit,skip).forEach(System.out::println);

//        distinct去重操作:将上面例子中的重复参数进行去重
        System.out.println("=====================");
        Stream.concat(limit,skip).distinct().forEach(System.out::println);

//        sorted 排序
        ArrayList<String> list = new ArrayList<>();
        list.add("asdf");
        list.add("view");
        list.add("world");
        list.add("zezeze");
        list.add("january");
        list.add("yald");
        list.add("ko");
//        按照字母顺序把数据打印在控制台
        System.out.println("=====================");
        System.out.println("=====================");
        list.stream().sorted().forEach(System.out::println);
//        按照字符串长度进行排序输出
        System.out.println("=====================");
        System.out.println("=====================");
        list.stream().sorted((s1,s2)->{
           int num =s1.length()-s2.length();
           int num1 = num==0?s1.compareTo(s2):num;
           return num1;
        }).forEach(System.out::println);

//        map和mapToInt
        System.out.println("=====================");
        ArrayList<String> intList = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        intList.stream().map(s ->
            Integer.parseInt(s)
        ).forEach(System.out::println);

第三步：终结操作

概念

终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作。

常见方法

void forEach(Consumer action)： 对此流的每个元素执行操作
long count()： 返回此流中的元素数

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

        ArrayList<String> strings = new ArrayList<>();
        strings.add("周恩来");
        strings.add("周瑜儿");
        strings.add("大乔");
        strings.add("小乔");
        strings.add("周围");
        strings.add("诸葛亮");
        strings.add("关羽");
        //        终结操作：执行完此操作后，stream流将不能再执行其他操作
//        forEach：对此流的每个元素执行操作
//        count:返回此流中的元素数
        strings.stream().forEach(System.out::println);
        long count = strings.stream().count();
        System.out.println(count);
    }

第四步：收集操作

概念

对数据使用Stream流的方式操作完毕后，可以把流中的数据收集到集合中。

常用方法

R collect(Collector collector) 把结果收集到集合中

工具类Collectors提供了具体的收集方式

public static Collector toList() 把元素收集到List集合中
public static Collector toSet() 把元素收集到Set集合中
**public static Collector toMap(Function keyMapper,FunctionvalueMapper)**把元素收集到Map集合中

package com.csf.streamIO;

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

public class StreamDemo02 {
    public static void main(String[] args) {
        ArrayList<String> man = new ArrayList<>();
        man.add("周星驰");
        man.add("周润发");
        man.add("周润发");
        man.add("成龙");
        man.add("李连杰");
        man.add("周瑜");
        ArrayList<String> woman = new ArrayList<>();
        woman.add("张曼玉");
        woman.add("林青霞");
        woman.add("柳岩");
        woman.add("王祖贤");
        woman.add("林志玲");

        Stream<String> stream = man.stream().filter(s -> s.startsWith("周")).distinct();
        Stream<String> stringStream = woman.stream().limit(4).filter(s -> s.length() == 3);
        Stream<String> concat = Stream.concat(stringStream, stream);
        List<String> collect = concat.collect(Collectors.toList());
        System.out.println(collect);

//        数组和集合练习
        String[] str = {"张三,21","李四,12","王二麻,22","周六,18","刘七,20"};
        Map<String,Integer> map = Stream.of(str).filter(s -> Integer.parseInt(s.split(",")[1]) >= 20)
                .collect(Collectors.toMap(s->s.split(",")[0],s->Integer.parseInt(s.split(",")[1])));
        Set<String> strings = map.keySet();
        for (String key:strings){
            Integer integer = map.get(key);
            System.out.println(key+":"+integer);
        }

    }
}

有些方法示例可能没有全部列举到，举一反三即可。
学习记录！！！