JAVA8 Stream API使用(拷贝即用)

2023-08-04 23:05:10

JAVA8 Stream

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

什么是 Stream？

Stream（流）是一个来自数据源的元素队列并支持聚合操作

元素：是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。

数据源：流的来源。可以是集合，数组，I/O channel，产生器generator等。

聚合操作：类似SQL语句一样的操作，比如filter, map, reduce, find,match, sorted等。

和以前的Collection操作不同，Stream操作还有两个基础的特征：

Pipelining:：中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格（fluent style）。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。

内部迭代：以前对集合遍历都是通过Iterator或者For-Each的方式,显式的在集合外部进行迭代，这叫做外部迭代。Stream提供了内部迭代的方式，通过访问者模式(Visitor)实现。

具体操作如下:

1:生成流stream

//通过现有的一个集合获取stream
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //获取一个顺序流
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

//使用Arrays 中的 stream() 方法，将数组转成流
Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);


//通过静态方法 of 创造流。stream,of方法返回的是一个有限长度的有顺序的流
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
public class StreamOfObjDemo {
    public static void main(String[] args) {
        Stream<User> userStream = Stream.of(
                new User("Mahesh", 22),
                new User("Krishn", 20),
                new User("Suresh", 25)
        );
        userStream.forEach(u -> System.out.println(u.getUserName()));
    }
}

//通过静态方法iterate()生成一个有序的但是长度是无限长的流，由于是无限长的所以一般结合这个limit()使用
//Stream.iterate(final T seed, final UnaryOperator<T> f)这个方法入参是两个,一个种子值，一个一元函数。这个种子值放入这个一元函数会生产一系列的值得到了一个无线的流数据集合
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
stream2.forEach(System.out::println);// 打印的内容是0、2、4、6、8、10

//可以通过静态方法Stream.generate，无限顺序无序流，其中每个元素由提供的供应商生成。这适用于生成恒定流，随机元素流等。由于是无限长的所以一般结合这个limit()使用
Stream<Double> stream3 = Stream.generate(Math::random).limit(2);
stream3.forEach(System.out::println);


// java8还提供了一些创造基本包装类型流的API
// 要创建IntStream，我们使用IntStream.of方法。
// 要创建LongStream，我们使用LongStream.of方法。
// 为了创建DoubleStream，我们使用DoubleStream.of方法。

IntStream intStream = IntStream.of(12, 14, 16);
intStream.forEach(e -> System.out.println(e));


LongStream longStream = LongStream.of(154L, 236L, 306L);
longStream.forEach(e -> System.out.println(e));


DoubleStream doubleStream = DoubleStream.of(123.56, 456.87, 784.65);
doubleStream.forEach(e -> System.out.println(e));

// 使用 BufferedReader.lines() 方法，将每行内容转成流
// 假设我们读取一个文本文件转为流
BufferedReader reader = new BufferedReader(new FileReader("F:\\\\test_stream.txt"));
Stream<String> lineStream = reader.lines();
lineStream.forEach(System.out::println);
//上面的会把文件里的所有文本信息顺序打印，代码非常简洁

// 使用 Pattern.splitAsStream() 方法，将字符串分隔成流
Pattern pattern = Pattern.compile(",");
Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
stringStream.forEach(System.out::println);

2:迭代

Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。以下代码片段使用forEach 输出了10个随机数：

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

filter：过滤流中的某些元素

limit(n)：获取n个元素

skip(n)：跳过n元素，配合limit(n)可实现分页

distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素

Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);
 
Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14
        .distinct() //6 7 9 8 10 12 14
        .skip(2) //9 8 10 12 14
        .limit(2); //9 8
newStream.forEach(System.out::println);

3:Stream.map API

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

// map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map(i -> i * i).distinct().collect(Collectors.toList());

flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

Stream<String> s3 = list.stream().flatMap(s -> {
    //将每个元素转换成一个stream
    String[] split = s.split(",");
    Stream<String> s2 = Arrays.stream(split);
    return s2;
});
s3.forEach(System.out::println); // a b c 1 2 3

4:Stream.filter API

// filter 方法用于通过设置条件过滤出元素。以下代码片段使用filter 方法过滤出空字符串：
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
int count = (int) strings.stream().filter(string -> string.isEmpty()).count();
// 这个filter方法本质上传入的是一个 Predicate函数，这个函数结果返回是true那个这个元素即是满足条件的，否则将被过滤掉

5:Stream.limit API

limit 方法用于获取指定数量的流。以下代码片段使用 limit 方法打印出 10 条数据：

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

6:Stream.limit API

sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：

Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);

7:并行（parallel）程序

parallelStream 是流并行处理程序的代替方法。以下实例我们使用parallelStream 来输出空字符串的数量：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
// 获取空字符串的数量
int count = (int) strings.parallelStream().filter(string -> string.isEmpty()).count();

8:Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors可用于返回列表或字符串：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);

9:统计summaryStatistics

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

码农公寓