- 外文名
- Lambda
- 编程语言
- 编程语言 创建表达式目录树类型
- 游 戏
- 半条命科幻第一人称射击电子游戏
- LaTeX表示
- \lambda
- 半条命的进化
- 半条命(1998~2020)
- 中文名
- 兰木达
- 网络释义
- IT专业英语词典-L等
- 流行符号
- 失意、无奈、孤独、低调等
- 希腊字母
- 是第十一个希腊字母
-
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:40package 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); }
}
-
关于Python中的lambda,这篇阅读量10万+的文章可能是你见过的最完整的讲解
2018-03-04 16:29:10lambda是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函数有如下特性:
-
lambda函数是匿名的:所谓匿名函数,通俗地说就是没有名字的函数。lambda函数没有名字。
-
lambda函数有输入和输出:输入是传入到参数列表argument_list的值,输出是根据表达式expression计算得到的值。
-
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函数的用法扩展为以下几种:
-
将lambda函数赋值给一个变量,通过这个变量间接调用该lambda函数。
例如,执行语句add=lambda x, y: x+y,定义了加法函数lambda x, y: x+y,并将其赋值给变量add,这样变量add便成为具有加法功能的函数。例如,执行add(1,2),输出为3。
-
将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),我们一起探讨高质量软件养成之道。
-
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集合进行排序。 -
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和普通的函数... -
死磕Lambda表达式(一):初识Lambda
2020-02-24 18:22:05Lambda表达式是表示可传递匿名函数的一种简洁方式,Lambda表达式没有名称,但是有参数列表、函数主体、返回类型,还可能有一个可以抛出的异常列表。 -
java8 手把手教你学会写lambda表达式
2017-04-16 14:24:31Java8其中一个很重要的新特性就是lambda表达式,允许我们将行为传到函数中。想想看,在Java8 之前我们想要将行为传入函数,仅有的选择就是匿名内部类。Java8发布以后,lambda表达式将大量替代匿名内部类的使用,... -
MyBatis-Plus | 最简单的查询操作教程(Lambda)
2018-09-12 00:36:52引言 上一篇:MyBatis-Plus | 最优雅最简洁地完成数据库操作 是对MyBatis-Plus的功能进行简单介绍,虽然是介绍,也让我们领略...官方表示,3.x支持Lambda表达式,那应该怎么使用呢?我们来看个例子: QueryWra... -
Lambda表达式
2020-03-28 16:04:29Lambda表达式、函数式接口、方法引用、构造器引用 -
深入理解Lambda
2016-03-10 17:18:43Lambda是一个表达式,也可以说它是一个匿名函数。然而在使用它或是阅读Lambda代码的时候,却显得并不那么容易。因为它匿名,因为它删减了一些必要的说明信息(比如方法名)。下面就来说说Lambda是如何进行转换和... -
死磕Lambda表达式(二):Lambda的使用
2020-02-24 18:24:45在哪使用Lambda表达式?怎么样正确的使用Lambda表达式? -
Java 8:一文掌握 Lambda 表达式
2019-10-23 20:20:30本文将介绍 Java 8 新增的 Lambda 表达式,包括 Lambda 表达式的常见用法以及方法引用的用法,并对 Lambda 表达式的原理进行分析,最后对 Lambda 表达式的优缺点进行一个总结。 -
C++11 之 lambda函数的详细使用
2018-07-03 22:38:421. lambda 函数概述 lambda 表达式是一种匿名函数,即没有函数名的函数;该匿名函数是由数学中的λ演算而来的。通常情况下,lambda函数的语法定义为: [capture] (parameters) mutable -&amp;amp;amp;... -
java8新特性—— Lambda表达式
2020-12-06 19:18:06Lambda表达式 用来替代匿名函数,可以将一个函数赋值给一个变量作为参数传入另一个函数,java的闭包 原则:可推导就是可省略,比如说参数类型,返回值 // 1. 不需要参数,返回值为 5 {}只有一行代码,可以省略 ()... -
lambda表达式详解
2019-07-18 18:20:40lambda介绍 匿名:没有一个确定的名称 函数:lambda不属于一个特定的类,但是却有参数列表、函数主体、返回类型、异常列表 传递:可以作为参数传递给方法、或者存储在变量中 简洁:不需要写很多模板代码 基本语法 ... -
死磕Lambda表达式(三):更简洁的Lambda
2020-02-24 18:26:16写出更简洁、更易懂的Lambda表达式。 -
lambda表达式
2019-03-04 14:36:46lambda表达式 lambda 表达式 创建一个匿名函数 格式 [捕获的变量](函数的参数) mutable ->ret_type {函数体}(调用的时候传参) [] 捕获的外部变量 [m] 捕获 m 值传递 且拷贝份不能修改 想修改 需要在... -
【Java8】 lambda 特性讲解
2019-11-20 20:15:45Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。使用 Lambda 表达式可以使代码变的更加简洁紧凑。跟Scala有点类似,因为 ... -
python lambda
2018-05-26 11:20:41编程中提到的 lambda 表达式,通常是在需要一个函数,但是又不想费神去命名一个函数的场合下使用,也就是指匿名函数。 add = lambda x,y : x + y print(add(1, 2)) list = [3, 5, -4, -1, 0, -2, -6] #用... -
Lambda架构
2018-07-11 21:15:04转载:...Marz在Twitter工作期间开发了著名的实时大数据处理框架Storm,Lambda架构是其根据多年进行分布式大数据系统的经验总结提炼而成。Lambda架构的目标是设...
-
项目经理成长之路
-
Liunx安装Nginx
-
Rust解决cargo build太慢
-
整合后的文件就叫可执行程序,windows后缀为.exe,Linux后缀为.out
-
光伏并网matlab仿真模型.zip
-
一天学完MySQL数据库
-
第二章 分支程序结构设计——作业-答案.html
-
牛之关系谱(DP)
-
【考研初试】安徽建筑大学501建筑设计考研真题库资料
-
linux ubuntu18.04 英伟达驱动 实测能装上 识别1080ti 1070ti显卡 NVIDIA-Linux-x86_64-460.39.run
-
MySQL 备份与恢复详解(高低版本 迁移;不同字符集 相互转换;表
-
java面试整理
-
工程制图 AutoCAD 2012 从二维到三维
-
FPGA进阶学习路线.pdf
-
只需要几秒 超强win10关闭自动更新工具.rar
-
139网站可用性测试报告.pdf
-
php获取mysql表中数据总数(总行数)
-
多少个电信号算一组?每个信号位有何意义?
-
NFS 实现高可用(DRBD + heartbeat)
-
espnetv2