Java编程中使用lambda表达式的奇技淫巧
为什么使用lambda表达式
先看几个例子:
第一个例子,在一个独立的线程中执行某项任务,我们通常这么实现:
class worker implements runnable { public void run() { for (int i = 0; i < 100; i++) dowork(); } ... } worker w = new worker(); new thread(w).start();
第二个例子,自定义字符串比较的方法(通过字符串长度),一般这么做:
class lengthcomparator implements comparator<string> { public int compare(string first, string second) { return integer.compare(first.length(), second.length()); } } arrays.sort(strings, new lengthcomparator());
第三个例子,在javafx中,给一个button添加一个callback:
button.setonaction(new eventhandler<actionevent>() { public void handle(actionevent event) { system.out.println("thanks for clicking!"); } });
这些例子有一个共同点,就是:先定义一段代码块,传给某个对象或方法,然后被执行。在lambda表
达式之前,java是不允许直接传递代码块的,因为java是面向对象的,因此必须传递一个对象,将要
执行的代码块封装到对象里。
lambda表达式的语法
将上面第二个例子中的lengthcomparator,用lambda表达式表示为:
(string first, string second) -> integer.compare(first.length(), second.length());
->前为参数列表,其后为表达式语句体;
如果表达式语句体不止一行,则将语句体写在{}中,与普通的函数一样:
(string first, string second) -> { if (first.length() > second.length()) { return 1; } else if (first.length() == second.length()) { return 0; } else { return -1; } };
如果没有参数,()还是需要带上,比如上面的第一个例子,可以表示为:
() -> { for (int i = 0; i < 1000; i ++) { dowork(); } }
如果参数的类型可以从上下文自动推断,则可以省略:
comparator<string> comp = (first, second) // same as (string first, string second) -> integer.compare(first.length(), second.length());
如果参数只有一个,且类型可以自动推断,则小括号()也可以省略:
// instead of (event) -> or (actionevent event) -> eventhandler<actionevent> listener = event -> system.out.println("thanks for clicking!");
lambda表达式的返回值的类型是自动推断的,因此不需要指明;在lambda表达式,某些条件分支中有
返回值,而其它分支没有返回值,是不允许的,如:
(x) -> { if (x >= 0) { return 1; } }
另外,expression lambda和statement lambda的区别是,expression lambda不需要
写return关键字,java runtime会将表达式的结果作为返回值返回,而statement lambda是
写在{}中的表达式,需要使用return关键字,比如:
// expression lambda comparator<string> comp1 = (first, second) -> integer.compare(first.length(), second.length()); // statement lambda comparator<string> comp2 = (first, second) -> { return integer.compare(first.length(), second.length());};
functional interface
如果一个接口(interface)仅有一个抽象方法(abstract method),就称为
functional interface,比如runnable、comparator等。
在任何一个需要functional interface对象的地方,都可以使用lambda表达式:
arrays.sort(words, (first, second) -> integer.compare(first.length(), second.length()));
这里,sort()的第二个参数需要的是一个comparator对象,而comparator是
functional interface,因此可以直接传入lambda表达式,在调用该对象的compare()方法
时,就是执行该lambda表达式中的语句体;
如果lambda表达式的语句体会抛出异常,则对应的functional interface中的抽象方法必须抛
出了该异常,否则就需要在lambda表达式中显式捕获异常:
runnable r = () -> { system.out.println("------"); try { thread.sleep(10); } catch (interruptedexception e) { // catch exception } }; callable<string> c = () -> { system.out.println("--------"); thread.sleep(10); return ""; };
method reference
如果将lambda表达式的参数作为参数传递给一个方法,他们的执行效果是相同的,则该lambda表达式
可以使用method reference表达,以下两种方式是等价的:
(x) -> system.out.println(x) system.out::println
其中system.out::println被称为method reference。
method reference主要有三种形式:
- object::instancemethod
- class::staticmethod
- class::instancemethod
对于前两种方式,对应的lambda表达式的参数和method的参数是一致的,比如:
system.out::println (x) -> system.out.println(x) math::pow (x, y) -> math.pow(x, y)
对于第三种方式,对应的lambda表达式的语句体中,第一个参数作为对象,调用method,将其它参数
作为method的参数,比如:
string::comparetoignorecase (s1, s2) -> s1.comparetoignorecase(s2) 1.5 constructor reference
constructor reference与method reference类似,只不过是特殊的method:new,具体调用的是哪个构造函数,由上下文环境决定,比如:
list<string> labels = ...; stream<button> stream = labels.stream().map(button::new);
button::new等价于(x) -> button(x),所以调用的构造函数是:button(x);
除了创建单个对象,也可以创建对象数组,如下面两种方式等价:
int[]::new (x) -> new int[x]
变量作用域
lambd表达式会捕获当前作用域下可用的变量,比如:
public void repeatmessage(string text, int count) { runnable r = () -> { for (int i = 0; i < count; i ++) { system.out.println(text); thread.yield(); } }; new thread(r).start(); }
但是这些变量必须是不可变的,为什么呢?看下面这个例子:
int matches = 0; for (path p : files) new thread(() -> { if (p has some property) matches++; }).start(); // illegal to mutate matches
因为可变的变量在lambda表达式中不是线程安全的,这和内部类的要求是一致的,内部类中只能引用
外部定义的final变量;
lambda表达式的作用域与嵌套代码块的作用域是一样的,所以在lambd表达式中的参数名或变量名不
能与局部变量冲突,如:
path first = paths.get("/usr/bin"); comparator<string> comp = (first, second) -> integer.compare(first.length(), second.length()); // error: variable first already defined
如果在lambda表达式中引用this变量,则引用的是创建该lambda表达式的方法的this变量,如:
public class application() { public void dowork() { runnable runner = () -> { ...; system.out.println(this.tostring()); ... }; } }
所以这里的this.tostring()调用的是application对象的tostring(),而不是runnable
对象的。
default method
接口中只能有抽象方法,如果在已有的接口中新增一个方法,则该接口所有的实现类都需要实现该方法。
java 8中引入了default method的概念,在接口中新增一个default方法,不会破坏已有的接
口规则,接口的实现类可以选择重写或直接继承该default方法,比如:
interface person { long getid(); default string getname() { return "john q. public"; } }
java是允许多继承的,如果一个类的父类中定义的方法和接口中定义的default方法完全相同,或者
一个类的两个接口中定义了完全相同的方法, 则如何处理这种冲突呢?处理规则如下:
如果是父类和接口的方法冲突:以父类中的方法为准,接口中的方法被忽略;
如果两个接口中的default方法冲突,则需要重写该方法解决冲突;
static method
java 8之前,接口中只能定义static变量,java 8开始,接口中可以添加static方法,比如
comparator接口新增了一系列comparingxxx的static方法,比如:
public static <t> comparator<t> comparingint(tointfunction<? super t> keyextractor) { objects.requirenonnull(keyextractor); return (comparator<t> & serializable) (c1, c2) -> integer.compare(keyextractor.applyasint(c1), keyextractor.applyasint(c2)); }
使用这个static方法,以下两种方式也是等价的:
1、
arrays.sort(cities, (first, second) -> integer.compare(first.length(), second.length()));
2、
arrays.sort(cities, comparator.comparingint(string::length));
所以,以后我们在设计自己的接口时,不需要再定义单独的工具类(如collections/collection),
在接口中使用static方法就行了。
匿名内部类
在 java 世界中,匿名内部类 可以实现在应用程序中可能只执行一次的操作。例如,在 android 应用程序中,一个按钮的点击事件处理。你不需要为了处理一个点击事件单独编写一个独立的类,可以用匿名内部类完成该操作:
button button = (button) findviewbyid(r.id.button1); button.setonclicklistener(new onclicklistener() { @override public void onclick(view view) { toast.maketext(mainactivity.this, "button clicked", toast.length_short).show(); } });lambda 示例
public void runnabletest() { system.out.println("=== runnabletest ==="); // 一个匿名的 runnable runnable r1 = new runnable() { @override public void run() { system.out.println("hello world one!"); } }; // lambda runnable runnable r2 = () -> system.out.println("hello world two!"); // 执行两个 run 函数 r1.run(); r2.run(); }
public void runnabletest() { system.out.println("=== runnabletest ==="); // 一个匿名的 runnable runnable r1 = new runnable() { @override public void run() { system.out.println("hello world one!"); } }; // lambda runnable runnable r2 = () -> system.out.println("hello world two!"); // 执行两个 run 函数 r1.run(); r2.run(); }
2.comparator lambda
public class person { private string givenname; private string surname; private int age; private gender gender; private string email; private string phone; private string address; }
public class person { private string givenname; private string surname; private int age; private gender gender; private string email; private string phone; private string address; }
public class comparatortest { public static void main(string[] args) { list<person> personlist = person.createshortlist(); // 使用内部类实现排序 collections.sort(personlist, new comparator<person>() { public int compare(person p1, person p2) { return p1.getsurname().compareto(p2.getsurname()); } }); system.out.println("=== sorted asc surname ==="); for (person p : personlist) { p.printname(); } // 使用 lambda 表达式实现 // 升序排列 system.out.println("=== sorted asc surname ==="); collections.sort(personlist, (person p1, person p2) -> p1.getsurname().compareto(p2.getsurname())); for (person p : personlist) { p.printname(); } // 降序排列 system.out.println("=== sorted desc surname ==="); collections.sort(personlist, (p1, p2) -> p2.getsurname().compareto(p1.getsurname())); for (person p : personlist) { p.printname(); } } }
public class comparatortest { public static void main(string[] args) { list<person> personlist = person.createshortlist(); // 使用内部类实现排序 collections.sort(personlist, new comparator<person>() { public int compare(person p1, person p2) { return p1.getsurname().compareto(p2.getsurname()); } }); system.out.println("=== sorted asc surname ==="); for (person p : personlist) { p.printname(); } // 使用 lambda 表达式实现 // 升序排列 system.out.println("=== sorted asc surname ==="); collections.sort(personlist, (person p1, person p2) -> p1.getsurname().compareto(p2.getsurname())); for (person p : personlist) { p.printname(); } // 降序排列 system.out.println("=== sorted desc surname ==="); collections.sort(personlist, (p1, p2) -> p2.getsurname().compareto(p1.getsurname())); for (person p : personlist) { p.printname(); } } }
上一篇: java 数据类型有哪些取值范围多少