精华内容
下载资源
问答
  • java1.8常用的Lamdba表达式 Stream API

    千次阅读 2019-08-15 23:50:18
    Lambda表达式是一个匿名函数,运用Lambda表达式可以极大的提高编程效率程序可读性。 Java 8 中的 Stream 是对集合(Collection)对象功能的增强,对集合进行各种非常便利、高效的聚合操作,或者大批量数据操作。 ...

    Lambda表达式是什么,有什么用?

    Lambda表达式是一个匿名函数,运用Lambda表达式可以极大的提高编程效率和程序可读性。
    Java 8 中的 Stream 是对集合(Collection)对象功能的增强,对集合进行各种非常便利、高效的聚合操作,或者大批量数据操作。
    Stream 可以理解为高级版本的 Iterator。同时它提供串行和并行两种模式进行汇聚操作,并发模式能够充分利用多核处理器的优势,使用 fork/join 并行方式来拆分任务和加速处理过程。
     

    了解下lamdba表达式的组成:

    (str) -> System.out.println(str)

    左边代表参数,右边代表主体。

    (str) :代表参数,不写类型会根据上下文获取(str1),也可以自己定义参数(String str1),也可以有多个参数(String str1,String str2),也可以无参()。

    ->     :  理解为“转到”的意思

    System.out.println(str) : 代表主体,如果是代码块加上花括号{System.out.println(str1); System.out.println(str2);}

    废话少说,下面介绍下在项目中经常用到的Lamdba表达式

    常用的Lamdba表达式

    代替匿名内部类

    //before
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("123");
        }
    }).start();
    
    //after
    new Thread(() -> System.out.println("456")).start();

    forEach:循环List

    List<String> list = Arrays.asList("2", "b", "10", "4", "6", "aa", "b", "ccdf");
    
    //before
    for (String str : list) {
        System.out.println(str);
    }
    
    //after
    list.forEach((str) -> System.out.println(str));
    
    // double colon operator
    list.forEach(System.out::println);
    
    System.out.println("**********************************************");
    
    //before
    for (String str : list) {
        if (str.equals("a")) {
            System.out.println(str);
        }
    }
    
    //after
    list.forEach((str) -> {
        if (str.equals("a")) {
            System.out.println(str);
        }
    });

    sort :  对List进行排序

    List<String> list = Arrays.asList("2", "b", "10", "4", "6", "aa", "b", "ccdf");
    
    //before
    Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    });
    
    //after
    Comparator<String> sortByName = ((String s1, String s2) -> (s1.compareTo(s2)));
    list.sort(sortByName);
    
    //or
    list.sort((String s1, String s2) -> s1.compareTo(s2));

    map : 它的作用就是把 input Stream 的每一个元素,映射成 output Stream 的另外一个元素。

    List<String> list = Arrays.asList("a", "a", "b", "c", "d", "g", "a", "z", "c");
    
    //转换成大写
    List<String> output = list
            .stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
    System.out.println(output);
    
    //每个元素 都 加上"字母"
    List<String> collect = list
            .stream()
            .map(s -> s + "字母")
            .collect(Collectors.toList());
    System.out.println(collect);

    reduce  :  依照运算规则把 Stream 里所有的元素组合起来

    List<String> list = Arrays.asList("a", "a", "b", "c", "d", "g", "a", "z", "c");
    
    // 把字符串都连接在一起
    String reduce = list.stream().reduce("",String::concat);
    System.out.println(reduce);
    
    // 求最小值
    double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
    System.out.println(minValue);
    
    // 求和,有起始值
    int sumValue = Stream.of(1, 2, 3, 4).reduce(10, Integer::sum);
    System.out.println(sumValue);
    
    // 求和,无起始值
    sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
    System.out.println(sumValue);

    下面我们建一个实体类,进一步学习

    class Student {
            private int id;
            private String name;
            private int age;
            private String gender;
        //getter \ setter 构造器 省略
    }

    Collectors.groupingBy : 把 Stream 元素进行归组
    Collectors.partitioningBy 其实是一种特殊的 groupingBy

    List<String> list = Arrays.asList("a", "a", "b", "c", "d", "g", "a", "z", "c");
    //统计每个字母出现次数
    Map<String, Long> collect = list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    System.out.println(collect);
    
    System.out.println("**********************************************");
    
    //初始化测试数据
    List<Student> studentList = new ArrayList<Student>() {
        {
            add(new Student(1, "小明", 12, "男"));
            add(new Student(2, "小花", 18, "女"));
            add(new Student(3, "小白", 13, "女"));
            add(new Student(4, "小黑", 14, "男"));
        }
    };
    // 按照年龄进行分组
    Map<Boolean, List<Student>> baby = studentList
            .stream()
            .collect(Collectors.partitioningBy(s -> s.getAge() < 18));
    System.out.println("年龄小于18的人数: " + baby.get(true).size());
    System.out.println("年龄大于18的人数: " + baby.get(false).size());
    
    // 按照性别分组  返回集合对象
    Map<String, List<Student>> collect1 = studentList
            .stream()
            .collect(Collectors.groupingBy(Student::getGender));
    System.out.println(collect1);
    
    //按照性别分组  返回统计后的个数
    Map<String, Long> collect2 = studentList
            .stream()
            .collect(Collectors.groupingBy(Student::getGender, Collectors.counting()));
    System.out.println(collect2);

     

    ************************************进阶学习********************************************

    filter 、collect 、map 、limit 等等操作

    //初始化测试数据
    List<Student> studentList = new ArrayList<Student>() {
        {
            add(new Student(1, "小明", 12, "男"));
            add(new Student(2, "小花", 18, "女"));
            add(new Student(3, "小白", 13, "女"));
            add(new Student(4, "小黑", 14, "男"));
        }
    };
    
    //查出所有学生姓名
    studentList.forEach((s) -> System.out.println(s.getName()));
    
    System.out.println("**********************************************");
    
    //给所有的学生年龄加3岁
    Consumer<Student> studentConsumer = s -> s.setAge(s.getAge() + 3);
    studentList.forEach(studentConsumer);
    System.out.println(studentList);
    
    System.out.println("**********************************************");
    
    //使用过滤器filter ,查出小明的信息
    studentList.stream().filter((s) -> s.getName().equals("小明")).forEach((s) -> System.out.println(s));
    
    System.out.println("**********************************************");
    
    // 自定义一些 filter
    Predicate<Student> nameFilter = (s) -> s.getName().equals("小花");
    Predicate<Student> ageFliter = (s) -> s.getAge() > 10;
    studentList.stream().filter(nameFilter).filter(ageFliter).forEach(System.out::println);
    
    System.out.println("**********************************************");
    
    //limit 限制返回结果的个数
    studentList.stream().filter(ageFliter).limit(2).forEach(System.out::println);
    
    System.out.println("**********************************************");
    
    //排序sorted + 转换collect
    List<Student> collect = studentList
            .stream()
            .sorted((s1, s2) -> s1.getAge() - s2.getAge())
            .collect(Collectors.toList());
    System.out.println(collect);
    
    System.out.println("**********************************************");
    
    //获取最大 \ 最小 年龄
    Student studentMax = studentList
            .stream()
            .min((s1, s2) -> s1.getAge() - s2.getAge())
            //.max((s1, s2) -> s1.getAge() - s2.getAge())
            .get();
    System.out.println(studentMax);
    
    System.out.println("**********************************************");
    
    // map + collect 将结果集转成String 、 Set ...
    String studentNameStr = studentList
            .stream()
            .map(Student::getName)
            .collect(Collectors.joining(","));
    System.out.println(studentNameStr);
    
    Set<String> studentNameSet = studentList
            .stream()
            .map(Student::getName)
            .collect(Collectors.toSet());
    System.out.println(studentNameSet);
    
    System.out.println("**********************************************");
    
    //统计所有学生的年龄总和
    int sum = studentList
            .parallelStream()
            .mapToInt(s -> s.getAge())
            .sum();
    System.out.println(sum);
    参考文章: https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/
    展开全文
  • 基于JDK 1.8  1、循环: // 以前的循环方式 for (String player : players) { ...nums.stream().filter(num -> num != null).count();   转载于:https://www.cnblogs.com/liangblog/p/10330447.html

    基于JDK 1.8 

    1、循环:

    // 以前的循环方式  
    for (String player : players) {  
         System.out.print(player + "; ");  
    }  
      
    // 使用 lambda 表达式以及函数操作(functional operation)  
    players.forEach((player) -> System.out.print(player + "; "));  
       
    // 在 Java 8 中使用双冒号操作符(double colon operator)  
    players.forEach(System.out::println);  

    2、匿名内部类:

    // 使用匿名内部类
    btn.setOnAction(new EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent event) {
    System.out.println("Hello World!");
    }
    });

    // 或者使用 lambda expression
    btn.setOnAction(event -> System.out.println("Hello World!"));

    3、比较函数排序:

    //  使用 lambda expression 排序

    Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));

    Arrays.sort(players, sortByName);

    //  也可以采用如下形式:

    Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));

     4、结合Stream:

    //Lists是Guava中的一个工具类
    List<Integer> nums = Lists.newArrayList(1,null,3,4,null,6);
    nums.stream().filter(num -> num != null).count();

     

    转载于:https://www.cnblogs.com/liangblog/p/10330447.html

    展开全文
  • 集合流,stream的运用和lamdba的涉及本文旨在探究lamdba表达式的使用以及jdk1.8中流的使用,且格式完全参照[csdn的markdown格式提示][6]在搞懂lambda之前,我们需要搞清楚什么叫做函数式接口 所谓函数式接口,就是...

    本文旨在探究lamdba表达式的使用以及jdk1.8中流的使用,且格式完全参照[csdn的markdown格式提示][6]

    在搞懂lambda之前,我们需要搞清楚什么叫做函数式接口

    所谓函数式接口,就是接口中只有一个抽象方法的接口,这种类型的接口也称为SAM接口,即Single
    Abstract Method interfaces。

    看看lamdba表达式的语法规范

    () -> function();

    第一个()内是参数别表,->为java中lamdba表达式符号(其他语言的lamdba表达式不太清楚),后面为函数,在java中就是方法,使用方式与平常使用相同。

    stream的运用

    在jdk1.8的文档中,我们看到Stream接口中有提供了很多的方法,但是,jdk中不是所有方法都是常用方法,下面我来罗列一下我们常用到的方法(按字母表顺序)

    1. collect():对流中的元素以Collector<-T,A,R>进行收集,其中T为元素输入类型,A为可变累积类型,R为返回结果类型,原谅我这里没有深究,Collectors工具类中给了很多工作中经常使用到的规则,如List、Map、Set等,可以直接使用
    2. count():返回流中的元素个数
    3. filter():将流以给定的谓词(这里指的是函数式接口,可以使用lamdba表达式)匹配,得出结果流,这里我个人通俗地理解为对流的过滤,将流中的的元素以给定的函数进行过滤,得出结果流
    4. foreach():对流中的每个元素进行函数操作,这里同样可以写lamdba表达式
    5. limit():返回以流中的元素组成的流,数量不超过给定的值
    6. map():返回以给定函数结果组成的流,这里说明一下map方法与filter方法的区别,filter方法中的函数返回boolean值以判断次元素的去留,filter后的元素与之前的元素类型是一致的,而map是以给定函数的运行结果为元素的,这就意味着map方法返回的流中的元素与之前不尽相同了
    7. sorted():返回以流中元素自然排序的顺序流,可以给定排序方式,同样可以写lamdba表达式来描述
    8. toArray():返回流中元素组成的数组,数组类型为Object,这里也可以给定返回类型

    这里贴一些代码图片:
    filter的使用


    map的使用


    collect的使用


    最后在对集合流做一个总结吧:之前我们使用集合时,都是需要先遍历集合,然后处理集合中的元素进行处理,而Collection接口给的方法不多,无法以动态的方式处理集合,而jdk1.8中提供的函数式编程(这里解释一下,给我这样的小白科普写函数式编程,我理解的函数式编程就是指将封装好的函数交给需要使用此函数的程序执行,有点像java中的接口编程,但是java中接口编程需要定义方法名称以及传递参数的类型、数目等,而jdk1.8提供的函数式编程无须定义这些,我们只需要告诉这个接口调用哪个方法,以什么方式调用就可以了(以lamdba表达式的形式,也许这就是c和java的区别吧)),函数式编程可以将如何操作元素的接口暴露出来,然后在需要使用该接口时是需要告诉这个接口的实现方法就可以了,这里就是lamdba表达式只能写在函数式接口的原因了,多个抽象方法无法匹配对应方法。

    展开全文
  • Lamdba表达式(2) - Stream

    2019-10-01 17:35:06
    有了Lamdba表达式 , Java就具有了进行函数式编程的条件 但是作为彻底的面向对象语言 , 并不支持函数的独立存在 所以JDK1.8添加了Stream以及一些相关的接口 Stream的特点可以概括如下 Stream是元素的序列 , 看起来...

    有了Lamdba表达式 , Java就具有了进行函数式编程的条件
    但是作为彻底的面向对象语言 , 并不支持函数的独立存在
    所以JDK1.8添加了Stream以及一些相关的接口

    Stream的特点可以概括如下

    1. Stream是元素的序列 , 看起来有点类似Iterator
    2. 可以支持顺序和并行聚合的操作
      可以把Stream看成一个高级版本的Iterator
      Iterator只能逐个对元素进行遍历 , 然后执行某些操作
      对于Stream , 只需要给出对元素进行处理的回调函数
      就可以对这个元素序列进行一些操作

    可以参考underscore对数组或者对象进行处理的一些方法
    编程方式上十分类似

    List<Integer> nums = Lists.newArrayList(5,2,1,0,null,56);
    Stream<Integer> stream = nums.stream();
    //过滤掉序列中的null值 并获得剩余元素的数量
    long count = stream.filter(num -> num!=null).count();
    System.out.println(count);//5

    Lists是Guava当中的一个工具类 , 这里用它来产生一个List对象

    Stream当中的很多非聚合方法 , 都是返回Stream对象 , 可以进行连缀
    但是注意 : 每次调用后的结果 , 都是产生一个新的Stream对象 , 而不再是原Stream对象
    此时如果再对原对象进行任何操作 , 都会抛出异常

    创建Stream

    有两种方式可以创建一个Stream对象

    1. 通过Stream接口当中的静态工厂方法
    2. 通过Collection接口的默认方法stream() , 上面的例子用的就是这种方式
      Stream接口中的静态工厂方法
    • of方法 - 有两个重载形式 , 一个是接收单一值 , 一个是接收多个值
    Stream<Integer> intStream = Stream.of(10,20,30);
    Stream<String> strStream = Stream.of("test");
    • generate方法 - 获得一个生成器
      这个方法产生的Stream是一个惰性序列 , 也就是它并不保存这个序列中所有的内容 , 每次需要获取的时候 , 再去生成
      通过这种方式 , 可以节约大量的内存 , 也可以获得一个无限长的序列
    Stream<Integer> randomNums = Stream.generate(()->(int)(Math.random()*1000));
    randomNums.limit(20).forEach(System.out::println);

    常用的非聚合操作

    • distinct - 去除序列中的重复元素 ( 依赖元素的equals方法 )
    • filter - 对于实参函数执行结果为false的 , 从序列中去除
    • map - 对于元素逐个使用实参函数进行处理 , 并将返回值组装成一个新的序列
    • peek - 克隆原Stream产生一个新的Stream , 并提供一个消费函数 , 当新Stream中的每个元素被消费的时候都会调用该函数
    • limit - 截取前若干个元素
    • skip - 丢弃前若干个元素
    • sorted - 对序列中的元素进行排序 ( 可以指定Comparator )

    常用的聚合操作

    聚合操作(也称为折叠)接受一个元素序列为输入,反复使用某个合并操作,把序列中的元素合并成一个汇总的结果。

    • collect - 将所有的元素放入到一个Collection容器当中 ( 属于可变聚合 )
    • reduce - 将前两个元素使用指定函数进行聚合 , 将结果与第三个元素进行聚合 , 依次进行下去
    • count - 获得序列中元素的数量

    Stream当中的方法大部分都可以根据名称猜出意思
    就不一一介绍了 , 详细内容参阅JDK源码

    转载于:https://www.cnblogs.com/programInit/p/6408606.html

    展开全文
  • 随着学习的深入,jdk8的改变强大远超出我的理解。由lamdba表达式引起的再一次思考,先贴出来这一块的代码 List&lt;CartDTO&gt; cartDTOList = orderDTO.getOrderDetailList().stream().map((e) -&gt; ...
  • 随着学习的深入,jdk8的改变强大远超出我的理解。 由lamdba表达式引起的再一次思考,先贴出来这一块的代码 List&lt;CartDTO&gt; cartDTOList = orderDTO.getOrderDetailList().stream().map((e) -&...
  • JDK 1.8遍历和Stream 不一样的遍历 摒弃掉传统的for循环的写法,让你体验到遍历的快感 for (int index = 0; index < list.size(); index++) { User user = list.get(index); System.out.println(user.getName...
  • 1.3 方法引用构造器 12 1.2.1 方法引用 12 1.2.2 构造器 12 1.4 Stream语法 13 1.3.1 入门案例 13 1.3.2 怎么得到Stream 15 1.3.3 转换Stream 16 1.3.4 汇聚Stream 19 2 Optional类 20 2.1 创建Optional容器 21 ...
  • Java8新特性 主要内容 Lamdba表达式 函数式接口 方法引用和构造器引用 ...Lamdba和Stream 为核心 一、Lambda表达式 为什么使用Lambda表达式 Lamdba是一个匿名函数,我们可以将Lambda表达式理解为是一段可以
  • jdk1.8提供了Stream 类,极大的方便了...下面就是一个通过Stream 提供的filter以及sorted对集合列表进行过滤排序。 List<ServiceOrderingViewDTO> list1 = result.getServiceOrderingViewDTOList().stream...
  • stream和方法引用Stream流:思想转变:传统集合的多步遍历代码使用流多步遍历代码:获取流根据Collection获取流根据Map获取流根据数组获取流流的常用方法:逐一处理:forEach过滤:filter映射:map统计个数:count取...
  • 在Java 8中,得益于Lamdba所带来的的函数式编程,引入了一个全新的Stream流概念,用于解决已有集合、数组类库存在的弊端(采用了Stream流简化集合和数组的操作) 案例:从集合中筛选出所有姓张的人出来,然后再找出姓名...
  • 文章目录一、Lambda表达式1、普通... java集合的聚合操作1、传统遍历聚合操作遍历2、 Stream和管道的概念3、管道源4、中间操作5、结束操作 一、Lambda表达式 1、普通方法 public class Hero implements Comparable&l
  • 1 Lamdba优于匿名内部类 (1)DEMO1 匿名内部类:过时 Collections.sort(words, new Comparator<String>() { public int compare(String s1, String s2) { return Integer.compare(s1.length(), s2.length...
  • lambda表达式是一个匿名函数,我们可以把lamdba表达式理解为是一段可以传递的代码。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,是java的语言表达能力得到了提升。 先不说语法,我们先来做一个需求...
  • 常用词句说明 ​ 语法糖: Syntactic sugar 这种语法对语言的功能并咩有影响,但是更方便使用,通常来说使用语法糖可以增加程序的...在 java 8 中得益于Lamdba带来的函数式编程,引入了一个全新的Stream概念,用于解决
  • lambda stream常用API

    2020-08-20 18:04:09
    Lambda表示数学符号"λ",计算机领域中的λ代表"λ演算",表达了计算机中最基本的概念:“调用""置换” 是一个匿名函数,可以理解为一段可以传递的代码 是JDK1.8的一个新特性 lamdba操作集合 Users u1=new Users...
  • lambda以前没太关注,直到前段时间写了个接口,数据处理逻辑本身稍有些繁琐,写了几个处理方法看着可读性差,用stream流与lamdba后简化了不少。在这梳理入门级应用场景,后续至少看的懂lambda。 特地到oracle官网看...
  • 这个版本包含语言、编译器、库、工具JVM等方面的十多个新特性。 1. Lambda表达式 1.1 何为Lamdba表达式 Lambda表达式理解为简洁地表示可传递的一种表达式:它没有名称,但有参数列表、函数主体、返回类型,可能...
  • (2)通过Stream和方法引用,你的代码将变得更直观 以下介绍三种简单的重构 重构代码,用lamdba表达式重构匿名类 用方法引用重构Lamdba表达式 用StreamApi重构命令式的数据处理 7.1.2 从匿名类到Lamdba表达式 ...
  • java.util.function其他的函数式接口 lamdba表达式 方法引用 流 Stream 1 什么是函数式接口 用@FunctionInterface注解的接口是函数式接口,那么不用@FunctionInterface注解的接口是不是函数式接口?什么...
  • JDK1.8,Java8常用新特性

    万次阅读 多人点赞 2018-09-17 10:43:24
    A.Lamdba表达式 1.Java8概述 Java8,也就是jdk1.8,是意义深远的一个新版本 是Java5之后一个大的版本升级,让Java语言库仿佛获得了新生 新特性包含: a.随着大数据的兴起,函数式编程在处理大数据上的优势...
  • Lambda表达式

    2019-03-11 14:52:12
    Lamdba通过表达式代替功能接口,它提供了一个正常的参数列表一个使用这些参数的主体(body,可以使一个表达式,也可以是代码块)。 Java8 se添加了2个对集合数据进行批量操作的包,Java.util.function包以及java....
  • Java8常用新特性

    2020-12-27 02:28:58
    一、Lamdba表达式 二、方法引用 三、Stream流 四、并行API Java8概述。Java8,也就是jdk7.8,是意义深远的一个新版本,是Java5之后一个大的版本升级,让Java语言库仿佛获得了新生。新版本包含: 随着...
  • Java 8 新特性

    2020-03-28 16:28:08
    Java 8 新特性一、 接口二、Lamdba表达式三、方法引用四、Stream五、日期时间 一、 接口 在java8 中,接口中引入了新的关键字defaultstatic,通过使用default修饰方法,可以让我们在接口中定义具体的方法实现,也...
  • 【JavaSE学习笔记】JDK1.8常用新特性

    万次阅读 多人点赞 2017-11-25 22:38:21
    A.Lamdba表达式 1.Java8概述 Java8,也就是jdk1.8,是意义深远的一个新版本 是Java5之后一个大的版本升级,让Java语言库仿佛获得了新生 新特性包含: a.随着大数据的兴起,函数式编程在处理大数据上的优势开始...

空空如也

空空如也

1 2
收藏数 31
精华内容 12
关键字:

lamdba和stream