stream笔记

获取流的几种方式：
1、所有的Collection集合都可以通过stream默认方法获取流。
2、stream接口的静态方法of（）可以获取数组对应的流。
练习代码如下：

package Demo01;

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

public class Demo01GetStream {
    public static void main(String[] args) {
        //把集合转化为stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> steam2 = set.stream();
        
        //获取键，存储到一个set集合中，转换为stream流
        Map<String,String> map = new HashMap<>();
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();
        
        //获取值，存储到Collection集合中，转换为流。
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        //获取键值对/键的映射关系 entrySet（）
        Set<Map.Entry<String,String>> entries = map.entrySet();
        Stream<Map.Entry<String,String>> stream5 = entries.stream();
        
        //把数组转换为stream流
        Stream<Integer> stream6 = Stream.of(1,2,3,4,5);
        
        //把可变数组转换为stream流
        int[]arr = {'1','2','3','4'};
        Stream<int[]> stream7 = Stream.of(arr);
    }
}

stream流中的常用方法：
延迟方法：返回值类型任然是Stream接口自身类型的方法，因此支持链式调用。（除了终结方法之外，其他方法均为延迟方法）
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持StringBuilder那样的链式调用，终结方法包括count和forEach。

forEach：用来遍历流中的数据，是一个终结方法，遍历之后不能继续调用Stream流中的其他方法。

filter：通过filter方法讲一个流转换为一个子集流。
方法签名：Stream<T> filter(Predicate<? super T> predicate);

Stream流的特点：Stream属于管道流，只能消费一次（使用一次）。第一个Stream使用完毕方法，数据就会流转到下一个Stream上，所以第一个Stream流就不能使用方法了。抛出如下异常
map方法：如果需要将流中的元素映射到另一个流中，可以使用map方法。
练习：

package Demo01;

import java.util.stream.Stream;

public class Demo05StreamMap {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1","2","3","4");
        Stream<Integer> stream1 = stream.map((str) -> {
            return Integer.parseInt(str);
        });
        stream1.forEach(i-> System.out.println(i));
    }
}

count：统计个数。终结方法，返回值类型long。
练习：

package Demo01;

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

public class Demo06StreamCount {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

limit:对流进行截取，只取用前n个。
练习：

package Demo01;

import java.util.stream.Stream;

public class Demo07StreamLimit {
    public static void main(String[] args) {
        String[] arr = {"无双剑姬","疾风剑豪","无极剑圣","暗裔剑魔"};
        Stream<String> stream = Stream.of(arr);
        Stream<String> stream1 = stream.limit(3);
        stream1.forEach(name-> System.out.println(name));
    }
}

skip：跳过前面几个元素，得到一个截取之后的流。
练习：

package Demo01;

import java.util.stream.Stream;

public class Demo08StreamSkip {
    public static void main(String[] args) {
        String[] arr = {"无双剑姬","疾风剑豪","无极剑圣","暗裔剑魔"};
        Stream<String> stream = Stream.of(arr);
        Stream<String> stream1 = stream.skip(3);
        stream1.forEach(name-> System.out.println(name));
    }
}

concat:如果有两个流，希望合并成为一个流，可以使用concat。
练习：

package Demo01;

import java.util.stream.Stream;

public class Demo09StreamConcat {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三丰", "张翠山", "周伯通", "张无忌");
        String[] arr = {"无双剑姬","疾风剑豪","无极剑圣","暗裔剑魔"};
        Stream<String> stream1 = Stream.of(arr);
        Stream<String> concat = Stream.concat(stream, stream1);
        concat.forEach(name-> System.out.println(name));
    }
}