Stream

1.Stream流

1.1 体验Stream

需求：按照下面的要求完成集合的创建和遍历

• 创建一个集合，存储多个字符串元素
• 把集合中所有以“张”开头的元素存储到一个新的集合
• 把“张”开头的集合中的长度为3的元素存储到一个新的集合中
• 遍历上一步得到的集合

使用Stream流的方式完成过滤操作

• list.stream().filter(s->s.startsWith("张")).filters(s-s.length()==3).forEach(System.out::println);
• 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：生产流、过滤姓张、过滤长度为3、逐一打印
• Stream流把真正的函数式编程风格引入到Java中

package com.itheima.Stream;

import java.util.ArrayList;

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("张无忌");
        list.add("柳岩");
        list.add("张敏");
        //把集合中的所有以张开头的元素存储到一个新的集合
        ArrayList<String> list1 = new ArrayList<>();
        for (String str : list) {
            if (str.startsWith("张")) {
                list1.add(str);
            }
        }
        //System.out.println(list1);
        //把集合中的所有以张开头的集合中长度为3的元素存储到一个新的集合
        ArrayList<String> list2 = new ArrayList<>();
        for (String str : list1) {
            if (str.length() == 3) {
                list2.add(str);
            }
        }
        //System.out.println(list2);
        //遍历集合中的所有元素，并输出
        for (String str : list2) {
            System.out.println(str);
        }
        System.out.println("===========================");
        //Stream流改写
        //list.stream().filter(str -> str.startsWith("张")).filter(str -> str.length() == 3).forEach(str -> System.out.println(str));
        list.stream().filter(str -> str.startsWith("张")).filter(str -> str.length() == 3).forEach(System.out::println);
        
    }
}

1.2 Stream流的生成方式

Stream流的使用

• 生产流

  通过数据源(集合，数组等)生成流

  list.stream()

• 中间操作

  一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用

  filter()

• 终结操作

  一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必是流的最后一个操作

  forEach()

Stream流的常见生成方式

• Collection体系的集合可以使用默认方法stream()生成流

  default Streamstream()

• Map体系的集合间接的生成流

• 数组可以通过Stream接口的静态方法of(T...values)生成流

package com.itheima.Stream;

import com.itheima.Thread.SellTicket;

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

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

        Set<String> set=new HashSet<>();
        Stream<String> setStream = set.stream();

        //Map体系的集合间接生成流
        Map<String,Integer> map=new HashMap<>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String,Integer>> entryStream = map.entrySet().stream();
        //数组可以通过Stream接口的静态方法of()生成流
        String[] strs={"a","b","c"};
        Stream<String> strStream = Stream.of(strs);
        Stream<String> stringStream = Stream.of("a", "b", "c");
        Stream<Integer> intStream = Stream.of(1, 2, 3);
        
    }
}

1.3 Stream流的常见中间操作方法

• Streamfilter(Predicate predicate):用于对流中的数据进行过滤

  Predicate接口中的方法 Boolean test(T t):对给定的参数进行判断，返回一个布尔值

package com.itheima.Stream;

import java.util.ArrayList;

public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("张无忌");
        list.add("张三丰");
        list.add("柳岩");
        list.add("张敏");
        //把list集合中以张开头的元素在控制台输出
//        list.stream().filter((String s)->{
//            return s.startsWith("张");
//        }).forEach(System.out::println);
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("===========================");
        //把list集合中长度为3的元素在控制台输出
        list.stream().filter(s->s.length()==3).forEach(System.out::println);
        System.out.println("===========================");
        //把list集合中以张开头的，长度为3的元素在控制台输出
        list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);

    }
}

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

package com.itheima.Stream;

import java.util.ArrayList;

public class StreamDemo04 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("123");
        list.add("456");
        list.add("789");
        //取前3个元素
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("===========================");
        //跳过前2个元素
        list.stream().skip(2).forEach(System.out::println);
        System.out.println("===========================");
        //跳过前2个元素，取剩下的元素中的前2个元素
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

• staticStreamconcat(Stream a,Stream b):合并a和b两个流为一个流
• Streamdistinct():返回由该流的不同元素(根据Object.equals(Object))组成的流

package com.itheima.Stream;

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

public class StreamDemo05 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("张无忌");
        list.add("张三丰");
        list.add("柳岩");
        list.add("王祖贤");
        //取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        //跳过两个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        //将两个流合并成一个流
        //Stream<String> s3 = Stream.concat(s1, s2);
        //将流中的数据依次打印出来
        //s3.forEach(System.out::println);
        //合并两个流，要求元素不能重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);

    }
}

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

package com.itheima.Stream;

import java.util.ArrayList;
import java.util.Comparator;

public class StreamDemo06 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("c++");
        list.add("python");
        //按照字母顺序把数据在控制台输出
        list.stream().sorted().forEach(System.out::println);
        System.out.println("===========================");
        //按照字符串长度把数据在控制台输出
        //list.stream().sorted((s1, s2) -> s1.length() - s2.length()).forEach(System.out::println);
        list.stream().sorted((s1,s2)->{
            int num = s1.length() - s2.length();
            int num2= num==0?s1.compareTo(s2):num;
            return num2;
        }).forEach(System.out::println);
       //list.stream().sorted(Comparator.comparingInt(String::length)).forEach(System.out::println);
    }
}

• Streammap(Function mapper):返回由给定函数应用于此流的元素的结果组成的流

  Function接口中的方法 R apply(T t)

• IntStream map ToInt(ToIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果

  IntStream：表示原始int流

  ToIntFunction接口中的方法 int applyAsInt(T value)

package com.itheima.Stream;

import java.util.ArrayList;

public class StreamDemo07 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");
        //将集合中的字符串转换为整数后在控制台输出
        //list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        System.out.println("===========================");
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        System.out.println("===========================");
        //int sum()返回此流中元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

1.4 Stream流的常见终结操作方法

Stream流的常见终结操作方法

• void forEach(Consumer action):对此流的每个元素执行操作

  Consumer接口中的方法 void accept(T t):对指定的参数执行此操作

• long count()：返回此流中的元素数

package com.itheima.Stream;

import java.util.ArrayList;

public class StreamDemo08 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串数据
        ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("张无忌");
        list.add("张三丰");
        list.add("张敏");
        //把集合中的元素在控制台输出
        list.stream().forEach(System.out::println);
        //统计集合中有几个以“张”开头的元素，并输出
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
    }
}

1.5 Stream流的练习

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

• 男演员只要名字为3个字的前三人

• 女演员只要姓林的，并且不要第一个

• 把过滤后的男演员和女演员姓名组合合并到一起

• 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据

  演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

package com.itheima.Stream;

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

public class StreamDemo09 {
    public static void main(String[] args) {
        //创建男演员集合
        ArrayList<String> manactors = new ArrayList<>();
        manactors.add("周润发");
        manactors.add("张学友");
        manactors.add("张国荣");
        manactors.add("吴京");
        manactors.add("张艺谋");
        manactors.add("周星驰");
        manactors.add("成龙");

        //创建女演员集合
        ArrayList<String> womanactors = new ArrayList<>();
        womanactors.add("林心如");
        womanactors.add("范冰冰");
        womanactors.add("林青霞");
        womanactors.add("杨幂");
        womanactors.add("王祖贤");
        womanactors.add("柳岩");
        womanactors.add("李沁");
        womanactors.add("赵薇");

       /* //男演员只要名字为3个字的前三个
        Stream<String> manStream=manactors.stream().filter(name -> name.length() == 3).limit(3);
        //女演员只要姓林的，并且不要第一个
        Stream<String> womanStream=womanactors.stream().filter(name -> name.startsWith("林")).skip(1);
        //把过滤后的男演员和女演员合并
        Stream<String> stream=Stream.concat(manStream,womanStream);
        //把上一步操作后的结果作为构造方法的参数来创建演员对象，遍历数据
        //stream.map(Actor::new).forEach(System.out::println);
        stream.map(Actor::new).forEach(actor -> System.out.println(actor.getName()));*/
        Stream.concat(manactors.stream().filter(name -> name.length() == 3).limit(3),
                womanactors.stream().filter(name -> name.startsWith("林")).skip(1)).map(Actor::new)
                .forEach(actor -> System.out.println(actor.getName()));
    }
}

1.6 Stream流的收集操作

package com.itheima.Stream;

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

public class StreamDemo10 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串数据
        ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("张无忌");
        list.add("张三丰");
        list.add("张敏");
        //得到名字为3个字的流
        Stream<String> listStream=list.stream().filter(name -> name.length() == 3);
        //把使用Stream流操作完的数据收集到list集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("===========================");
        Set<Integer> set=new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(40);
        //得到年龄大于25的数据
        Stream<Integer> setStream=set.stream().filter(age -> age > 25);
        //把使用Stream流操作完的数据收集到Set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for (Integer age : ages) {
            System.out.println(age);
        }
        System.out.println("===========================");
        String[] strArray={"林青霞,30","张曼玉,20","张无忌,25","张三丰,30","张敏,30"};
        //把字符串数组中年龄大于28的数据转换成流
        Stream<String> arrayStream=Stream.of(strArray).filter(str->Integer.parseInt(str.split(",")[1])>28);
        //把使用Stream流操作完的数据收集到Map集合中并遍历,字符串中的姓名作键，年龄作值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(str -> str.split(",")[0], str -> Integer.parseInt(str.split(",")[1])));
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Integer value = map.get(key);
            System.out.println(key + ":" + value);
        }


    }
}