获取流方式

根据Collection获取流

• Collection接口中有一个stream()方法,可以获取流 , default Stream<E> stream():获取一个Stream流

  1. 通过List集合获取:

  2. 通过Set集合获取

        // 方式一:　根据Collection获取流
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张杰");
        list.add("张三丰");
        // 根据List集合获取流
        Stream<String> stream1 = list.stream();

        HashSet<String> set = new HashSet<>();
        set.add("张无忌");
        set.add("周芷若");
        set.add("赵敏");
        set.add("张杰");
        set.add("张三丰");
        // 根据Set集合获取流
        Stream<String> stream2 = set.stream();

根据Map获取流

• 使用所有键的集合来获取流

• 使用所有值的集合来获取流

• 使用所有键值对的集合来获取流

        // 方式二:　根据Map获取流
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "张无忌");
        map.put(2, "周芷若");
        map.put(3, "赵敏");
        map.put(4, "张杰");
        map.put(5, "张三丰");

        //  根据Map集合的键
        Stream<Integer> stream3 = map.keySet().stream();

        //  根据Map集合的值
        Stream<String> stream4 = map.values().stream();

        //  根据Map集合的键值对对象
        Stream<Map.Entry<Integer, String>> stream5 = map.entrySet().stream();

根据数组获取流

• Stream流中有一个static <T> Stream<T> of(T... values)

  • 通过数组获取:

  • 通过直接给多个数据的方式

        // 方式三: 根据数组来获取流
        String[] arr = {"张无忌",
                "周芷若",
                "赵敏",
                "张杰",
                "张三丰"};
        Stream<String> stream6 = Stream.of(arr);

        // 根据直接传入元素的方式
        Stream<String> stream7 = Stream.of("张无忌",
                "周芷若",
                "赵敏",
                "张杰",
                "张三丰");

Stream流常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

• 终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。本小节中，终结方法包括count和forEach方法。

• 非终结方法\延迟方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为非终结方法。）

函数拼接与终结方法

在上述介绍的各种方法中，凡是返回值仍然为Stream接口的为函数拼接方法，它们支持链式调用；而返回值不再为Stream接口的为终结方法，不再支持链式调用。如下表所示：

方法名	方法作用	方法种类	是否支持链式调用
count	统计个数	终结	否
forEach	逐一处理	终结	否
filter	过滤	函数拼接	是
limit	取用前几个	函数拼接	是
skip	跳过前几个	函数拼接	是
map	映射	函数拼接	是
concat	组合	函数拼接	是

forEach : 逐一处理

虽然方法名字叫forEach，但是与for循环中的“for-each”昵称不同，该方法并不保证元素的逐一消费动作在流中是被有序执行的。

void forEach(Consumer<? super T> action);

该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。例如：

public class Test1forEach {
    public static void main(String[] args) {
        /*
            Stream流:
                void forEach(Consumer<? super T> action); 对此流的每个元素执行操作   终结方法
                参数Consumer<T>类型: 是一个函数式接口,该接口中的抽象方法为:void accept(T t);　　　消费接口
         */
        // 根据Collection获取流
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张杰");
        list.add("张三丰");
        // 根据List集合获取流
        Stream<String> stream1 = list.stream();
        // 使用stream1调用forEach方法
        stream1.forEach((String name)->{
            System.out.println(name);// 打印
        });

        System.out.println("==================");
        // 省略格式:
        list.stream().forEach(name->System.out.println(name));

        System.out.println("==================");
        //stream1.forEach(name->System.out.println(name));// 报错 Stream流只能使用一次，不能重复使用
    }
}

count：统计个数

正如旧集合Collection当中的size方法一样，流提供count方法来数一数其中的元素个数：

long count();

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：

public class Test2count {
    public static void main(String[] args) {
        /*
            Stream流:
                long count();统计流中元素的个数
         */
        Stream<String> stream1 = Stream.of("张无忌", "周芷若", "赵敏", "张杰", "张三丰");
        long count = stream1.count();
        System.out.println("统计元素个数:"+count);// 5

    }
}

filter：过滤

可以通过filter方法将一个流转换成另一个子集流。方法声明：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个Predicate函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

基本使用

Stream流中的filter方法基本使用的代码如：

public class Test3filter {
    public static void main(String[] args) {
        /*
            Stream<T>流:
                Stream<T> filter(Predicate<? super T> predicate); 将一个流转换成另一个子集流
                参数Predicate<T>类型:是一个函数式接口,包含的抽象方法为:  boolean test(T t);   判断\比较接口
         */
        Stream<String> stream1 = Stream.of("张无忌", "周芷若", "赵敏", "张杰", "张三丰");
        stream1.filter((String name)->{
            System.out.println("filter方法");
            return name.startsWith("张");
        }).forEach(name->System.out.println(name));
    }
}

在这里通过Lambda表达式来指定了筛选的条件：必须姓张。

limit：取用前几个

limit方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：

public class Test4limit {
    public static void main(String[] args) {
        /*
            Stream流:
                Stream<T> limit(long maxSize); 对流进行截取，只取用前n个
                注意: 如果流的元素个数大于参数则进行截取；否则不进行操作
         */
        Stream<String> stream1 = Stream.of("张无忌", "周芷若", "赵敏", "张杰", "张三丰");
        // 取用前3个
        stream1.limit(3).forEach(name-> System.out.println( name));

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

        Stream<String> stream2 = Stream.of("张无忌", "周芷若", "赵敏", "张杰", "张三丰");
        stream2.limit(13).forEach(name-> System.out.println( name));
    }
}

skip：跳过前几个

如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：

public class Test5skip {
    public static void main(String[] args) {
        /*
            Stream流:
                Stream<T> skip(long n); 跳过前几个元素
                 注意: 如果流的元素个数大于参数则进行跳过；否则,最后流中的元素个数为0
         */
        Stream<String> stream1 = Stream.of("张无忌", "周芷若", "赵敏", "张杰", "张三丰");
        // 跳过前2个
        stream1.skip(2).forEach(name-> System.out.println(name));

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

        Stream<String> stream2 = Stream.of("张无忌", "周芷若", "赵敏", "张杰", "张三丰");
        // 跳过前12个
        stream2.skip(12).forEach(name-> System.out.println(name));
    }
}

map：映射

如果需要将流中的元素映射到另一个流中，可以使用map方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

基本使用

Stream流中的map方法基本使用的代码如：

public class Test6map {
    public static void main(String[] args) {
        // 案例1: 流中的Sring类型元素 转换为 String类型元素的流
        Stream<String> stream1 = Stream.of("jack", "rose");
        stream1.map((String str)->{return str+"98";}).forEach(name-> System.out.println(name));

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

        // 案例2: 流中的Sring类型元素 转换为 Integer类型元素的流
        Stream<String> stream2 = Stream.of("18", "19");
        stream2.map((String str)->{return Integer.valueOf(str);}).forEach(i-> System.out.println(i+1));

    }
}

concat：组合

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

备注：这是一个静态方法，与java.lang.String当中的concat方法是不同的。

该方法的基本使用代码如：

public class Test7concat {
    public static void main(String[] args) {
        /*
            Stream流:
                static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b);合并2个流中的元素
         */
        Stream<String> stream1 = Stream.of("jack", "rose");
        Stream<String> stream2 = Stream.of("18", "19");
        // 合并
        Stream.concat(stream1,stream2).forEach(str-> System.out.println(str));
    }
}