lambda 订阅
希腊字母表中排序第十一位的字母,大写为Λ,英语名称为Lambda。 展开全文
希腊字母表中排序第十一位的字母,大写为Λ,英语名称为Lambda。
信息
外文名
Lambda
编程语言
编程语言 创建表达式目录树类型
游    戏
半条命科幻第一人称射击电子游戏
LaTeX表示
\lambda
半条命的进化
半条命(1998~2020)
中文名
兰木达
网络释义
IT专业英语词典-L等
流行符号
失意、无奈、孤独、低调等
希腊字母
是第十一个希腊字母
λ希腊字母
ΛLambda(大写Λ,小写λ)读音:lam (b) da(兰木达)['læmdə]是第十一个希腊字母大写Λ用于:粒子物理学上,Λ重子的符号小写λ用于:物理上的波长符号放射学的衰变常数线性代数中的特征值西里尔字母的 Л 是由 Lambda 演变而成代数中的康威常数【汽车】1.氧传感器的值0.1-0.95V⒉过量空气系数附录:希腊字母读音及科学方面应用
收起全文
精华内容
下载资源
问答
  • Lambda

    千次阅读 2019-10-21 12:46:57
    使用效果2.1 未使用 lambda 和 使用 lambda 的区别三. 基本语法四. 函数式接口 一. 简介 Lambda 是一个匿名函数,我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码 像数据一样进行传递)。可以写出更简洁...

    一. 简介

    Lambda 是一个匿名函数,我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码 像数据一样进行传递)。可以写出更简洁、更 灵活的代码。作为一种更紧凑的代码风格,使 Java的语言表达能力得到了提升.

    二. 使用效果

    2.1 未使用 lambda 和 使用 lambda 的区别

       /**
         * 未使用 lambda 表达式
         */
        @Test
        public void test01() {
    
            Comparator<Integer> comparator1 = new Comparator<Integer>() {
    
                @Override
                public int compare(Integer o1, Integer o2) {
    
                    return Integer.compare(o1,o2);
                }
            };
            TreeSet set = new TreeSet(comparator1);
    
    
        }
    
        /**
         * 使用 lambda 表达式
         */
        @Test
        public void test02() {
    
            // 使用 lambda
            Comparator<Integer> comparator = (o1,o2) -> Integer.compare(o1,o2);
            TreeSet set = new TreeSet(comparator);
    
        }
    
    

    三. 基本语法

    Lambda 表达式在Java 语言中引入了一个新的语法元 素和操作符。这个操作符为 “->” , 该操作符被称 为 Lambda 操作符或剪头操作符。它将 Lambda 分为 两个部分:
    左侧:指定了 Lambda 表达式需要的所有参数
    右侧:指定了 Lambda 体,即 Lambda 表达式要执行 的功能。

            // 语法格式一: 无参, 无返回值, lambda 体只需要执行一条语句
            Runnable runnable = () -> System.out.println("hello world");
    
            // 语法格式二: 有一个参数, 并且无返回值
            Consumer<String> consumer = (args) -> System.out.println(args);
    
            // 语法格式三: 只有一个参数时,参数的小括号可以省略
            Consumer<String> consumer2 = args -> System.out.println(args);
    
            // 语法格式四: lambda 需要两个参数,多行执行语句,并且有返回值
            Comparator<Integer> comparator = (a, b) -> {
                System.out.println("hello world");
                return Integer.compare(a, b);
            };
    
            // 语法格式五: lambda 需要两个参数,一条执行语句,并且有返回值
            Comparator<Integer> comparator2 = (a, b) -> Integer.compare(a, b);
    
            // 语法格式六: lambda 表达式的参数列表的数据类型可以省略不写,因为 jvm 编译器可以通过上下文推断出数据类型,即"类型推断"
            Comparator<Integer> comparator3 = (Integer a, Integer b) -> Integer.compare(a, b);
    
    

    四. 函数式接口

    只包含一个抽象方法的接口,称为函数式接口。
    你可以通过 Lambda 表达式来创建该接口的对象。(若 Lambda
    表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方
    法上进行声明)。
    我们可以在任意函数式接口上使用 @FunctionalInterface 注解,
    这样做可以检查它是否是一个函数式接口,同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口。
    Lambda 表达式需要"函数式接口"的支持
    一个抽象方法不会报错.
    在这里插入图片描述

    两个抽象方法编译报错.
    在这里插入图片描述

    展开全文
  • lambda

    千次阅读 2019-09-19 18:55:40
    package lambda; /** lambda表达式 JDK8之后推出的新特性 lambda旨在让我们可以"以函数式编程".直观感受是可以用更简洁的方式创建匿名内部类 语法: (参数列表)->{ 方法体 } 使用lambda创建的匿名内部类实现...

    package lambda;
    /**

    • lambda表达式 JDK8之后推出的新特性
    • lambda旨在让我们可以"以函数式编程".直观感受是可以用更简洁的方式创建匿名内部类
    • 语法:
    • (参数列表)->{
    •  方法体
      
    • }
    • 使用lambda创建的匿名内部类实现的接口只能有一个抽象方法
    • @author ChenYi
    • @date 2019.09.19
      /
      public class LambdaDemo {
      public static void main(String[] args) {
      Runnable r1=new Runnable() {
      public void run() {
      System.out.println(“hello”);
      }
      };
      /

      * 编译器最终会把lambda改为内部类的方式
      * 编译器会自动根据程序上下文分析出lambda创建时实现的是哪个接口
      /
      Runnable r2=()->{
      System.out.println(“hi”);
      };
      /

      * 如果方法中只有一句代码,那么方法体的"{}"可以省略
      */
      Runnable r3=()->System.out.println(“goodbye”);
      Thread t1=new Thread(r1);
      t1.start();
      Thread t2=new Thread(r2);
      t2.start();
      Thread t3=new Thread(r3);
      t3.start();
      }
      }

    package lambda;

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    /**

    • 有参方法的lambda
    • @author ChenYi
    • @date 2019.09.19
      */
      public class LambdaDemo2 {
      public static void main(String[] args) {
      List list=new ArrayList();
      list.add(“马化腾”);
      list.add(“马云”);
      list.add(“比尔盖茨”);
      System.out.println(list);
      // Comparator c=new Comparator() {
      // public int compare(String o1, String o2) {
      // return o1.length()-o2.length();
      // }
      // };

    // Comparator c=(o1,o2)->{
    // return o1.length()-o2.length();
    // };

    	/*
    	 * 当方法有返回值时,如果可以省略"{}"那么此时也要连同省略return关键字
    	 */
    	Comparator<String> c=(o1,o2)-> o1.length()-o2.length();
    

    // Collections.sort(list,(o1,o2)-> o1.length()-o2.length());

    	Collections.sort(list,c);
    	System.out.println(list);
    }
    

    }

    展开全文
  • lambda是Python编程语言中使用频率较高的一个关键字。那么,什么是lambda?它有哪些用法?网上的文章汗牛充栋,可是把这个讲透的文章却不多。这里,我们通过阅读各方资料,总结了关于Python中的lambda的“一个语法,...

    lambda是Python编程语言中使用频率较高的一个关键字。那么,什么是lambda?它有哪些用法?网上的文章汗牛充栋,可是把这个讲透的文章却不多。这里,我们通过阅读各方资料,总结了关于Python中的lambda的“一个语法,三个特性,四个用法,一个争论”。欢迎阅读和沟通(个人微信: fibona007)。

    由于文章是从我的公众号上复制过来的,因此排版不整齐,但是内容绝对充实,欢迎关注公众号[测试不将就],阅读原文

    一个语法

    在Python中,lambda的语法是唯一的。其形式如下:

     lambda argument_list: expression

    其中,lambda是Python预留的关键字,argument_list和expression由用户自定义。具体介绍如下。

    1. 这里的argument_list是参数列表,它的结构与Python中函数(function)的参数列表是一样的。具体来说,argument_list可以有非常多的形式。例如:

    • a, b
    • a=1, b=2
    •  *args
    •  **kwargs
    •  a, b=1, *args
    • ......

    2. 这里的expression是一个关于参数的表达式。表达式中出现的参数需要在argument_list中有定义,并且表达式只能是单行的。以下都是合法的表达式:

    • 1
    •  None
    • a + b
    • sum(a)
    • 1 if a >10 else 0
    •  ......

    3.  这里的lambda argument_list: expression表示的是一个函数。这个函数叫做lambda函数。

     

    三个特性

    lambda函数有如下特性:

    1. lambda函数是匿名的:所谓匿名函数,通俗地说就是没有名字的函数。lambda函数没有名字。

    2. lambda函数有输入和输出:输入是传入到参数列表argument_list的值,输出是根据表达式expression计算得到的值。

    3. lambda函数一般功能简单:单行expression决定了lambda函数不可能完成复杂的逻辑,只能完成非常简单的功能。由于其实现的功能一目了然,甚至不需要专门的名字来说明。

    下面是一些lambda函数示例:

    •       lambda x, y: x*y;函数输入是x和y,输出是它们的积x*y
    •      lambda:None;函数没有输入参数,输出是None
    •      lambda *args: sum(args); 输入是任意个数的参数,输出是它们的和(隐性要求是输入参数必须能够进行加法运算)
    •      lambda **kwargs: 1;输入是任意键值对参数,输出是1

     

    四个用法

     

    由于lambda语法是固定的,其本质上只有一种用法,那就是定义一个lambda函数。在实际中,根据这个lambda函数应用场景的不同,可以将lambda函数的用法扩展为以下几种:

    1. 将lambda函数赋值给一个变量,通过这个变量间接调用该lambda函数

      例如,执行语句add=lambda x, y: x+y,定义了加法函数lambda x, y: x+y,并将其赋值给变量add,这样变量add便成为具有加法功能的函数。例如,执行add(1,2),输出为3。

    2. 将lambda函数赋值给其他函数,从而将其他函数用该lambda函数替换

    例如,为了把标准库time中的函数sleep的功能屏蔽(Mock),我们可以在程序初始化时调用:time.sleep=lambda x:None。这样,在后续代码中调用time库的sleep函数将不会执行原有的功能。例如,执行time.sleep(3)时,程序不会休眠3秒钟,而是什么都不做。

          3. 将lambda函数作为其他函数的返回值,返回给调用者。

    函数的返回值也可以是函数。例如return lambda x, y: x+y返回一个加法函数。这时,lambda函数实际上是定义在某个函数内部的函数,称之为嵌套函数,或者内部函数。对应的,将包含嵌套函数的函数称之为外部函数。内部函数能够访问外部函数的局部变量,这个特性是闭包(Closure)编程的基础,在这里我们不展开。

          4. 将lambda函数作为参数传递给其他函数

    部分Python内置函数接收函数作为参数。典型的此类内置函数有这些。

    • filter函数。此时lambda函数用于指定过滤列表元素的条件。例如filter(lambda x: x % 3 == 0, [1, 2, 3])指定将列表[1,2,3]中能够被3整除的元素过滤出来,其结果是[3]。

    • sorted函数。此时lambda函数用于指定对列表中所有元素进行排序的准则。例如sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]按照元素与5距离从小到大进行排序,其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]。

    • map函数。此时lambda函数用于指定对列表中每一个元素的共同操作。例如map(lambda x: x+1, [1, 2,3])将列表[1, 2, 3]中的元素分别加1,其结果[2, 3, 4]。

    • reduce函数。此时lambda函数用于指定列表中两两相邻元素的结合条件。例如reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])将列表 [1, 2, 3, 4, 5, 6, 7, 8, 9]中的元素从左往右两两以逗号分隔的字符的形式依次结合起来,其结果是'1, 2, 3, 4, 5, 6, 7, 8, 9'。

    另外,部分Python库函数也接收函数作为参数,例如gevent的spawn函数。此时,lambda函数也能够作为参数传入。

     

    一个争议

    事实上,关于lambda在Python社区是存在争议的。Python程序员对于到底要不要使用lambda意见不一致。

    • 支持方认为使用lambda编写的代码更紧凑,更“pythonic”。

    • 反对方认为,lambda函数能够支持的功能十分有限,其不支持多分支程序if...elif...else...和异常处理程序try ...except...。并且,lambda函数的功能被隐藏,对于编写代码之外的人员来说,理解lambda代码需要耗费一定的理解成本。他们认为,使用for循环等来替代lambda是一种更加直白的编码风格。

    关于lambda的争执没有定论。在实际中,是否使用lambda编程取决于程序员的个人喜好。

    以上就是我们总结的关于Python中的lambda的“一个语法,三个特性,四个用法,一个争论”。如有纰漏之处,欢迎批评指正。

     

    作者:软件工程专家/全栈测试开发/技术写作者,欢迎添加作者微信(fibona007)交流。欢迎微信关注个人公号"测试不将就"(ID: awesometest),我们一起探讨高质量软件养成之道。

     
     
     
     
     
     
     
    展开全文
  • public class LambdaShow { public delegate void NoReturnNoPara();//无参数无返回值委托 public delegate void NoReturnWithPara(string x
  • Java Lambda表达式入门

    万次阅读 多人点赞 2014-04-27 21:17:58
    原文链接:Start Using Java Lambda Expressions 下载示例程序 Examples.zip 。 原文日期: 2014年4月16日 翻译日期: 2014年4月27日 翻译人员: 铁锚 简介 (译者认为: 超过3行的逻辑就不适用Lambda表达式了。虽然看着...

    原文链接: Start Using Java Lambda Expressions

    下载示例程序 Examples.zip
    原文日期: 2014年4月16日

    翻译日期: 2014年4月27日
    翻译人员: 铁锚
    简介

    (译者认为: 超过3行的逻辑就不适用Lambda表达式了。虽然看着很先进,其实Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。本人建议不要乱用,因为这就和某些很高级的黑客写的代码一样,简洁,难懂,难以调试,维护人员想骂娘.)
    Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
    Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及 java.util.stream 包。 流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。 在本文中,我们将从简单到复杂的示例中见认识lambda表达式和stream的强悍。
    环境准备
    如果还没有安装Java 8,那么你应该先安装才能使用lambda和stream(译者建议在虚拟机中安装,测试使用)。 像NetBeans 和IntelliJ IDEA 一类的工具和IDE就支持Java 8特性,包括lambda表达式,可重复的注解,紧凑的概要文件和其他特性。
    下面是Java SE 8和NetBeans IDE 8的下载链接:
    Java Platform (JDK 8): 从Oracle下载Java 8,也可以和NetBeans IDE一起下载
    NetBeans IDE 8: 从NetBeans官网下载NetBeans IDE
    Lambda表达式的语法
    基本语法:
    (parameters) -> expression

    (parameters) ->{ statements; }

    下面是Java lambda表达式的简单例子:

    // 1. 不需要参数,返回值为 5
    () -> 5
    
    // 2. 接收一个参数(数字类型),返回其2倍的值
    x -> 2 * x
    
    // 3. 接受2个参数(数字),并返回他们的差值
    (x, y) -> x – y
    
    // 4. 接收2个int型整数,返回他们的和
    (int x, int y) -> x + y
    
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
    (String s) -> System.out.print(s)

    基本的Lambda例子
    现在,我们已经知道什么是lambda表达式,让我们先从一些基本的例子开始。 在本节中,我们将看到lambda表达式如何影响我们编码的方式。 假设有一个玩家List ,程序员可以使用 for 语句 ("for 循环")来遍历,在Java SE 8中可以转换为另一种形式:

     

    String[] atp = {"Rafael Nadal", "Novak Djokovic",
           "Stanislas Wawrinka",
           "David Ferrer","Roger Federer",
           "Andy Murray","Tomas Berdych",
           "Juan Martin Del Potro"};
    List<String> players =  Arrays.asList(atp);
    
    // 以前的循环方式
    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);

    正如您看到的,lambda表达式可以将我们的代码缩减到一行。 另一个例子是在图形用户界面程序中,匿名类可以使用lambda表达式来代替。 同样,在实现Runnable接口时也可以这样使用:

     

    // 使用匿名内部类
    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!"));
    

    下面是使用lambdas 来实现 Runnable接口 的示例:

     

    // 1.1使用匿名内部类
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("Hello world !");
        }
    }).start();
    
    // 1.2使用 lambda expression
    new Thread(() -> System.out.println("Hello world !")).start();
    
    // 2.1使用匿名内部类
    Runnable race1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("Hello world !");
        }
    };
    
    // 2.2使用 lambda expression
    Runnable race2 = () -> System.out.println("Hello world !");
     
    // 直接调用 run 方法(没开新线程哦!)
    race1.run();
    race2.run();


    Runnable 的 lambda表达式,使用块格式,将五行代码转换成单行语句。 接下来,在下一节中我们将使用lambdas对集合进行排序。
    使用Lambdas排序集合
    在Java中,Comparator 类被用来排序集合。 在下面的例子中,我们将根据球员的 name, surname, name 长度 以及最后一个字母。 和前面的示例一样,先使用匿名内部类来排序,然后再使用lambda表达式精简我们的代码。
    在第一个例子中,我们将根据name来排序list。 使用旧的方式,代码如下所示:

     

    String[] players = {"Rafael Nadal", "Novak Djokovic", 
        "Stanislas Wawrinka", "David Ferrer",
        "Roger Federer", "Andy Murray",
        "Tomas Berdych", "Juan Martin Del Potro",
        "Richard Gasquet", "John Isner"};
     
    // 1.1 使用匿名内部类根据 name 排序 players
    Arrays.sort(players, new Comparator<String>() {
        @Override
        public int compare(String s1, String s2) {
            return (s1.compareTo(s2));
        }
    });

    使用lambdas,可以通过下面的代码实现同样的功能:

     

    // 1.2 使用 lambda expression 排序 players
    Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));
    Arrays.sort(players, sortByName);
    
    // 1.3 也可以采用如下形式:
    Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));


    其他的排序如下所示。 和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :

     

    // 1.1 使用匿名内部类根据 surname 排序 players
    Arrays.sort(players, new Comparator<String>() {
        @Override
        public int compare(String s1, String s2) {
            return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" "))));
        }
    });
    
    // 1.2 使用 lambda expression 排序,根据 surname
    Comparator<String> sortBySurname = (String s1, String s2) -> 
        ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) );
    Arrays.sort(players, sortBySurname);
    
    // 1.3 或者这样,怀疑原作者是不是想错了,括号好多...
    Arrays.sort(players, (String s1, String s2) -> 
          ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) ) 
        );
    
    // 2.1 使用匿名内部类根据 name lenght 排序 players
    Arrays.sort(players, new Comparator<String>() {
        @Override
        public int compare(String s1, String s2) {
            return (s1.length() - s2.length());
        }
    });
    
    // 2.2 使用 lambda expression 排序,根据 name lenght
    Comparator<String> sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length());
    Arrays.sort(players, sortByNameLenght);
    
    // 2.3 or this
    Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length()));
    
    // 3.1 使用匿名内部类排序 players, 根据最后一个字母
    Arrays.sort(players, new Comparator<String>() {
        @Override
        public int compare(String s1, String s2) {
            return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
        }
    });
    
    // 3.2 使用 lambda expression 排序,根据最后一个字母
    Comparator<String> sortByLastLetter = 
        (String s1, String s2) -> 
            (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
    Arrays.sort(players, sortByLastLetter);
    
    // 3.3 or this
    Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));
    

    就是这样,简洁又直观。 在下一节中我们将探索更多lambdas的能力,并将其与 stream 结合起来使用。
    使用Lambdas和Streams
    Stream是对集合的包装,通常和lambda一起使用。 使用lambdas可以支持许多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等等。 同样,Stream使用懒运算,他们并不会真正地读取所有数据,遇到像getFirst() 这样的方法就会结束链式语法。 在接下来的例子中,我们将探索lambdas和streams 能做什么。 我们创建了一个Person类并使用这个类来添加一些数据到list中,将用于进一步流操作。 Person 只是一个简单的POJO类:

     

    public class Person {
    
    private String firstName, lastName, job, gender;
    private int salary, age;
    
    public Person(String firstName, String lastName, String job,
                    String gender, int age, int salary)       {
              this.firstName = firstName;
              this.lastName = lastName;
              this.gender = gender;
              this.age = age;
              this.job = job;
              this.salary = salary;
    }
    // Getter and Setter 
    // . . . . .
    }

    接下来,我们将创建两个list,都用来存放Person对象:

     

    List<Person> javaProgrammers = new ArrayList<Person>() {
      {
        add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));
        add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));
        add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));
        add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));
        add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));
        add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));
        add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));
        add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));
        add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));
        add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));
      }
    };
    
    List<Person> phpProgrammers = new ArrayList<Person>() {
      {
        add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));
        add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));
        add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600));
        add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));
        add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100));
        add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));
        add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));
        add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));
        add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600));
        add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800));
      }
    };

    现在我们使用forEach方法来迭代输出上述列表:

     

    System.out.println("所有程序员的姓名:");
    javaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
    phpProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

    我们同样使用forEach方法,增加程序员的工资5%:

     

    System.out.println("给程序员加薪 5% :");
    Consumer<Person> giveRaise = e -> e.setSalary(e.getSalary() / 100 * 5 + e.getSalary());
    
    javaProgrammers.forEach(giveRaise);
    phpProgrammers.forEach(giveRaise);

    另一个有用的方法是过滤器filter() ,让我们显示月薪超过1400美元的PHP程序员:

     

    System.out.println("下面是月薪超过 $1,400 的PHP程序员:")
    phpProgrammers.stream()
              .filter((p) -> (p.getSalary() > 1400))
              .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

    我们也可以定义过滤器,然后重用它们来执行其他操作:

     

    // 定义 filters
    Predicate<Person> ageFilter = (p) -> (p.getAge() > 25);
    Predicate<Person> salaryFilter = (p) -> (p.getSalary() > 1400);
    Predicate<Person> genderFilter = (p) -> ("female".equals(p.getGender()));
    
    System.out.println("下面是年龄大于 24岁且月薪在$1,400以上的女PHP程序员:");
    phpProgrammers.stream()
              .filter(ageFilter)
              .filter(salaryFilter)
              .filter(genderFilter)
              .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
    
    // 重用filters
    System.out.println("年龄大于 24岁的女性 Java programmers:");
    javaProgrammers.stream()
              .filter(ageFilter)
              .filter(genderFilter)
              .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
    

    使用limit方法,可以限制结果集的个数:

     

    System.out.println("最前面的3个 Java programmers:");
    javaProgrammers.stream()
              .limit(3)
              .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
    
    
    System.out.println("最前面的3个女性 Java programmers:");
    javaProgrammers.stream()
              .filter(genderFilter)
              .limit(3)
              .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

    排序呢? 我们在stream中能处理吗? 答案是肯定的。 在下面的例子中,我们将根据名字和薪水排序Java程序员,放到一个list中,然后显示列表:

    // 静态引入

    import static java.util.stream.Collectors.toList;

     

    System.out.println("根据 name 排序,并显示前5个 Java programmers:");
    List<Person> sortedJavaProgrammers = javaProgrammers
              .stream()
              .sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName())))
              .limit(5)
              .collect(toList());
    
    sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));
     
    System.out.println("根据 salary 排序 Java programmers:");
    sortedJavaProgrammers = javaProgrammers
              .stream()
              .sorted( (p, p2) -> (p.getSalary() - p2.getSalary()) )
              .collect( toList() );
    
    sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));

    如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个 更快的是min和max方法:

     

    System.out.println("工资最低的 Java programmer:");
    Person pers = javaProgrammers
              .stream()
              .min((p1, p2) -> (p1.getSalary() - p2.getSalary()))
              .get()
    
    System.out.printf("Name: %s %s; Salary: $%,d.", pers.getFirstName(), pers.getLastName(), pers.getSalary())
    
    System.out.println("工资最高的 Java programmer:");
    Person person = javaProgrammers
              .stream()
              .max((p, p2) -> (p.getSalary() - p2.getSalary()))
              .get()
    
    System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary())

    上面的例子中我们已经看到 collect 方法是如何工作的。 结合 map 方法,我们可以使用 collect 方法来将我们的结果集放到一个字符串,一个 Set 或一个TreeSet中:

     

    System.out.println("将 PHP programmers 的 first name 拼接成字符串:");
    String phpDevelopers = phpProgrammers
              .stream()
              .map(Person::getFirstName)
              .collect(joining(" ; ")); // 在进一步的操作中可以作为标记(token)   
    
    System.out.println("将 Java programmers 的 first name 存放到 Set:");
    Set<String> javaDevFirstName = javaProgrammers
              .stream()
              .map(Person::getFirstName)
              .collect(toSet());
    
    System.out.println("将 Java programmers 的 first name 存放到 TreeSet:");
    TreeSet<String> javaDevLastName = javaProgrammers
              .stream()
              .map(Person::getLastName)
              .collect(toCollection(TreeSet::new));
    

    Streams 还可以是并行的(parallel)。 示例如下:

     

    System.out.println("计算付给 Java programmers 的所有money:");
    int totalSalary = javaProgrammers
              .parallelStream()
              .mapToInt(p -> p.getSalary())
              .sum();

    我们可以使用summaryStatistics方法获得stream 中元素的各种汇总数据。 接下来,我们可以访问这些方法,比如getMax, getMin, getSum或getAverage:

     

    //计算 count, min, max, sum, and average for numbers
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    IntSummaryStatistics stats = numbers
              .stream()
              .mapToInt((x) -> x)
              .summaryStatistics();
    
    System.out.println("List中最大的数字 : " + stats.getMax());
    System.out.println("List中最小的数字 : " + stats.getMin());
    System.out.println("所有数字的总和   : " + stats.getSum());
    System.out.println("所有数字的平均值 : " + stats.getAverage()); 

    OK,就这样,希望你喜欢它!
    总结
    在本文中,我们学会了使用lambda表达式的不同方式,从基本的示例,到使用lambdas和streams的复杂示例。 此外,我们还学习了如何使用lambda表达式与Comparator 类来对Java集合进行排序。

    展开全文
  • 我们在使用 Java8 lambda 表达式的时候常常会遇到这样的编译报错 Variable used in lambda expression should be final or effectively final
  • java8的lambda表达式提供了一些方便list操作的方法,主要涵盖分组、过滤、求和、最值、排序、去重。跟之前的传统写法对比,能少写不少代码。 新建实体类 package com.vvvtimes.vo; import java.math.BigDecimal;...
  • python中lambda的用法

    万次阅读 多人点赞 2016-03-25 11:25:18
    一、lambda函数也叫匿名函数,即,函数没有具体的名称。先来看一个最简单例子: def f(x): return x**2 print f(4) Python中使用lambda的话,写成这样 g = lambda x : x**2 print g(4) 二、lambda和普通的函数...
  • Python中的lambda函数

    万次阅读 多人点赞 2019-03-30 19:41:51
    Python中的lambda函数 在Python中,我们使用lambda关键字来声明一个匿名函数,这就是为什么我们将它们称为“lambda函数”。匿名函数是指没有声明函数名称的函数。尽管它们在语法上看起来不同,lambda函数的行为方式...
  • Python 之 lambda 函数完整详解 & 巧妙运用

    万次阅读 多人点赞 2019-04-01 20:40:29
    lambda 函数在 Python 编程语言中使用频率非常高,那么,什么是lambda?它有哪些用法? 本文参考: https://blog.csdn.net/zjuxsl/article/details/79437563 这里总结了关于 Python 中的 lambda 函数的“一个语法,...
  • MyBatis-Plus | 最简单的查询操作教程(Lambda

    万次阅读 多人点赞 2018-09-12 00:36:52
    引言 上一篇:MyBatis-Plus | 最优雅最简洁地完成数据库操作 是对MyBatis-Plus的功能进行简单介绍,虽然是介绍,也让我们领略...官方表示,3.x支持Lambda表达式,那应该怎么使用呢?我们来看个例子: QueryWra...
  • lambda表达式

    2018-10-22 13:18:37
    Lambda 表达式”(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个匿名函数,即没有函数名的函数。Lambda表达式可以表示闭包(注意...
  • 死磕Lambda表达式(一):初识Lambda

    万次阅读 多人点赞 2020-02-24 18:22:05
    Lambda表达式是表示可传递匿名函数的一种简洁方式,Lambda表达式没有名称,但是有参数列表、函数主体、返回类型,还可能有一个可以抛出的异常列表。
  • Lambda_lambda_visualc_源码

    2021-10-03 13:29:20
    C# lambda expression manual for Visual C#
  • lambda 函数 AWS Lambda 函数
  • Lambda示例 要构建Lambda,“包描述符”“ template.yaml”是必需的。 请记住,在JVM离开实例之前,实现“ RequestStreamHandler”的类将是“ Singleton”(杀死)。 AWSTemplateFormatVersion : 2010-09-09 ...
  • 死磕Lambda表达式(四):常用的函数式接口

    万次阅读 多人点赞 2020-03-05 08:26:53
    在Java8支持Lambda表达式以后,为了满足Lambda表达式的一些典型使用场景,JDK为我们提供了大量常用的函数式接口。它们主要在 java.util.function 包中,下面简单介绍几个其中的接口及其使用示例。
  • aws-lambda-list:希望有用的AWS lambda和与lambda相关的资源的列表
  • python lambda表达式

    2021-01-20 02:25:38
    lambda 表达式的语法格式为: lambda [parameter_list] : 表达式 根据其语法格式可以得到lambda 表达式的两个要点: 1、lambda 表达式必须使用 lambda 关键字定义。 2、在 lambda 关键字之后、冒号左边为参数列表,...
  • JAVA 8 Lambda表达式-Lambda Expressions.rar
  • Lambda-Final:AWS Lambda示例
  • lambda:为AWS Lambda和Clojure构建工具
  • sqs-to-lambda-via-lambda, 向Lambda函数交付SQS队列项( 使用 Lambda ) 到 Lambda ( 通过 Lambda )当前没有用于Lambda的本机SQS事件源。 这种情况很糟糕。你可以运行类似于但是需要运行一个实例,谁想这样做。?运行...
  • lambda 示例 Java 8 lambda 实验

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 481,316
精华内容 192,526
关键字:

lambda