JDK8新特性之 stream流

大家好，这里是教授.F

目录

引入：

将list集合转成set集合：

补充： 

将list集合转成Map集合：

查找最大和最小：

Match用法：

过滤器的用法：

限制元素个数---limit：

实现对数据排序：

遍历：

统计个数---count：

 跳过前部分元素---skip()：

流的转换Map：

对集合进行排序---sorted():

去除重复数据---distinct():

---

引入：

   Java 8中引入的Stream是一种对集合进行操作的新方式，它提供了一种更具表现力和简洁的方式来处理集合数据。Stream可以被看作是对集合进行数据处理的高级工具，它提供了一种类似于流水线的方式来处理集合中的元素，可以进行过滤、映射、排序、聚合等操作。

将list集合转成set集合：

要使用Stream来将List集合转换为Set集合，
你可以使用Stream的distinct()方法来去除重复元素，
然后使用collect()方法将结果收集到一个Set集合中。下面是一个示例代码：

java
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 创建一个List集合
        List<Integer> list = List.of(1, 2, 3, 4, 4, 5, 5, 6);

        // 使用Stream将List转换为Set
        Set<Integer> set = list.stream()
                               .distinct() // 去除重复元素
                               .collect(Collectors.toSet()); 
                               // 收集到Set集合中

        // 打印转换后的Set集合
        System.out.println("转换后的Set集合：" + set);
    }
}

补充： 

        set集合底层依赖于 map集合实现防重复key，map集合底层基于equals比较防重复的结合哈希值的

将list集合转成Map集合：

        补充：list集合只有元素值。key需要指定。我们可以将key指为

要使用Stream将List集合转换为Map集合，你需要指定一个键-值对的生成规则。
通常情况下，可以使用Collectors.toMap()方法来实现这个目的。
在toMap()方法中，你需要提供两个函数：一个用于提取键，另一个用于提取值。
下面是一个示例代码：


import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 创建一个List集合，包含学生的姓名和年龄
        List<Student> students = List.of(
            new Student("Alice", 20),
            new Student("Bob", 22),
            new Student("Charlie", 21)
        );

        // 使用Stream将List转换为Map
        Map<String, Integer> studentMap = students.stream()
                .collect(Collectors.toMap(Student::getName, Student::getAge));

        // 打印转换后的Map集合
        System.out.println("转换后的Map集合：" + studentMap);
    }

    static class Student {
        private String name;
        private int age;

        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }
}

计算求和---reduce()：
        reduce 方法将 Stream 中的元素按照给定的操作进行组合，最终得到一个值。

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个整数的 Stream
        Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);

        // 使用 reduce 方法计算求和
        int sum = numbers.reduce(0, (subtotal, element) -> subtotal + element);

        System.out.println("Stream 中元素的求和为：" + sum);
    }
}

查找最大和最小：

Match用法：

        判断数据是否匹配指定的条件

allMatch(Predicate<? super T> predicate)返回此流的所有元素是否与提供的谓词匹配。

anyMatch(Predicate<? super T> predicate)返回此流的任何元素是否与提供的谓词匹配。

noneMatch(Predicate<? super T> predicate)返回此流的元素是否与提供的谓词匹配。匹配所有元素，所有元素都不满足条件

过滤器的用法：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 创建一个包含字符串的 List
        List<String> words = Arrays.asList("apple", "banana", "cherry", "date");

        // 使用 filter 方法过滤包含字母 'a' 的字符串
        List<String> filteredWords = words.stream()
                                          .filter(word -> word.contains("a"))
                                          .collect(Collectors.toList());

        // 打印过滤后的结果
        System.out.println("包含字母 'a' 的单词有：" + filteredWords);
    }
}

限制元素个数---limit：

        limit 方法接受一个参数，即要限制的元素数量。只有前面指定数量的元素会被保留下来，超过指定数量的元素会被丢弃。

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // 创建一个包含整数的 Stream
        Stream<Integer> numbers = Stream.iterate(0, n -> n + 1);

        // 使用 limit 方法限制 Stream 中元素的数量
        Stream<Integer> limitedStream = numbers.limit(5);

        // 打印限制后的结果
        limitedStream.forEach(System.out::println);
    }
}

实现对数据排序：

遍历：

        forEach()方法可以用来遍历集合中的元素。

        forEach方法接受一个Consumer接口作为参数，该接口表示对流中的每个元素要执行的操作。Consumer接口定义了一个名为accept的抽象方法，该方法接受一个参数并返回void，通常用于执行一些操作而不返回结果。

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 创建一个包含整数的 List 集合
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 使用 forEach 方法遍历 List 集合，并打印每个元素
        numbers.forEach(System.out::println);
    }
}

统计个数---count：

        统计stream中的元素个数。

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个整数的 Stream
        Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);

        // 使用 count 方法统计 Stream 中元素的个数，并打印结果
        long count = numbers.count();
        System.out.println("Stream 中元素的个数为：" + count);
    }
}

 跳过前部分元素---skip()：

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // 创建一个包含整数的 Stream
        Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);

        // 使用 skip 方法跳过前两个元素
        Stream<Integer> skippedStream = numbers.skip(2);

        // 打印跳过后的结果
        skippedStream.forEach(System.out::println);
    }
}

流的转换Map：

        map方法能将一个流中的元素映射到另一个流中。

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // 创建一个包含字符串的 Stream
        Stream<String> stringStream = Stream.of("1", "2", "3", "4", "5");

        // 使用 map 方法将字符串转换为整数类型
        Stream<Integer> integerStream = stringStream.map(Integer::parseInt);

        // 打印转换后的结果
        integerStream.forEach(System.out::println);
    }
}

对集合进行排序---sorted():

Stream<T> sorted();//根据集合中元素来进行自然排序
Stream<T> sorted(Comparator<? super T> comparator);//可以指定排序类型

去除重复数据---distinct():