java8新特性之Stream流

最新推荐文章于 2024-08-02 17:39:33 发布
最新推荐文章于 2024-08-02 17:39:33 发布
阅读量329 收藏
点赞数
分类专栏： java8新特性 文章标签： stream java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45119323/article/details/107746374
版权

一、什么是Stream流

Stream是java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤、映射数据等操作，使用Stream API对集合数据进行操作就类似使用SQL执行数据库查询。也可以使用Stream API来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

集合讲的是数据，流讲的是计算

注意：

  • Stream自己不会存储元素
  • Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
  • Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才会去执行

二、Stream操作的三个步骤

1、创建Stream

一个数据源，获取一个流

package com.xuzhi.stream;

/**
 * Author: 徐志
 * Date: 2020/8/1 15:20
 */

import com.xuzhi.entity.Employee;
import org.junit.Test;

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

/**
 * Stream操作的三个步骤
 * 1.创建Stream
 * 2.中间操作
 * 3.终止操作
 */
public class TestStreamAPI1 {
    //1.创建Stream的几种方式
    @Test
    public void test1(){
        //1.可以通过Collection系列集合提供的stream()或者parallelStream()
        List<String> list=new ArrayList<>();
        Stream<String> stream1=list.stream();

        //2.通过Arrays中的静态方法获取数组流
        Employee[] emps=new Employee[10];
        Stream<Employee> stream2= Arrays.stream(emps);

        //3.通过Stream中的静态方法of()创建
        Stream<String> stream3 = Stream.of("aa", "dd", "dd", "ddddd");

        //4.创建无限流
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
        stream4.limit(10)
                .forEach(System.out::println);

        Stream.generate(()->Math.random())
                .limit(5)
                .forEach(System.out::println);

    }
}

2、中间操作

一个中间操作链，对数据源的数据进行处理
注意：多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”

package com.xuzhi.stream;

/**
 * Author: 徐志
 * Date: 2020/8/1 15:33
 */

import com.xuzhi.entity.Employee;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

/**
 * 中间操作
 * 筛选和切片
 * filter--接收Lambda，从流中排出某些元素
 * limit--截断流，使其元素不超过给定 的数量
 * skip(n)--跳过元素，返回一个扔掉了前n个元素的流，若流中的元素不足n个，则返回一个空流
 * distinct---筛选，通过流所产生的hashCode和equals()去除重复元素
 */
public class TestStreamAPI2 {
    List<Employee> employees= Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",38,5555.99),
            new Employee("王五",50,6666.99),
            new Employee("赵六",16,3333.99),
            new Employee("田七",8,7777.99)
    );

    //内部迭代
    @Test
    public void test1(){
         employees.stream()
                 .filter((e)->e.getAge()>35)
                 .forEach(System.out::println);
    }

    //外部迭代
    @Test
    public void test2(){
        Iterator<Employee> it=employees.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

    @Test
    public void test3(){
        employees.stream()
                .filter((e)->e.getSalary()>5000)
                .limit(2)
                .forEach(System.out::println);
    }

    @Test
    public void test4(){
        employees.stream()
                .filter((e)->e.getSalary()>5000)
                .skip(2)
                .forEach(System.out::println);
    }

    /**
     * 映射
     * map--接收lambda，将元素转换成其他形式获取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
     * flatMap--接收一个函数作为参数，将流中的每一个值换成另一个流，然后把所有的流连成一个流
     *
     */
     @Test
    public void test5(){
         List<String> list=Arrays.asList("aaa","bbb","ccccc","ddd","ee");

         list.stream()
                 .map((str)->str.toUpperCase())
                 .forEach(System.out::println);

         employees.stream()
                 .map(Employee::getName)
                 .forEach(System.out::println);


         /**--------------------------------------------**/
         Stream<Stream<Character>> stream=list.stream()
                 .map(TestStreamAPI2::filterCharacter);

         stream.forEach((sm)->{
             sm.forEach(System.out::println);
         });

         /**--------------------------------------------**/
         list.stream()
                 .flatMap(TestStreamAPI2::filterCharacter)
                 .forEach(System.out::println);



     }

     public static Stream<Character> filterCharacter(String str){
         List<Character> list=new ArrayList<>();

         for (Character c:str.toCharArray()) {
             list.add(c);
         }
         return list.stream();
     }

    /**
     * 排序
     * sorted()--自然排序
     * sorted(Comparator com)
     *
     */
    @Test
    public void test7(){
        List<String> list=Arrays.asList("aa","ddd","dddf","rfgg");

        list.stream()
                .sorted()
                .forEach(System.out::println);

        employees.stream()
                .sorted((e1,e2)->{
                    if(e1.getAge()==e2.getAge()){
                        return e1.getName().compareTo(e2.getName());
                    }else{
                        return Integer.compare(e1.getAge(),e2.getAge());
                    }

                })
        .forEach(System.out::println);
    }
}

map和flatMap的区别
在讲解mapflatMap的区别之前，先来看看集合中add()和addALL()方法的区别

@Test
    public void test(){
        List list1=new ArrayList();
        List list2=new ArrayList();
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        list1.add(1);
        list1.add(2);
        list1.add(list);
        System.out.println(list1.toString());

        list2.add(1);
        list2.add(2);
        list2.addAll(list);
        System.out.println(list2.toString());
    }

运行结果
在这里插入图片描述
使用add()方法，他会将集合当做元素插入进集合当中，而addAll()而是将此集合中的元素插入。

map和flatMap与之类似，遇到同样的情况，map会返回一个Stream的集合，集合里面又有一个Stream的集合，二flatMap不会

3、终止操作

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

package com.xuzhi.stream;

/**
 * Author: 徐志
 * Date: 2020/8/2 8:11
 */

import com.xuzhi.entity.Employee;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 终止操作
 */
public class TestStreamAPI3 {
    List<Employee> employees= Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",38,5555.99),
            new Employee("王五",50,6666.99),
            new Employee("赵六",16,3333.99),
            new Employee("田七",18,7777.99)
    );

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

    @Test
    public void  test1(){
        boolean b1 = employees.stream()
                .allMatch((e) -> e.getAge() == 18);
        System.out.println(b1);

        boolean b2 = employees.stream()
                .anyMatch((e) -> e.getAge() == 18);
        System.out.println(b2);

        boolean b3 = employees.stream()
                .noneMatch((e) -> e.getAge() == 18);
        System.out.println(b3);

        Optional<Employee> first = employees.stream()
                .sorted((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary()))
                .findFirst();
        System.out.println(first.get());

        Optional<Employee> any = employees.stream()
                .sorted()
                .findAny();
        System.out.println(any.get());


    }

    @Test
    public void test2(){
        long count = employees.stream()
                .count();
        System.out.println(count);

        Optional<Employee> max = employees.stream()
                .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(max.get());

        Optional<Double> min = employees.stream()
                .map(Employee::getSalary)
                .min(Double::compare);
        System.out.println(min.get());
    }

    /**
     * 规约
     * reduce--可以将流中的元素反复结合起来，得到一个值
     */

    @Test
    public void test3(){
        List<Integer> list=Arrays.asList(1,2,3,4,5,6,7,8,9,0);

        Integer reduce = list.stream()
                .reduce(0, (x, y) -> x + y);
        System.out.println(reduce);

        Optional<Double> reduce1 = employees.stream()
                .map(Employee::getSalary)
                .reduce(Double::sum);

    }

    /**
     * 收集
     *
     * collect--将流转换成其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
     */
    @Test
    public void test4(){
        List<String> collect = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());
        collect.forEach(System.out::println);

        Set<Double> collect1 = employees.stream()
                .map(Employee::getSalary)
                .collect(Collectors.toSet());
        collect1.forEach(System.out::println);

        HashSet<String> collect2 = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        collect2.forEach(System.out::println);
    }

    @Test
    public void test5(){
        Long collect = employees.stream()
                .collect(Collectors.counting());
        System.out.println(collect);

        Double collect1 = employees.stream()
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(collect1);

       Double collect2 = employees.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(collect2);

        Optional<Employee> collect3 = employees.stream()
                .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        System.out.println(collect3.get());

    }

    //分组
    @Test
    public void test6(){
        Map<Integer, List<Employee>> collect = employees.stream()
                .collect(Collectors.groupingBy(Employee::getAge));
        System.out.println(collect);
    }
    

   //分区
   @Test
    public void test8(){
       Map<Boolean, List<Employee>> collect = employees.stream()
               .collect(Collectors.partitioningBy((e) -> e.getSalary() > 6000));
       System.out.println(collect);
   }

   @Test
   public void test9(){
       DoubleSummaryStatistics collect = employees.stream()
               .collect(Collectors.summarizingDouble(Employee::getSalary));
       System.out.println(collect.getMax());
   }

   //连接
   @Test
    public void test10(){
       String collect = employees.stream()
               .map(Employee::getName)
               .collect(Collectors.joining(","));
       System.out.println(collect);
   }
}

三、小练习

package com.xuzhi.stream;

import com.xuzhi.entity.Employee;
import org.junit.Test;

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

/**
 * Author: 徐志
 * Date: 2020/8/2 10:33
 */
public class Zuoye {
    /**
     * 给定一个数字列表，如何返回一个由每个数的平方组成的列表
     * 给定【1，2，3，4，5】，应该返回【1，4，9，16，25】
     */

    @Test
    public void test1(){
        Integer[] nums=new Integer[]{1,2,3,4,5};
        Arrays.stream(nums)
                .map((x)->x*x)
                .forEach(System.out::println);
    }

    /**
     * 怎样用map+reduce数出有多少个Employee
     */
    List<Employee> employees= Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",38,5555.99),
            new Employee("王五",50,6666.99),
            new Employee("赵六",16,3333.99),
            new Employee("田七",8,7777.99)
    );
    public void test2(){
        Optional<Integer> reduce = employees.stream()
                .map((e) -> 1)
                .reduce(Integer::sum);
        System.out.println(reduce.get());
    }

}

四、并行流和顺序流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流

java8中将并行进行了优化，我们可以很容易的对数据进行并行操作，StreamAPI可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换
在这里插入图片描述
在这里插入图片描述

  • ForkJoinCalculate.java
package com.xuzhi.forkJoin;

import java.util.concurrent.RecursiveTask;

/**
 * Author: 徐志
 * Date: 2020/8/2 11:20
 */
 /**
 使用ForkJoin框架必须继承RecursiveAction或者RecursiveTask。两者的区别是RecursiveTask有返回值，RecursiveAction没有返回值
 */
public class ForkJoinCalculate extends RecursiveTask<Long> {

    private static final long serialVersionUID=233224555L;

    private long start;
    private long end;

    private static final long THREADHOLD=10000;

    public ForkJoinCalculate(long start,long end){
        this.start=start;
        this.end=end;

    }
    @Override
    protected Long compute() {
        long length=end-start;
        if(length<=THREADHOLD){
            long sum=0;
            for (long i=start;i<=end;i++){
                sum+=i;
            }
            return sum;

        }else{
            long mid=(start+end)/2;
            ForkJoinCalculate left=new ForkJoinCalculate(start,mid);
            left.fork();
            ForkJoinCalculate right=new ForkJoinCalculate(mid+1,end);
            right.fork();

            return left.join()+right.join();
        }
    }
}
  • TestForkJoin.java
package com.xuzhi.forkJoin;

import org.junit.Test;

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

/**
 * Author: 徐志
 * Date: 2020/8/2 11:29
 */
public class TestForkJoin {

/*
使用ForkJoin
*/
    @Test
    public void test1(){
        Instant startTime = Instant.now();

        ForkJoinPool pool=new ForkJoinPool();
        ForkJoinTask<Long> task=new ForkJoinCalculate(0,100000000L);
        Long sum=pool.invoke(task);
        System.out.println(sum);

        Instant endTime = Instant.now();
        System.out.println(Duration.between(startTime, endTime).toMillis());
    }

/*
传统的for循环
*/
    @Test
    public void test2(){

        Instant startTime = Instant.now();
        long sum=0L;
        for (long i = 0; i <=100000000L; i++) {
            sum+=i;
        }
        System.out.println(sum);
        Instant endTime = Instant.now();
        System.out.println(Duration.between(startTime, endTime).toMillis());


    }

    //java8并行流
    public void test3(){
        Instant startTime = Instant.now();
        LongStream.rangeClosed(0,100000000L)
                .parallel()
                .reduce(0,Long::sum);

        Instant endTime = Instant.now();
        System.out.println(Duration.between(startTime, endTime).toMillis());

    }
}

使用forkJoin框架或者并行流都是为了充分利用CPU的资源，当数据量过小的时候，for循环会比其他两种方式块，当数据量较大时，并行流的优势就提现出来了

五、Optional

Optional<T>类是一个容器类，代表一个值存在或者不存在，原来使用Null表示一个值不存在，现在Optional可以更好的表达这个概念，并且可以避免空指针异常

常用方法：

  • Optional.of(T t)：创建一个Optional实例
  • Optional.empty()：创建一个空的Optional实例
  • Optional.ofNullable(T t)：若t不为null，创建Optional实例，否则则创建空实例
  • isPresent()：判断是否包含值
  • orElse(T t)：如果调用 的对象包含值，返回该值，否则返回t
  • orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回s获取的值
  • map(Function f)：如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
  • flatMap(Function mapper)：与map类似，要求返回值必须是Optional
package com.xuzhi.optional;

import com.xuzhi.entity.Employee;
import org.junit.Test;

import java.util.Optional;

/**
 * Author: 徐志
 * Date: 2020/8/2 14:53
 */
public class TestOptional {

    @Test
    public void test1(){
        //不能为null
        Optional<Employee> op=Optional.of(new Employee());

        Employee employee = op.get();
        System.out.println(employee);
    }

    @Test
    public void test2(){
        Optional<Employee> op = Optional.empty();
        System.out.println(op.get());

    }

    @Test
    public void test3(){
        //有值就获取，没值就什么都不做
        Optional<Employee> op = Optional.ofNullable(null);
       /* if (op.isPresent()){
            System.out.println(op.get());
        }*/

        Employee employee = op.orElse(new Employee("李四", 66, 99999));
        System.out.println(employee);

        Employee employee1 = op.orElseGet(() -> new Employee());
        System.out.println(employee1);


    }

    @Test
    public void test4(){
        Optional<Employee> dd = Optional.ofNullable(new Employee("dd", 33, 4343));
      /*  Optional<String> s = dd.map((e) -> e.getName());
        System.out.println(s.get());*/

        Optional<String> s = dd.flatMap((e) -> Optional.of(e.getName()));
        System.out.println(s);

    }
}

六、总结

本人观看的学习资料为B站尚硅谷教学视频。简单的学习了解了Stream流操作集合的强大，过去对集合中的元素进行操作可能需要写比较复杂的代码，现在通过Stream流配合lambda表达式，实现一些功能实在是太轻松了。附上本人微信公众号二维码，欢迎一起交流学习
在这里插入图片描述

lamdaxu
关注
专栏目录
java8新特性之Stream
higher_的博客
11-27 494
概述 Stream API与InputStream和OutputStream是完全不同的概念，Stream API是对Java中集合操作的增强，可以利用它进行各种过滤、排序、分组、聚合等操作。Stream API配合Lambda表达式可以加大的提高代码可读性和编码效率，Stream API也支持并行操作。 流不是集合，它不关心数据的存放，只关注如何处理数据 Stream API主要用于处理集合...
Java8新特性之Stream流详解+案例
橘子汁的博客
06-11 2023
Stream是一个流，在java.util.Stream包路径下，主要作用就是对集合数据进行查找过滤等操作，一种高效且易用的数据处理方式 流的创建：此处列举3种常用方法 //1. 通过 java.util.Collection.stream() 方法 List<String> list = Arrays.asList("a", "b", "c"); Stream<String> stream = list.stream // 创建并行流 Stream<String>
Java8新特性-Stream流
Xiong-er 的博客
10-14 349
01 、概述 Stream 是JDK1.8的新特性，可以结合lambada表达式结合使用 可以提升开发的效率和性能。 02、 Stream流的作用 对于集合迭代的增强处理 可以对于集合数组进行更高效的聚合操作，比如： 分组、过滤、排序，元素的追加等。 解决了的传统开发过程中，jdk对集合或者数组API不足的问题，因为在早期的API的开发过程中，对集合或者Map的操作其实比较单一和缺乏。在jdk1.8之后就参考了很多语言的一些对数组和集合操作的API。 比如JS的数组的reduce、map、sort、f
Java8新特性（二） Stream与Optional详解
最新发布
Hello World!
08-02 722
Stream（java.util.stream） 是Java 8中新增的一种抽象流式接口，主要用于配合Lambda表达式提高批量数据的计算和处理效率。Stream不是一种数据结构，它是来自数据源的一种元素序列组织视图，并支持一系列聚合操作，比如过滤、排序、映射、遍历等；其中，数据源可以是一个数组、集合或I/O channel等。
Java8新特性 - stream流
Javaer`s blog
07-13 337
1. lambda表达式 1.1 什么是lambda Lambda 表达式有何用处？如何使用？ 以java为例，可以对一个java变量赋一个值，比如int a = 1，而对于一个方法，一块代码也是赋予给一个变量的，对于这块代码，或者说被赋给变量的函数，就是一个lambda表达式 //为变量赋值 int a = 1; //将代码块赋值给变量 var = public void fun(int x){ x+1; } //可以简化 var = (x)->x+1; 1.2 java为什么要引入lamb
java代码之美（2）---Java8 Stream
后端元宇宙
01-09 380
Stream 第一次看到Stream表达式就深深把我吸引，用它可以使你的代码更加整洁而且对集合的操作效率也会大大提高，如果你还没有用到java8的Stream特性，那就说明你确实out啦。 一、概述 1、什么是Stream Stream是一种可供流式操作的数据视图有些类似数据库中视图的概念它不改变源数据集合如果对其进行改变的操作它会返回一个新的数据集合。 总的来讲它有三大特性：在之后我们...
Java8新特性Stream流实例详解
08-29
Java8新特性Stream流实例详解 Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。...
java8新特性之Stream流操作
l_l_jh的博客
04-22 1498
Stream流操作是java8的最重要的新特性之一，功能强大,非常常用。可以说每个java coder必须掌握，这次把理论放在最后面，因为你可能不需要知道的多么详细，只是需要看看某个功能，可能听名字就大概知道它是做什么的。 举个简单例子，现在给了你同学信息和成绩，你需要统计班级平均分 // 以前可能的做法 public static avgScore(List<Student> stus){ int sum=0; for (Student student : stus) {
java8新特性 stream流的方式遍历集合和数组操作
08-18
Java 8 新特性 Stream 流的方式遍历集合和数组操作 Java 8 中引入了 Stream 流的概念，旨在提供一种更加优雅的方式来遍历集合和数组。Stream 流可以看作是一种 lazy 的数据结构，它可以对集合和数组进行遍历、过滤...
Java8新特性之Stream流 （图片整理）
qq_43268400的博客
08-10 987
Java8新特性之Stream流 学习笔记全面总结（图片整理） 由于放着一张图上太大，反而影响总结的效果。 故根据以下方式进行分类分开总结，最后再转一篇流的操作的案例的文章。 一 Stream流的概述 二 流的获取 三 流的操作方法列表及分类 四 流的操作方法-按使用目的分类 五 Stream流部分执行机制分析 六 转一篇流操作案例参考文 一 Stream流的概述 二 流的获取 三...
Java8新特性整理之流的介绍与使用（三）
一大三千的博客
02-07 590
流是什么 官方定义：支持顺序和并行聚合操作的元素序列。 这里有几个关键词，顺序、并行、聚合、元素序列。 所谓顺序就是单线程顺序执行，并行就是多线程分解执行，聚合就是将顺序或并行执行的结果计算后得出最终结果，元素序列则是将数据源（数组，文件，集合等）流化后的数据结构。 流与集合 上面说的还是有些不明朗，下面结合Java中的集合（Collection）来进一步解释流。 Java现有的集
Java8新特性——Stream
skeeing的博客
06-27 617
1、Stream在Java8中被定义为泛型接口 2、Stream接口代表数据流。 3、Stream不是一个数据结构，不直接存储数据。 4、Stream通过管道操作数据。 5、创建Stream接口实现类对象： stream()：创建一个Stream接口实现类的对象。 例如： Stream stream=people.stream();一、管道：代表一个操作序列。 二、
Java 8 新特性——Stream
wenqi1992的博客
07-13 1547
Java 8 新特性之 Stream 的详细讲解，丰富的示例，通熟易懂
Java8新特性之Stream流
helloliyibo的博客
09-22 302
Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，课执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来进行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式 注意： Stream自己不会存储元素 Stream不会改变源对象。相...
java8 新特性 stream
weixin_43975276的博客
09-01 505
Stream.of(数组对象)创建流，如果数组数据类型是基本类型，那么创建的流内部是数组对象（int[ ]）,会有问题。我理解中Stream.of()更像是直接把参数作为一个个的对象去创建流（看解释符合我的猜想），不过参数是字符串数组的时候又会拿数组里面的数据去创建流，真是疑惑。在括号内，是一对多的关系，左边是原理的对象，右边是一个新的流。也就是将一个对象转成一个流（流里面可能包含多个对象），最后再将全部流合在一起，形成一个新的流。根据括号内的条件，符合条件的加入返回的流，不符合的就被过滤掉。
java8 新特性之stream
秋叶清风的博客
09-24 128
学习 Java 8 Stream，总结一下，方便自己以后的学习查看 生成流 stream() 对流的操作，包括 forEach,map,filter,limit,sorted,Collectors,mapToInt 新建 StreamDemo01 import lombok.extern.slf4j.Slf4j; import java.util.Arrays; import java.util.IntSummaryStatistics; import java.util.List; import j
java8新特性之stream
庄生晓梦的博客
12-29 281
上一章我们讲了java8新特性之lambda表达式，作为一个匿名函数，极大的简化了代码。今天我们来聊聊java8的另一个可以简化代码的特性——stream。 lambda表达式是stream的基础，建议先学习lambda表达式在学习stream相关知识。 1、首先，stream是什么？ 刚接触可能觉得stream和对文件进行操作的io流类似，但实际上这两者一点关系都没有。 stream是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值