java基础之Stream流（生成方式、filter、limit 、skip、concat 和 distinct）

一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第12天，点击查看活动详情。

1.1 Stream流的生成方式

Stream流的常见生成方式
- 1、Collection体系的集合可以使用默认方法stream()生成流：default Stream<E> stream()
- 2、Map体系的集合间接的生成流
- 3、数组可以通过Stream接口的静态方法生成流：of (T... values)

package test;


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

public class Demo {
    public static void main(String[] args) {
        //1、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();

        //2、Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<>();
        Stream<String> keyStream = map.keySet().stream(); //KeySet()方法得到一个Set集合
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //3、数组可以通过Stream接口的静态方法生成流：of (T... values)
        String[] strArray = {"java","python","scala"};
        Stream<String> strArrayStream1 = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("java","python");
        Stream<Integer> integerStream = Stream.of(10, 20, 30);
    }
}

Stream流的使用方法

方法名	说明
list.stream()	生成流：通过数据源(集合，数组等)生成流
filter()	中间操作：一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤映射,然后返回一个新的流,交给下一个操作使用
forEach()	终结操作：一个流只能有一个终结操作，当这个操作执行后，流就被使用“光" 了,无法再被操作。所以这必定是流的最后一个操作

1.2 Stream流中间操作之 filter

Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
Predicate接口中的方法boolean test(T t)：対给定的参数迸行判断，返回一个布尓值
范例

package test;

import java.util.ArrayList;

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

        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");

        //需要1：把list集合中以张开头的在控制台输出
        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：把以张开头，长度为3的在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
//        张无忌
//        张天峰
    }
}

1.3 Stream流中间操作之 limit 和 skip

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

package test;

import java.util.ArrayList;

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

        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：跳过3个元素，把剩下的在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("---------");
//        张天峰
//        小白
//        张飞

        //需求3：跳过2个元素，把剩下元素的前两个输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
//        大熊猫
//        张天峰
    }
}

1.4 Stream流中间操作之 concat 和 distinct

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

package test;

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

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

        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");

        //需要1：取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);

        //需求2：跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);

        //需求3：合并1,2结果得到的流，并输出
//        Stream.concat(s1,s2).forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张天峰
//        大熊猫
//        张天峰
//        小白
//        张飞

        //需求4：合并1,2结果得到的流，并输出，要求结果不重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张天峰
//        小白
//        张飞
    }
}