Java8新特性之Stream流的使用

最新推荐文章于 2024-04-17 04:46:20 发布
最新推荐文章于 2024-04-17 04:46:20 发布
阅读量891 收藏 1
点赞数
分类专栏： JAVA 文章标签： stream java
原文链接：https://www.cnblogs.com/wuhenzhidu/p/10740091.html
版权

Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作，在新版的JPA中，也已经加入了Stream。

1、Stream的操作步骤

Stream有如下三个操作步骤：

一、创建Stream

从一个数据源，如集合、数组、值、文件中获取流。

//集合
//这种数据源较为常用，通过stream()方法即可获取流对象：
List<Person> list = new ArrayList<Person>(); 
Stream<Person> stream = list.stream();

//数组
//通过Arrays类提供的静态函数stream()获取数组的流对象：
String[] names = {"chaimm","peter","john"};
Stream<String> stream = Arrays.stream(names);

//值
//直接将几个值变成流对象：
Stream<String> stream = Stream.of("chaimm","peter","john");

//文件
try(Stream lines = Files.lines(Paths.get(“文件路径名”),Charset.defaultCharset())){
//可对lines做一些操作
}catch(IOException e){
}

二、中间操作

一个操作的中间链，对数据源的数据进行操作。

三、终止操作

一个终止操作，执行中间操作链，并产生结果。

要注意的是，对流的操作完成后需要进行关闭操作（或者用JAVA7的try-with-resources，Java7简化了IO操作，把打开IO操作放在try后的括号中即可省略关闭IO的代码）。

举个例子：

有一个Person类和一个Person对象集合，需求：1）找到年龄大于18岁的人并输出；2）找出所有中国人的数量。

@Data
class Person {
    private String name;
    private Integer age;
    private String country;
    private char sex;

    public Person(String name, Integer age, String country, char sex) {
        this.name = name;
        this.age = age;
        this.country = country;
        this.sex = sex;
    }
}
List<Person> personList = new ArrayList<>();
personList.add(new Person("欧阳雪",18,"中国",'F'));
personList.add(new Person("Tom",24,"美国",'M'));
personList.add(new Person("Harley",22,"英国",'F'));
personList.add(new Person("向天笑",20,"中国",'M'));
personList.add(new Person("李康",22,"中国",'M'));
personList.add(new Person("小梅",20,"中国",'F'));
personList.add(new Person("何雪",21,"中国",'F'));
personList.add(new Person("李康",22,"中国",'M'));

在JDK8以前，我们可以通过遍历列表来完成。但是在有了Stream API后，可以这样来实现：

public static void main(String[] args) {

    // 1）找到年龄大于18岁的人并输出；
    personList.stream().filter((p) -> p.getAge() > 18).forEach(System.out::println);

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

    // 2）找出所有中国人的数量
    long chinaPersonNum = personList.stream().filter((p) -> p.getCountry().equals("中国")).count();
    System.out.println("中国人有：" + chinaPersonNum + "个");
}

输出结果： 

Person(name=Tom, age=24, country=美国, sex=M)
Person(name=Harley, age=22, country=英国, sex=F)
Person(name=向天笑, age=20, country=中国, sex=M)
Person(name=李康, age=22, country=中国, sex=M)
Person(name=小梅, age=20, country=中国, sex=F)
Person(name=何雪, age=21, country=中国, sex=F)
Person(name=李康, age=22, country=中国, sex=M)
-------------------------------------------
中国人有：6

personList.stream()是创建流，filter()属于中间操作，forEach、count()是终止操作。 

2、Stream中间操作--筛选与切片

  • filter：接收Lambda，从流中排除某些操作；
  • limit：截断流，使其元素不超过给定对象
  • skip(n)：跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补
  • distinct：筛选，通过流所生成元素的hashCode()和equals()去除重复元素。

2.1 limit举例

从Person列表中取出两个女性。

personList.stream().filter((p) -> p.getSex() == 'F').limit(2).forEach(System.out::println);

输出结果：

Person(name=欧阳雪, age=18, country=中国, sex=F)
Person(name=Harley, age=22, country=英国, sex=F)

2.2 skip举例

从Person列表中从第2个女性开始，取出所有的女性。

personList.stream().filter((p) -> p.getSex() == 'F').skip(1).forEach(System.out::println);

输出结果：

Person(name=Harley, age=22, country=英国, sex=F)
Person(name=小梅, age=20, country=中国, sex=F)
Person(name=何雪, age=21, country=中国, sex=F)

 2.3 distinct举例

从Person列表中取出所有男性并过滤掉名字重复的。

personList.stream().filter((p) -> p.getSex() == 'M').distinct().forEach(System.out::println);

输出结果： 

Person(name=Tom, age=24, country=美国, sex=M)
Person(name=向天笑, age=20, country=中国, sex=M)
Person(name=李康, age=22, country=中国, sex=M)

3、Stream中间操作--映射

  • map--接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
  • flatMap--接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

3.1 map举例

例1：我们用一个PersonCountry类来接收所有的国家信息：

@Data
class PersonCountry {
    private String country;
}

personList.stream().map((p) -> {
       PersonCountry personName = new PersonCountry();
       personName.setCountry(p.getCountry());
       return personName;
}).distinct().forEach(System.out::println);

输出结果：

PersonName(country=中国)
PersonName(country=美国)
PersonName(country=英国)

例2：有一个字符列表，需要提出每一个字符 

List<String> list = Arrays.asList("aaa","bbb","ccc","ddd","ddd");

 根据字符串获取字符方法：

public static Stream<Character> getCharacterByString(String str) {
    List<Character> characterList = new ArrayList<>();
    for (Character character : str.toCharArray()) {
        characterList.add(character);
    }
    return characterList.stream();
}
List<String> list = Arrays.asList("aaa","bbb","ccc","ddd","ddd");
final Stream<Stream<Character>> streamStream = list.stream().map(TestStreamAPI::getCharacterByString);
streamStream.forEach(System.out::println);

输出结果：

java.util.stream.ReferencePipeline$Head@3f91beef
java.util.stream.ReferencePipeline$Head@1a6c5a9e
java.util.stream.ReferencePipeline$Head@37bba400
java.util.stream.ReferencePipeline$Head@179d3b25
java.util.stream.ReferencePipeline$Head@254989ff

 从输出结果及返回结果类型（Stream<Stream<Character>>）可以看出这是一个流中流，要想打印出我们想要的结果，需要对流中的每个流进行打印：

streamStream.forEach(sm -> sm.forEach(System.out::print));

输出结果：

aaabbbcccdddddd

 但我们希望的是返回的是一个流，而不是一个包含了多个流的流，而flatMap可以帮助我们做到这一点。

3.2 flatMap举例

改写上面的方法，将map改成flatMap:

final Stream<Character> characterStream = list.stream().flatMap(TestStreamAPI::getCharacterByString);
characterStream.forEach(System.out::print);

输出结果：

aaabbbcccdddddd

3.3 map和flatMap的图解

map图解：

 

map在接收到流后，直接将Stream放入到一个Stream中，最终整体返回一个包含了多个Stream的Stream。

flatMap图解：

flatMap在接收到Stream后，会将接收到的Stream中的每个元素取出来放入一个Stream中，最后将一个包含多个元素的Stream返回。

4、Stream中间操作--排序

  • sorted()--自然排序(Comparable)
  • sorted(Comparator com)--定制排序（Comparator）

对前面的personList按年龄从小到大排序,年龄相同，则再按姓名排序：

final Stream<Person> sorted = personList.stream().sorted((p1, p2) -> {
    if (p1.getAge().equals(p2.getAge())) {
        return p1.getName().compareTo(p2.getName());
    } else {
        return p1.getAge().compareTo(p2.getAge());
    }
});
sorted.forEach(System.out::println);

 输出结果：

Person(name=欧阳雪, age=18, country=中国, sex=F)
Person(name=向天笑, age=20, country=中国, sex=M)
Person(name=小梅, age=20, country=中国, sex=F)
Person(name=何雪, age=21, country=中国, sex=F)
Person(name=Harley, age=22, country=英国, sex=F)
Person(name=李康, age=22, country=中国, sex=M)
Person(name=李康, age=22, country=中国, sex=M)
Person(name=Tom, age=24, country=美国, sex=M)

5、终止操作--查找与匹配

  • allMatch--检查是否匹配所有元素
  • anyMatch--检查是否至少匹配一个元素
  • noneMatch--检查是否没有匹配所有元素
  • findFirst--返回第一个元素
  • findAny--返回当前流中的任意元素
  • count--返回流中元素的总个数
  • max--返回流中最大值
  • min--返回流中最小值

5.1 allMatch

判断personList中的人是否都是成年人：

final boolean adult = personList.stream().allMatch(p -> p.getAge() >= 18);
System.out.println("是否都是成年人：" + adult);

final boolean chinaese = personList.stream().allMatch(p -> p.getCountry().equals("中国"));
System.out.println("是否都是中国人：" + chinaese);

输出结果：

是否都是成年人：true
是否都是中国人：false

5.2 max、min

获取personList中年龄最大的人信息和年龄最小的人信息：

final Optional<Person> maxAge = personList.stream().max((p1, p2) -> p1.getAge().compareTo(p2.getAge()));
System.out.println("年龄最大的人信息：" + maxAge.get());

final Optional<Person> minAge = personList.stream().min((p1, p2) -> p1.getAge().compareTo(p2.getAge()));
System.out.println("年龄最小的人信息：" + minAge.get());

输出结果：

年龄最大的人信息：Person(name=Tom, age=24, country=美国, sex=M)
年龄最小的人信息：Person(name=欧阳雪, age=18, country=中国, sex=F)

6、归约

Stream API的归约操作可以将流中元素反复结合起来，得到一个值：

Optional<T> reduce(BinaryOperator<T> accumulator);
T reduce(T identity, BinaryOperator<T> accumulator);
<U> U reduce(U identity,  BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);

6.1 求一个1到100的和

List<Integer> integerList = new ArrayList<>(100);
for(int i = 1;i <= 100;i++) {
  integerList.add(i);
}
final Integer reduce = integerList.stream().reduce(0, (x, y) -> x + y);
System.out.println("结果为：" + reduce);

输出结果：

结果为：5050

这里用到了reduce第二个方法：T reduce(T identity, BinaryOperator<T> accumulator)

把这个动作拆解一下，其运算步骤模拟如下：

0  (1,2) -> 1 + 2 + 0     
3  (3,4) -> 3 + 4 + 3
10 (5,6) -> 5 + 6 + 10
.
.
.

运算步骤是：每次将列表的两个元素相加，并将结果与前一次的两个元素的相加结果进行累加。在开始时，将identity设为0，因为第1个元素和第2个元素在相加的时候，前面还没有元素操作过。 

6.2 求所有人的年龄之和

final Optional<Integer> reduce = personList.stream().map(Person::getAge).reduce(Integer::sum);
System.out.println("年龄总和：" + reduce);

输出结果：

年龄总和：169

7、收集

collect：将流转换为其他形式，接收一个Collector接口实现 ，用于给Stream中汇总的方法

<R, A> R collect(Collector<? super T, A, R> collector);
<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);

collect不光可以将流转换成其他集合等形式，还可以进行归约等操作，具体实现也很简单，主要是与Collectors类搭配使用。 

7.1 改写3.1 map举例中的的例子，将国家收集起来转换成List

final List<String> collect = personList.stream().map(p -> p.getCountry()).distinct().collect(Collectors.toList());
System.out.println(collect);

输出结果：

[中国, 美国, 英国]

7.2 计算出平均年龄

final Double collect1 = personList.stream().collect(Collectors.averagingInt(p -> p.getAge()));
System.out.println("平均年龄为：" + collect1);

输出结果：

平均年龄为：21.125

7.3 找出最小年龄、最大年龄

final Optional<Integer> maxAge2 = personList.stream().map(Person::getAge).collect(Collectors.maxBy(Integer::compareTo));
System.out.println("最大年龄：" + maxAge2.get());

final Optional<Integer> minAge2 = personList.stream().map(Person::getAge).collect(Collectors.minBy(Integer::compareTo));
System.out.println("最小年龄：" + minAge2.get());

输出结果：

最大年龄：24
最小年龄：18

还有其他很操作，可以参考java.util.stream.Collectors。

8、注意流的关闭

try(final Stream<Integer> integerStream = personList.stream().map(Person::getAge)) {
 final Optional<Integer> minAge = integerStream.collect(Collectors.minBy(Integer::compareTo));
 System.out.println(minAge.get());
}

最好将流的操作放到try-with-resources，本章前面内容为了方便，没有放到try-with-resources中。

9、完整测试代码

import lombok.Data;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TestStreamAPI {

    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("欧阳雪",18,"中国",'F'));
        personList.add(new Person("Tom",24,"美国",'M'));
        personList.add(new Person("Harley",22,"英国",'F'));
        personList.add(new Person("向天笑",20,"中国",'M'));
        personList.add(new Person("李康",22,"中国",'M'));
        personList.add(new Person("小梅",20,"中国",'F'));
        personList.add(new Person("何雪",21,"中国",'F'));
        personList.add(new Person("李康",22,"中国",'M'));

        // 1）找到年龄大于18岁的人并输出；
        personList.stream().filter((p) -> p.getAge() > 18).forEach(System.out::println);

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

        // 2）找出所有中国人的数量
        long chinaPersonNum = personList.stream().filter((p) -> p.getCountry().equals("中国")).count();
        System.out.println("中国人有：" + chinaPersonNum);

        // limit
        personList.stream().filter((p) -> p.getSex() == 'F').limit(2).forEach(System.out::println);
        System.out.println();
        // skip
        personList.stream().filter((p) -> p.getSex() == 'F').skip(1).forEach(System.out::println);

        // distinct
        personList.stream().filter((p) -> p.getSex() == 'M').distinct().forEach(System.out::println);

        // map
        personList.stream().map((p) -> {
            PersonCountry personName = new PersonCountry();
            personName.setCountry(p.getCountry());
            return personName;
        }).distinct().forEach(System.out::println);

        // map2
        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd","ddd");

        final Stream<Stream<Character>> streamStream
                = list.stream().map(TestStreamAPI::getCharacterByString);
//        streamStream.forEach(System.out::println);
        streamStream.forEach(sm -> sm.forEach(System.out::print));

        // flatMap
        final Stream<Character> characterStream = list.stream().flatMap(TestStreamAPI::getCharacterByString);
        characterStream.forEach(System.out::print);

        // sort
        final Stream<Person> sorted = personList.stream().sorted((p1, p2) -> {

            if (p1.getAge().equals(p2.getAge())) {
                return p1.getName().compareTo(p2.getName());
            } else {
                return p1.getAge().compareTo(p2.getAge());
            }
        });
        sorted.forEach(System.out::println);

        // allMatch
        final Stream<Person> stream = personList.stream();
        final boolean adult = stream.allMatch(p -> p.getAge() >= 18);
        System.out.println("是否都是成年人：" + adult);

        final boolean chinaese = personList.stream().allMatch(p -> p.getCountry().equals("中国"));
        System.out.println("是否都是中国人：" + chinaese);

        // max min
        final Optional<Person> maxAge = personList.stream().max((p1, p2) -> p1.getAge().compareTo(p2.getAge()));
        System.out.println("年龄最大的人信息：" + maxAge.get());

        final Optional<Person> minAge = personList.stream().min((p1, p2) -> p1.getAge().compareTo(p2.getAge()));
        System.out.println("年龄最小的人信息：" + minAge.get());

        // reduce
        List<Integer> integerList = new ArrayList<>(100);
        for(int i = 1;i <= 100;i++) {
            integerList.add(i);
        }
        final Integer reduce = integerList.stream().reduce(0, (x, y) -> x + y);
        System.out.println("结果为：" + reduce);

        final Optional<Integer> totalAge = personList.stream().map(Person::getAge).reduce(Integer::sum);
        System.out.println("年龄总和：" + totalAge);

        // collect
        final List<String> collect = personList.stream().map(p -> p.getCountry()).distinct().collect(Collectors.toList());
        System.out.println(collect);

        final Double collect1 = personList.stream().collect(Collectors.averagingInt(p -> p.getAge()));
        System.out.println("平均年龄为：" + collect1);

        final Optional<Integer> maxAge2 = personList.stream().map(Person::getAge).collect(Collectors.maxBy(Integer::compareTo));
        System.out.println(maxAge2.get());

        try(final Stream<Integer> integerStream = personList.stream().map(Person::getAge)) {
            final Optional<Integer> minAge2 = integerStream.collect(Collectors.minBy(Integer::compareTo));
            System.out.println(minAge2.get());
        }
    }

    public static Stream<Character> getCharacterByString(String str) {

        List<Character> characterList = new ArrayList<>();

        for (Character character : str.toCharArray()) {
            characterList.add(character);
        }

        return characterList.stream();
    }
}

@Data
class PersonCountry {
    private String country;
}

@Data
class Person {
    private String name;
    private Integer age;
    private String country;
    private char sex;

    public Person(String name, Integer age, String country, char sex) {
        this.name = name;
        this.age = age;
        this.country = country;
        this.sex = sex;
    }
}

 

相思比梦长
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Stream流
萝卜_7
08-16 105
Stream流 1. 流的由来 在数据来源多样化的今天，在做数据统计和处理的时候，大多是以底层数据库或其他数据来源的数据为基础进行更上层的统计和处理。 在Java 的集合 API 中，辅助集合操作的方法太少 对数据的筛选、聚合操作等都需要程序员遍历集合进行，效率低下，笨拙 Stream流是对集合(Collection)对象功能的增强，它专注于对集合对象进行各种非常遍历、高效的聚合操作或者大数据的批量操作。 结合Lambda表达式，提高编程效率和程序的可读性。 2. Stream流 Stream流是一个
java8 退出stream,关闭Java 8 Stream
weixin_28793831的博客
02-24 514
If we use Java 8 Stream like list.stream().filter(....).collect(..)..... When is it closed this stream?Is it good practice that we close the stream us as the next example?Stream stream = list.stream()...
Java8新特性Stream流详解_stream ifpresent，2024年最新大数据开发架构师教你如何突破瓶颈
2301_79097795的博客
04-17 841
既然我们已经知道了这些强大的内置收集器，接下来就让我们尝试构建自定义收集器吧。比如说，我们希望将流中的所有人转换成一个字符串，包含所有大写的名称，并以|分割。为了达到这种效果，我们需要通过Collector.of()创建一个新的收集器。同时，我们还需要传入收集器的四个组成部分：供应器、累加器、组合器和终止器。() -> new StringJoiner(" | "), // supplier 供应器。
Stream API有哪些中间操作？看完你也可以吊打面试官
uuuyy_的博客
01-21 1282
Stream的中间操作 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值” 。 Stream的中间操作是不会有任何结果数据输出的。 Stream的中间操作在整体上可以分为：筛选与切片、映射、排序。接下来，我们就分别对这些中间操作进行简要的说明。 筛选与切片 这里，我将与筛选和切片有关的操作整理成如下表格。 接下来，我们列举几个简单的示例，以便加深理解。 为了更好的测试程序，我先构造了一个对象数组
Stream流编程的中间操作
madleep的博客
08-22 1033
一、Stram流的中间操作 Stream的中间操作分为两类，一类为无状态操作：元素操作跟其它元素没有关系，另一类为有状态操作：元素操作跟其它元素有关，比如求最大最小值、求平均值、排序等 二、使用步骤 1.如何进行中间操作 代码如下： public class StreamMediumOperate { public static void main(String[] args) { //map IntStream.of(1,2,3).map(x -> x *
Stream流中间操作方法
Leon_Jinhai_Sun的博客
09-12 1906
概念 中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。 常见方法 方法名 说明 Stream<T> filter(Predicate predicate) 用于对流中的数据进行过滤 Stream<T> limit(long maxSize) 返回此流中的元素组成的流，截取前指定参数个数的数据 Stream<T> skip(long n) 跳过指定参数个数的数据，返回由该流的..
Java8新特性Stream流实例详解
08-29
Java8新特性Stream流实例详解 Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。...
Java8新特性Stream的完全使用指南
08-19
Java8新特性Stream的完全使用指南 Stream是Java 1.8版本开始提供的一个接口，主要提供对数据集合使用流的方式进行操作，流中的元素不可变且只会被消费一次，所有方法都设计成支持链式调用。使用Stream API可以极大...
java8新特性 stream流的方式遍历集合和数组操作
08-18
Java 8 新特性 Stream 流的方式遍历集合和数组操作 Java 8 中引入了 Stream 流的概念，旨在提供一种更加优雅的方式来遍历集合和数组。Stream 流可以看作是一种 lazy 的数据结构，它可以对集合和数组进行遍历、过滤...
Java8特性Stream流的使用（学完就会，项目源码，附带个人总结）
09-09
以下将详细介绍Stream流的使用，以及它在Java8中的重要性。 首先，Stream API是一种用于处理集合的新接口，它可以对集合进行各种操作，如过滤、映射、聚合等，而无需显式地遍历集合。这种处理方式称为“函数式编程...
Java8新特性之方法引用&Stream流应用实例md，学习代码
最新发布
06-21
Java 8是Java语言的一个重要版本，引入了许多新特性，极大地提升了开发效率和代码的可读性。在本文中，我们将重点关注两个关键特性：方法引用和Stream流，并结合实际应用实例进行深入探讨。 首先，我们来看一下方法...
Stream流的常见中间操作方法
qq_52629349的博客
04-11 507
Stream流的常见中间操作方法
Stream 的几种中间操作
艾斯比
11-17 821
filter 根据条件过滤元素 limit 只取前 n 个元素 skip 跳过前 n 个元素 distinct 根据 hashcode() 和 equals() 去重 map 映射, 例如将某个类对象映射为其某个属性类型 flatMap 扁平映射, 把元素映射为 Stream
优雅参数判空_Java8 ： Optional 类，优雅判定null
weixin_31319319的博客
02-05 1046
Optional不是对null关键字的一种替代，而是对于null判定提供了一种更加优雅的实现NullPointException可以说是所有java程序员都遇到过的一个异常，虽然java从设计之初就力图让程序员脱离指针的苦海，但是指针确实是实际存在的，而java设计者也只能是让指针在java语言中变得更加简单、易用，而不能完全的将其剔除，所以才有了我们日常所见到的关键字null。空指针异常是一个运...
java_Stream流和Optional
beginnerdzz的博客
06-01 749
​ Java8的Stream使用的是函数式编程模式，如同它的名字一样，它可以被用来对集合或数组进行链状流式的操作。可以更方便的让我们对集合或数组操作。 idea 对debug对stream流的直观体现：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GtKTiuQX-1654088320870)(C:\Users\DONG\AppData\Roaming\Typora\typora-user-images\image-20220527225905697.png)]单列集合： 数
JAVA日期类求年龄并求出大于指定年龄的学生。本人菜鸟，第一次发JAVA博客，也是第一次发博客！望大家交流指正！
ytblackbird的博客
03-17 752
今天老师让设计个学生类，用日期类来求出年龄并通过输入指定年龄求出大于年龄的学生！下面是我的小代码： package stuT_test; import java.text.SimpleDateFormat; import java.util.*; /** * 1.建立个学生类，属性有姓名，出生日期等。 * 2.建立学生数组，输入一个年龄，求出所有大于此年龄的学生。 * * @au
Java 8 Stream中间操作使用详解
qq_42730111的博客
06-09 1374
再次介绍Stream Stream 使用一种类似用于SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。 Stream两种操作 中间操作（Intermediate Operations）：中间操作会返回一个新的流，一个流可以后面跟随零个或多个intermediat.
Java8学习(4)-Stream流
weixin_33804582的博客
04-02 258
Stream和Collection的区别是什么 流和集合的区别是什么？ 粗略地说, 集合和流之间的差异就在于什么时候进行计算。集合是一个内存中的数据结构，它包含数据结构中目前所有的值--集合中的每个元素都得先计算出来才能添加到内存里。(你可以往集合里加东西或者删东西，但是不管什么时候，集合中的每个元素都是放在内存里的，元素都得计算出来才能成为集合的一部分。) 相比之下，流则是在概念上固定的数...
Map/Reduce与中间结果理论
weixin_34248118的博客
10-30 284
为什么80%的码农都做不了架构师？>>> ...
java 8 的新特性 stream流的使用
05-05
Java 8引入了Stream API，它是一种新的处理集合的方式，可以用更简洁、更易读的代码处理集合数据。Stream API提供了非常方便的、高效的数据处理方式，包括筛选、排序、映射、归约等。 下面是一些Stream的常用操作：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值