Stream流的常见中间操作方法

Stream<T> fifter(Predicate predicate):用于对流中的数据进行过滤

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

package com.aynu24;

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

import java.util.ArrayList;

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

        //创建一个集合，存储多个字符串元素
        ArrayList<String> list=new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");


        //需求1：把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("--------");

        //需求2：把list集合中长度为3的元素在控制台输出

        list.stream().filter(s -> s.length()==3).forEach(System.out::println);
        System.out.println("--------");

        //需求3：把list集合中以张开头，长度为3的元素在控制台输出

        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):跳过指定参数个数的数据，返回由该流的剩余元素组成的流

package com.aynu24;

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

import java.util.ArrayList;

public class StreamDemo3 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list=new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前三个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");
        //需求2：跳过前三个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");
        //需求3：跳过两个元素，把剩下元素中的前两个元素在控制台中输出
        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)）组成的流

package com.aynu24;

//static <T> Stream <T> concat(Stream a,Stream b):合并a和b两个流为一个流

//Stream<T> distinct():返回由该流的不同元素 （根据Object.equals(Object)）组成的流


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

public class StreamDemo3 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list=new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前四个数据在控制台输出
        Stream<String> s1 = list.stream().limit(4);
        //需求2：跳过前二个元素，把剩下的元素在控制台输出
        Stream<String> s2 = list.stream().skip(2);
        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出
//        Stream.concat(s1,s2).forEach(System.out::println);
        System.out.println("--------");
        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出：要求字符串不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);

    }
}

 Stream<T>sorted():返回由此流的元素组成的流，根据自然顺序排序

Stream<T>sorced(Comparator comparator）:返回由该流的元素组成的流，根据提供的Comparator进行排序

package com.aynu24;

//        Stream<T>sorted():返回由此流的元素组成的流，根据自然顺序排序
//
//        Stream<T>sorced(Comparator comparator）:返回由该流的元素组成的流，根据提供的Comparator进行排序

import java.util.ArrayList;

public class StreamDemo4 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("linqingxia");
        list.add("zhangmanyu");
        list.add("wangzuxian");
        list.add("liuyan");
        list.add("zhangmin");
        list.add("zhangwuji");

        //需求1：按照字母顺序把数据在控制台输出
        list.stream().sorted().forEach(System.out::println);
        System.out.println("--------");

        //需求2：按照字符串长度把数据在控制台输出

//        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);
    }
}

linqingxia
liuyan
wangzuxian
zhangmanyu
zhangmin
zhangwuji
--------
liuyan
zhangmin
zhangwuji
linqingxia
wangzuxian
zhangmanyu

<R> Stream<R> map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流

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

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

        IntStream：表示原始int流

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

package com.aynu24;

import java.util.ArrayList;

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

public class StreamDemo5 {
    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(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() 返回此流中元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);

    }
}

10
20
30
40
50

--------
150