简单例子

创建一个有多个字符串元素的集合，把“张”开头长度为3的元素存储到新集合并遍历输出
Stream流方式完成过滤操作

• list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println)
• 阅读代码字面意思：生产流、过滤姓张、过滤长度为3、逐一打印
• Steam流把真正的函数式编程风格引入到Java中

Stream流的生成方式

生成流

• list.stream()通过数据源(集合，数组等)生成流

Stream流的常见生成方式

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

List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();
        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

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

HashMap<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(T...values)生成流

String[] strArray={"hello","world","java"};
Stream<String> strArrayStream = Stream.of(strArray);
Stream<String> strArrayStream2 = Stream.of("hello","world","java");
Stream<Integer> intStream = Stream.of(10, 20, 30);

Stream流常见的中间操作方法

• Stream<T> filter(Predicate predicate):用于对流中的数据进行过滤
  依赖于predicate接口中boolean test(T t)//对参数判断返回布尔值方法对流进行过滤

//把list中以张开头，长度为3的元素在cmd输出
`list.stream().filter(s->s.startsWith("张")).
filter(s->s.length()==3).forEach(System.out::println)`

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

//创建一个集合，存储多个字符串元素
ArrayList<String> list=new ArrayList<>();
list.add("Tom");list.add("Jack");list.add("Mary");
list.add("Jerry");list.add("Tomas");list.add("Ali");
//取前3个数据在控制台输出
list.stream().limit(3).forEach(System.out::println);
//跳过3个元素，把剩下元素在控制台输出
list.stream().skip(3).forEach(System.out::println);
//跳过2个元素，把剩下元素的前2个在控制台输出
list.stream().skip(2).limit(2).forEach(System.out::println);

• static <T> Stream<T> concat(Stream a,Stream b)合并a和b两个流为一个流
• Stream<T> distinct()返回由该流的不同元素(依据Object.equals(Object))组成的流

//创建一个集合，存储多个字符串元素
ArrayList<String> list=new ArrayList<>();
list.add("Tom");list.add("Jack");list.add("Mary");
list.add("Jerry");list.add("Tomas");list.add("Ali");
//取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
//跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//合并1，2得到的流，并把结果在cmd输出
Stream.concat(s1,s2).forEach(System.out::println);
//合并1，2得到的流，结果cmd输出，且字符串不能重复
Stream.concat(s1,s2).distinct().forEach(System.out::println);

• Stream<T> sorted()返回由此流的元素组成的流，依据自然顺序排序
• Stream<T> sorted(Comparator comparator)
  返回由此流的元素组成的流，依据提供的Comparator进行排序

public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list=new ArrayList<>();
        list.add("Tom");list.add("Jack");list.add("Mary");
        list.add("Jerry");list.add("Tomas");list.add("Ali");
        //按照字母顺序把数据在cmd输出
        list.stream().sorted().forEach(System.out::println);
        //按照字符串长度把数据在cmd输出
        list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);
        //字符串长度为第一标准，字母顺序为第二标准在cmd输出
        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);
    }
}

• <R> Stream <R> map(Function mapper) Funtion接口中对应方法R apply(T t)
  返回由给定函数应用于此流的元素的结果组成的流
• IntStream mapToInt(ToIntFunction mapper)ToIntFuntion接口的方法int applyAsInt(T value)
  返回一个IntStream其中包含将给定函数应用于此流的元素的结果

public class StreamDemo04 {
    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");
        //将集合中的字符串数据转换为整数之后在cmd输出
        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        //int sum()返回此流中元素综合，因为是IntStream所以可以调用
        int result=list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

Stream流的常见终结操作方法

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

public class StreamDemo5 {
    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");
        //把集合的元素在cmd输出
        list.stream().forEach(System.out::println);
        //统计集合中由几个1开通的元素，并把统计结果输出在cmd
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
    }
}

Stream流综合练习

public class Actor {
    private String name;
    public Actor(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

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

Stream流的收集操作

对数据使用Stream流的方式操作完后，为了把流中数据收集到集合中
Stream流的收集方法

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

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

• public static <T> Collector toList()把元素收集到List集合中
• public static <T> Collector toSet()把元素收集到Set集合中
  -- public static <T> Collector toMap(Function keyMapper,Function valueMapper)
  把元素收集到Map集合中

public class CollectDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list=new ArrayList<>();
        list.add("林青霞");list.add("张曼玉");
        list.add("王祖贤");list.add("柳岩");
        //得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
        //把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> names=listStream.collect(Collectors.toList());
        for(String name:names){
            System.out.println(names);
        }

        //创建Set集合对象
        Set<Integer> set=new HashSet<>();
        set.add(10);set.add(20);set.add(30);
        set.add(33);set.add(35);
        //得到年龄大于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);
        }
        
        //定义一个字符串数组，每个字符串数据由姓名和年龄组合而成
        String[] strArray={"林青霞,30","张曼玉,35","王祖贤,38","柳岩,29"};
        //得到字符串中年龄大于28的流
        Stream<String> arrayStream = Stream.of(strArray).
                filter(s -> Integer.parseInt(s.split(",")[1]) > 28);
        //把使用Stream流操作完毕的数据收集到Map集合中并遍历,字符串中姓名作键，年龄作值
        Map<String,Integer> map=arrayStream.collect(Collectors.toMap
                (s -> s.split(",")[0], s ->Integer.parseInt(s.split(",")[1])));
        Set<String> keySet=map.keySet();
        for(String key:keySet){
            Integer value=map.get(key);
            System.out.println(key+","+value);
        }
    }
}