Stream流使用

生成流

通过集合生成

// list 列表转换为 Stream
List<String> strList = new ArrayList<>();
strList.add("a");
strList.add("b");
Stream stream3 = list.stream();

// Set 集合转换为 Stream
Set<String> strSet = new HashSet<>();
strSet.add("a");
strSet.add("b");
Stream stream4 = strSet.stream();

// Map 集合转换为 Stream
Map<String,Integer> map = new HashMap<>();
map.put("a", 100);
map.put("b", 200);
Stream stream5 = map.entrySet().stream();

通过数组生成

int[] intArr = new int[]{
   1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(intArr);

该方法生成的流是数值流（IntStream）而不是Stream，使用数值流可以避免计算过程中拆箱装箱，提高性能

通过值生成

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

通过Stream的of方法生成流，通过Stream的empty方法可以生成一个空流

通过文件生成

Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());

通过Files.line方法得到一个流，并且得到的每个流是给定文件中的一行

通过函数生成

1. iterate

Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(5);

iterate方法接受两个参数，第一个为初始值，第二个为进行的函数操作，因为iterate生成的流为无限流，通过limit方法对流进行了截断，只生成5个偶数

2. generate

Stream<Double> stream = Stream.generate(Math::random).limit(5);

generate方法接受一个参数，方法参数类型为Supplier，由他为流提供值，generate生成的流也是无限流，因此通过limit对流进行了截断

中间操作

filter条件筛选

返回结果生成新的流中只包含满足筛选条件的数据

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().filter(i -> i > 3);

distinct去除重复元素

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().distinct();

limit返回指定流个数

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5); 
Stream<Integer> stream = integerList.stream().limit(3);

通过limit方法指定返回流的个数，limit的参数值必须>=0，否则将会抛出异常

skip跳过流中的元素

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().skip(2);

通过skip方法跳过流中的元素，skip的参数值必须>=0，否则将会抛出异常

map流映射

流映射就是将接受的元素映射成另外一个元素，通过map方法可以完成映射

List<String> stringList = Arrays.asList("Java 8", "Lambdas",  "In", "Action");
Stream<Integer> stream = stringList.stream().map(String::length);

1. 当出现相同的key时，解决方法：取前面value的值，或者取后面放入的value值，则覆盖先前的value值

Map<Long, String> map = userList.stream()
        .collect(Collectors.toMap(User::getId, User::getUsername, (v1, v2) -> v1));
Map<Long, String> map = userList.stream()
        .collect(Collectors.toMap(User::getId, User::getUsername, (v1, v2) -> v2));

2. 获取treeMap，根据key值进行排序

Map<Long, String> treeMap = new HashMap<>();
TreeMap<Long, String> map = treeMap.entrySet().stream()
.collect(Collectors.toMap(entry -> entry.getKey(), entry -> entry.getValue(), 
                          (v1, v2) -> v1, TreeMap::new));

常用方法

• mapToDouble
• mapToInt
• mapToLong

flatMap流转换

扁平化映射，将多个stream连接成一个stream，这个操作是针对类似多维数组的，比如集合里面包含集合，相当于降维作用
例如：如果想要从List中取出学生列表，需要取出每个班级的学生List，再for循环调用List.addAll()方法把所有班级的学生List到一个新的总和List中

@Data
public class StdCls {
   
    private String clsNo;
    private List<Student> studentList;
}

使用map映射后会变成List<List>，若使用flatMap会进行扁平化处理，从而将List嵌套List用stream合并成一个List

List<String> nameList = stdClsList.stream()
                        .map(StdCls::getStudentList)
                        .flatMap(Collection::stream) // 多个集合List合并
                        .map(Student::getName).collect(Collectors.toList());

sorted排序

将流中的元素按照自然排序方式进行排序。

1. sorted()：自然排序，流中元素需实现Comparable接口

List<String> list = Arrays.asList("aa", "ff", "dd");
//String 类自身已实现Compareable接口
list.stream().sorted().forEach(System