学习笔记之Stream流

Stream 流

体验

• 需求：按下面得要求完成集合的创建和遍历
  1. 创建一个集合，存储多啊哥字符串元素
  2. 把集合中所有以"张"开头的元素存储到一个新的集合
  3. 把"张"开头的集合中的长度为3的元素存储到一个新的集合
  4. 遍历上一步得到集合

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //方式一
        System.out.println("-------方式一---------");
        ArrayList<String> array = new ArrayList<>();

        ArrayList<String> zhanglist = new ArrayList<>();

        ArrayList<String> threelist = new ArrayList<>();
        array.add("张三丰");
        array.add("贾宝玉");
        array.add("林黛玉");
        array.add("杨过");
        array.add("郭靖");
        array.add("张敏");
        array.add("张无忌");
        for (String i : array) {
            if (i.startsWith("张")) {
                zhanglist.add(i);
            }
        }
        for (String i : zhanglist) {
            if (i.length() == 3) {
                threelist.add(i);
            }
        }
        for (String i : threelist) {
            System.out.println(i);
        }

        System.out.println("--------方式二----------");
        //方式二:
        //Stream流
        System.out.println("-------Lambda表达式-----");
        array.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        System.out.println("--------方法引用--------");
        array.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

直接阅读代码的字面意识即可完美展示无关逻辑方式的语义:生成流、过滤姓张、过滤长度为3、逐一打印
Stream流把真正的函数式编程风格引入到了java中

---

Stream流的生成方式

Stream流的使用

• 生成流
  • 通过数据源(集合，数组等)生成流
  • list.stream()
• 中间操作
  • 一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
  • filter()
• 总结操作
  • 一个流只能有一个终结操作，当这个操作执行后，流就被使用"光"了，无法再被操作。所以这必定是流的最后一个操作
  • forEach()

Stream流的生成方式

Stream流的常见生成方式

• Collection体系的集合可以使用默认的方法stream()生成流
  • default Stream stream()
• Map体系的集合间接的生成流
• 数组可以通过Stream接口的静态方法of(T...values)生成流

import java.util.*;
import java.util.stream.Stream;
public class Demo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认的方法stream()生成流
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();
        Set<String> set = new TreeSet<>();
        Stream<String> SetStream = set.stream();

        //Map体系的集合间接的生成流
        Map<String, Integer> map = new HashMap<>();
        Stream<String> KeyStream = map.keySet().stream();
        Stream<Integer> valuesStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();

        //数组可以通过Stream接口的静态方法of(T...values)生成流
        String[] str = {"HELLO", "WORLD", "JAVA"};
        Stream<String> strStream = Stream.of(str);
        Stream<String> strStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(1, 2, 3);
    }
}

---

Stream流常见中间操作方法

• Stream filter(Predicate predicate):用于流中的数据进行过滤
  • Predicate接口中的方法 boolean test(T t):对给定的参数进行判断，返回一个布尔值

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("张三丰");
        array.add("贾宝玉");
        array.add("林黛玉");
        array.add("杨过");
        array.add("郭靖");
        array.add("张敏");
        array.add("张无忌");

        //把list集合中以张开头的元素在控制台输出
        array.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);

        System.out.println("-----------");
        //把list集合中长度为3的元素在控制台输出
        array.stream().filter(s -> s.length() == 3).forEach(System.out::println);

        System.out.println("-----------");
        //把list集合中以张开头,长度为3的元素在控制太输出

        array.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

---

• Stream limit(long maxSize):返回流中的元素组成的流，截取前指定参数的数据
• Stream skip(long n):跳过指定参数个数的数据，返回由该流剩余元素组成的流

import java.util.ArrayList;
public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("张三丰");
        array.add("贾宝玉");
        array.add("林黛玉");
        array.add("杨过");
        array.add("郭靖");
        array.add("张敏");
        array.add("张无忌");

        //取前3个数据在控制台输出
        array.stream().limit(3).forEach(System.out::println);

        System.out.println("-----------------");
        //跳过3个元素，把剩下的元素在控制台输出
        array.stream().skip(3).forEach(System.out::println);

        System.out.println("-----------------");
        //跳过两个元素，把剩下的元素中前2个在控制台输出
        array.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

---

• static Stream concat(Stream a,Stream b):合并a和b两个流为一个流
• Stream distinct():返回由该流的不同元素(根据Objectequals(Object))组成的流

import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("张三丰");
        array.add("贾宝玉");
        array.add("林黛玉");
        array.add("杨过");
        array.add("郭靖");
        array.add("张敏");
        array.add("张无忌");

        //取前4个数据组成一个流
        Stream<String> s1 = array.stream().limit(4);

        //跳过2个数据组成一个流
        Stream<String> s2 = array.stream().skip(2);

        //合并得到的两个流,并输出结果
//        Stream.concat(s1,s2).forEach(System.out::println);

        
        //合并得到的两个流，并输出结果，要求字符元素不重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

---

• Stream sorted():返回由此流的元素组成的流，根据自然顺序排序
• Streamsorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序

import java.util.ArrayList;

public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> arrry = new ArrayList<String>();

        arrry.add("dd");
        arrry.add("cccc");
        arrry.add("aa");
        arrry.add("bbb");

        //按照字母顺序排序并输出
        arrry.stream().sorted().forEach(System.out::println);

        System.out.println("------------");
        //按照字符串长度把数据输出在控制台 降序
//        arrry.stream().sorted((s1,s2) -> s2.length() - s1.length()).forEach(System.out::println);
        
        //若长度相等按自然顺序排
        arrry.stream().sorted((s1, s2) -> {
            int num = s2.length() - s1.length();
            int num2 = num == 0 ? s1.compareTo(s2) : num;
            return num2;
        }).forEach(System.out::println);
    }
}

---

• Stream map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流
  • Function接口中的方法 R apply(T t)
• IntStream mapToInt(ToIntFunction mapper):返回一个IntStream其中包含将戈丁函数应用于此流的元素的结果
  • IntStream:表示原始int流
  • ToIntFunction接口中的方法 int applyAsInt(T value)

import java.util.ArrayList;
public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //将集合中的字符串数据转换为整数之后在控制台输出
//        list.stream().map(Integer::parseInt).forEach(System.out::println);

//        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

        //int sum()返回此流中元素的总和
        int sum = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
    }
}

Stream流的常见终结操作方法

• void forEach(Consumer action):对此流的元素执行操作
  • Consumer接口中的方法 void accept(T t):对给定的参数执行此操作
• long count():返回此流中的元素数

import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("张三丰");
        array.add("贾宝玉");
        array.add("林黛玉");
        array.add("杨过");
        array.add("郭靖");
        array.add("张敏");
        array.add("张无忌");

        //把集合中的元素在控制台输出
        array.stream().forEach(System.out::println);
        System.out.println("----------------");

        //统计集合中有几个以张开头的元素，并把统计结果在控制台输出
        long c = array.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(c);
    }
}

---

练习:

现有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，需求完成如下操作

• 男演员只要名字为3个字的前三人
• 女演员只要姓张的，并且不要第一个
• 把过滤后的男演员和女演员姓名合并到一起
• 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
  • 演员类Actor，里面有一个成员遍历，一个带参构造方法，以及成员变量对应的get/set方法

import java.util.ArrayList;
import java.util.stream.Stream;

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> Acto = new ArrayList<>();
        ArrayList<String> Actress = new ArrayList<>();

        Acto.add("成龙");
        Acto.add("乔振宇");
        Acto.add("刘德华");
        Acto.add("胡歌");
        Acto.add("周星驰");
        Acto.add("吴孟达");

        Actress.add("景甜");
        Actress.add("张天爱");
        Actress.add("江疏影");
        Actress.add("韩雪");
        Actress.add("张钧甯");
        Actress.add("张萌");

        System.out.println("-----方式一-----");
        //* 男演员只要名字为3个字的前三人
        Stream<String> acto = Acto.stream().filter(s -> s.length() == 3).limit(3);

        //* 女演员只要姓张的，并且不要第一个
        Stream<String> actress = Actress.stream().filter(s -> s.startsWith("张")).skip(1);

        //* 把过滤后的男演员和女演员姓名合并到一起
        Stream<String> actor = Stream.concat(acto, actress);
        actor.map(Actor::new).forEach(p -> System.out.println(p.getName()));

        System.out.println("-----方式二（合并）-----");
        Stream.concat(Acto.stream().filter(s -> s.length() == 3).limit(3),Actress.stream().filter(s -> s.startsWith("张")).skip(1)).map(Actor::new).forEach(p -> System.out.println(p.getName()));
    }
}

Stream流的收集操作

对数据使用流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢

• R collect(Collector collector)
• 但是这个收集方法的参数是一个Collector接口

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

• public static Collector toList():把元素收集到List集合中
• public static Collector toSet():把元素收集到Set集合中
• public static Collector toMap(Function KeyMapper,Function valueMapper):把元素收集到Map集合中

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> Acto = new ArrayList<>();
        Acto.add("成龙");
        Acto.add("乔振宇");
        Acto.add("刘德华");
        Acto.add("胡歌");
        Acto.add("周星驰");
        Acto.add("吴孟达");

        //得到名字为3个字的流
        Stream<String> acto = Acto.stream().filter(s -> s.length() == 3);

        //使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> list = acto.collect(Collectors.toList());
        for (String i : list) {
            System.out.println(i);
        }
        System.out.println("--------------------");

        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(25);
        set.add(30);
        set.add(33);
        set.add(35);

        //得到大于25的流
        Stream<Integer> age = set.stream().filter(s -> s > 25);

        //把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> a = age.collect(Collectors.toSet());
        for (Integer i : a) {
            System.out.println(i);
        }
        System.out.println("---------------------------");

        //定义一个字符串数组，每个字符串由姓名和年龄组合而成
        String[] strArray = {"乔振宇,30", "刘德华,33", "周星驰,25", "吴孟达,35"};

        //得到字符串中年龄数据大于28的流
        Stream<String> stream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);

        //把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
        Map<String, Integer> map = stream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
        Set<String> keys = map.keySet();
        for (String key : keys){
            Integer value = map.get(key);
            System.out.println(key+","+value);
        }
    }
}