2020-07-20Stream流

Stream流的生成方式

• stream流的使用

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

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

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

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

        Set<String> set = new HashSet<>();
        set.stream();
        //Map集合间接生成流
        Map<String,Integer> map = new HashMap<String, Integer>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
        //数组可以通过Stream接口的of（V...）
        String[] strArray = {"hello","world","java"};
        Stream<String> strArray1 = Stream.of(strArray);
    }
}

Stream流的常见中间操作方法

①Stream<T> filter(Predicate predicate):对流中的数据进行过滤；Predicate接口中的方法：boolean test(T t):对给定的参数进行判断，返回一个布尔值
②Stream<T> limit(long maxSize):返回此流中的元素组成的流，截取前指定参数个数的数据。
③Stream<T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流
④static<T> Stream<T> concat(Stream a,Stream b):合并a和b两个流为一个流
⑤Stream<T> distinct():返回由该流的不同元素（根据Object.equals(Object)）组成的流
⑥Stream<T> sorted():返回由此流的元素组成的流，按照自然顺序排序
⑦Stream<T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序
⑧<R> Stream<R> map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流
⑨IntStream mapToInt(ToIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果。IntStream接口中有sum方法，计算得到流中数字的和

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

public class streamTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("30");
        list.add("20");
        list.add("10");
        list.add("40");
        list.add("50");
        int sum = list.stream().mapToInt((String s) -> {
            return Integer.parseInt(s);
        }).sum();
        System.out.println(sum);
    }
}

Stream流的常见终结操作方法

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

Stream流的收集操作

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

• Stream流的收集方法
  ①R collect(Collector collector)
  ②但是这个收集方法的参数是一个Collector接口
• 工具类Collectors提供了具体的收集方式
  ①public static<T> Collector toList():把元素收集到list集合中
  ②public static<T> Collector toSet():把元素收集到Set集合中
  ③public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中去

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 StreamTest {
    public static void main(String[] args) {
        List<String> manlist = new ArrayList<String>();
        manlist.add("周润发");
        manlist.add("成龙");
        manlist.add("刘德华");

        //收集到List集合
        List<String> collect = manlist.stream().filter(s -> s.length() == 3).collect(Collectors.toList());
        for (String s:collect) {
            System.out.println(s);
        }
        //收集到Setjihe
        Set<String> collect1 = manlist.stream().filter(s -> s.length() < 3).collect(Collectors.toSet());
        for (String s:collect1) {
            System.out.println(s);
        }
        //收集到Map集合
        String[] str = {"吴京,24","成龙,45","周星驰,55","潘长江,67"};
        Stream<String> stream = Stream.of(str).filter((String s) -> Integer.parseInt(s.split(",")[1]) > 28);
        Map<String, String> map = stream.collect(Collectors.toMap(s -> s.split(",")[0], s -> s.split(",")[1]));
        Set<String> keys= map.keySet();
        for (String s:keys) {
            String value = map.get(s);
            System.out.println(s+","+value);
        }
    }
}

Stream流的练习

现在有两个ArrayList集合，分别存储6名男演员和6名女演员，要求完成如下操作
① 男演员只要名字为三个字的前三人
②女演员只要姓林的，并且不要第一个
③把过滤后的男演员姓名和女演员姓名合并到一起
④把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据

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

public class StreamTest {
    public static void main(String[] args) {
        List<String> manlist = new ArrayList<String>();
        manlist.add("周润发");
        manlist.add("成龙");
        manlist.add("刘德华");
        manlist.add("吴京");
        manlist.add("周星驰");
        manlist.add("李连杰");
        List<String> womenlist = new ArrayList<String>();
        womenlist.add("林心如");
        womenlist.add("张曼玉");
        womenlist.add("林青霞");
        womenlist.add("刘岩");
        womenlist.add("林志玲");
        womenlist.add("王祖贤");
        //男演员只要名字为三个字的前三人
        manlist.stream().filter((s)->s.length()==3).limit(3).forEach(s -> System.out.println(s));
        System.out.println("-------------------");
        //女演员只要姓林的，并且不要第一个
        womenlist.stream().filter(s -> s.startsWith("林")).skip(1).forEach(s -> System.out.println(s));
        System.out.println("--------------------");
        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream1 = manlist.stream().filter((s) -> s.length() == 3).limit(3);
        Stream<String> stream2 = womenlist.stream().filter(s -> s.startsWith("林")).skip(1);
        //把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
        Stream s  = Stream.concat(stream1,stream2);
        s.map((ss)-> new Actor((String) ss)).forEach(System.out::println);
    }
}


package test02;

public class Actor {
    //成员变量
    String name;
    //构造方法
    public Actor(String name) {
        this.name = name;
    }

    //成员方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Actor{" +
                "name='" + name + '\'' +
                '}';
    }
}