Java Stream流的相关操作

Stream流的生成

生成Stream流的方式

• Collection体系集合

  使用默认方法stream()生成流， default Stream stream()

• Map体系集合

  把Map转成Set集合，间接的生成流

• 数组

  通过Arrays中的静态方法stream生成流

• 同种数据类型的多个数据

  通过Stream接口的静态方法of(T… values)生成流

示例代码

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

public class StreamDemo1 {
    public static void main(String[] args) {
        //单列集合使用Stream流
        //List集合使用Stream流
        List<String> list = new ArrayList<>();

        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");

        //第一种形式
        //用Stream类型的变量去调用forEach()方法
        Stream<String> stream = list.stream();
        stream.forEach(s -> System.out.println(s));

        //第二种形式
        //直接让集合对象去调用stream()和forEach()方法
        list.stream().forEach(s -> System.out.println(s));
        //Set集合使用Stream生成流
        Set<String> set = new HashSet<>();

        set.add("tanqun");
        set.add("zuozhongtang");
        set.add("lihongzhang");

        set.stream().forEach(s -> System.out.println(s));

        System.out.println("============================");
        //双列集合使用Stream生成流
        Map<String,String> map = new HashMap<>();

        map.put("qiumin","38");
        map.put("huangjing","40");
        map.put("zuozhongzhi","42");

        map.keySet().stream().forEach(s -> System.out.println(s));
        map.values().stream().forEach(s -> System.out.println(s));
        map.entrySet().stream().forEach(s -> System.out.println(s));

        System.out.println("============================");
        //数组使用Stream生成流
        int[] array = {11,22,33,44,55,66};
        Arrays.stream(array).forEach(s -> System.out.println(s));

        String[] array2 = {"1","2","3"};
        Stream<String> stream1 = Arrays.stream(array2);
        stream1.forEach(s -> System.out.println(s));

        System.out.println("============================");
        //同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流
        Stream.of(1,2,3,4,5,6,7).forEach(s -> System.out.print(s));
        System.out.println();
        Stream.of("1","2","3","4","5").forEach(s -> System.out.print(s));

    }
}

Stream流中间操作方法

方法名	说明
Stream <T> filter(Predicate predicate)	用于对流中的数据进行过滤
Stream <T> limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream <T> skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static <T> Stream concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream <T> distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流

示例代码

1. Stream filter(Predicate predicate)用于对流中的数据进行过滤

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class StreamDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

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

        //fileter(Predicate predicate) 过滤流对流中的数据进行过滤
        //第一种使用形式，通过匿名内部类作为参数传入filter()方法
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                boolean result = s.startsWith("张");
                return result;
            }
        }).forEach(s -> System.out.println(s));

        //第二种使用形式，通过lambda表达式实现
        list.stream().filter(
                (String s) -> {
                    boolean result = s.startsWith("张");
                    return result;
                }
        ).forEach(s -> System.out.println(s));

        //第三种使用形式，简化lambda表达式
        list.stream().filter(
                s -> s.startsWith("张")
        ).forEach(s -> System.out.println(s));
    }
}

2. Stream limit(long maxSize)返回此流中的元素组成的流，截取前指定参数个数的数据
3. Stream skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的流
4. static Stream concat(Stream a, Stream b)合并a和b两个流为一个流
5. Stream distinct()返回由该流的不同元素（根据Object.equals(Object) ）组成的流

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

public class StreamDemo3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
//        Stream<T> limit(long maxSize)返回此流中的元素组成的流，截取前指定参数个数的数据
        list.stream().limit(3).forEach(s -> System.out.println(s));

        System.out.println("============================");

//        Stream<T> skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的流
        list.stream().skip(2).forEach(s -> System.out.println(s));

        System.out.println("============================");
//        static <T> Stream<T> concat(Stream a, Stream b)合并a和b两个流为一个流
        List<String> list2 = new ArrayList<>();

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

        Stream stream1 = list.stream();
        Stream stream2 = list2.stream();
        Stream.concat(stream1,stream2).forEach(s -> System.out.println(s));

        //简化格式
        System.out.println("------------------------------------------");
        Stream.concat(list.stream(),list2.stream()).forEach(s -> System.out.println(s));

        System.out.println("============================");
//        Stream<T> distinct()返回由该流的不同元素（根据Object.equals(Object) ）组成的流
        List<String> list3 = new ArrayList<>();

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

        list3.stream().distinct().forEach(s -> System.out.println(s));
    }
}

Stream流终结操作方法

执行终结操作的相关方法后,Stream流将不能再执行其他操作

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素数

实例代码

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

/**
 * Stream流终结操作方法
 *void forEach(Consumer action)对此流的每个元素执行操作
 * long count()返回此流中的元素数
 */

public class StreamDemo4 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
//         void forEach(Consumer action)对此流的每个元素执行操作
        //第一种形式，匿名内部类
        list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );

        System.out.println("=======================");
        //第二种形式，lambda表达式
        list.stream().forEach(
                (String s) -> {
                    System.out.println(s);
                }
        );

        System.out.println("=======================");
        //第三种形式，lambda表达式简写
        list.stream().forEach(s -> System.out.println(s));

        System.out.println("=======================");

//         long count()返回此流中的元素数量
        long n = list.stream().count();
        System.out.println("流中的元素数量为：" + n);
    }
}

Stream流的收集操作

• 在对集合使用流进行操作后，集合原本的数据并不会被修改，若想保存流中的操作到集合中，需要对流进行中间操作后进行最后的收集操作

方法名	说明
R collect(Collector collector)	把结果收集到集合中

其中collect()的参数为Collector类中的静态方法

类Collectors中提供了生成List，Set,Map三种容器的方法
collect()方法仅仅是收集流，而存储流操作的容器依赖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.*;
import java.util.stream.Collectors;

/**
 *  需求：过滤元素并遍历集合
 *  定义一个集合，并添加一些整数1,2,3,4,5,6,7,8,9,10
 *  将集合中的奇数删除，只保留整数
 *  遍历集合得到2,4,6,8,10
 *
 *  对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中
 *
 * public static <T> Collector toList()把元素收集到List集合中
 *  public static <T> Collector toSet()把元素收集到Set集合中
 *  public static  Collector toMap(Function keyMapper,Function valueMapper)把元素收集到Map集合中
 */

public class StreamDemo6 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }

        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        //完成对流的过滤，保留偶数,并且使用collect()方法将流中的数据收集，
        // 并用Collectors.toList()创建集合
        //public static <T> Collector toList()把元素收集到List集合中
        List<Integer> list1 = list.stream().filter(
                (Integer integer) -> {
                    return integer % 2 ==0;
                }
        ).collect(Collectors.toList());
        //简化版
        List<Integer> list2 = list.stream().filter(integer -> integer % 2 == 0).collect(Collectors.toList());

        //打印集合中的内容
        System.out.println(list1);
        System.out.println(list2);

        System.out.println("==========================");

        //public static <T> Collector toSet()把元素收集到Set集合中
        Set<Integer> set1 = list.stream().filter(
                (Integer integer) -> {
                    return integer % 2 == 0;
                }
        ).collect(Collectors.toSet());

        //简化版
        Set<Integer> set2 = list.stream().filter(integer -> integer % 2 == 0).collect(Collectors.toSet());

        //输出Set集合中的内容
        System.out.println(set1);
        System.out.println(set2);

        //输出结果显示出了Set集合元素不可重复的特点

        System.out.println("==========================");

        //public static  Collector toMap(Function keyMapper,Function valueMapper)把元素收集到Map集合中
        List<String> list3 = new ArrayList<>();

        list3.add("唐三,18");
        list3.add("小舞,17");
        list3.add("唐昊,48");

        Map<String,String> map = list3.stream().filter(
                //(String s) -> {}  表示s去遍历流中的每一个数据，并在后面的{}中进行处理
                (String s) -> {
                    String[] array = s.split(",");
                    int i = Integer.parseInt(array[1]);
                    return i<=18;
                }
                //此处要将toMap()方法的参数列表写清楚
        ).collect(Collectors.toMap(
                s -> {
                    return s.split(",")[0];
                },
                s -> {
                    return s.split(",")[1];
                }
        ));
        //输出Map
        System.out.println(map);

    }
}

Stream流的整合操作

• Stream stream = Stream.concat(Stream1,Stream2);

实例代码

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

/**
 * 案例需求
 *
 * 现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
 *
 * - 男演员只要名字为3个字的前三人
 * - 女演员只要姓林的，并且不要第一个
 * - 把过滤后的男演员姓名和女演员姓名合并到一起
 * - 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
 *
 * 演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法
 */

public class StreamDemo7 {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        list1.add("周润发");
        list1.add("成龙");
        list1.add("刘德华");
        list1.add("吴京");
        list1.add("周星驰");
        list1.add("李连杰");

        list2.add("林心如");
        list2.add("张曼玉");
        list2.add("林青霞");
        list2.add("柳岩");
        list2.add("林志玲");
        list2.add("王祖贤");

        Stream<String> manStream = list1.stream().filter(
                (String s) -> {
                    return s.length() == 3;
                }
        ).limit(3);

        Stream<String> womanStream = list2.stream().filter(
                (String s) -> {
                    return s.startsWith("林");
                }
        ).skip(1);

        //将两个流合并到一个流stream中
        Stream<String> stream = Stream.concat(manStream,womanStream);
        //用lambda表达式去遍历stream流中的所有元素并使用
        stream.forEach(
                (String name) -> {
                    Actor actor = new Actor(name);
                    System.out.println(actor);
                });
    }

}