Lambda 表达式
lambda 是jdk8 新增加的功能，若要使用lambda一定要使用jdk8的开发环境，lambda表达式是一个可传递的代码块，可以在以后执行一次或多次。
我们以前应该都用过匿名类，就像下例：
package lambda;
public class LambdaTest {
public static void main(String[] args) {
new Thread(new Thread(){
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("I am a Thread");
}
}).start();
}
}
输出结果：
I am a Thread下面是使用lambda表达式实现此功能的一个小例子。
package lambda;
public class LambdaTest {
public static void main(String[] args) {
new Thread(() ->{System.out.println("I am a Thread");}
).start();
}
}
输出结果：
I am a Thread例二：
package lambda;
public class LambdaTest {
public static void main(String[] args) {
Runnable t = () -> {System.out.println("I am a Thread");};
new Thread(t).start();
}
}输出结果：
I am a Threadlambda表达式形式：参数，箭头（->）以及一个代码块，通过上面的例子，我们可以看出，lambda表达式的代码块中的内容和Runnable接口中run方法里面执行的内容执行效果是相同的。
参数（）<=> run方法的参数（），对于那些只有一个抽象方法的接口来说，需要这种接口的对象时，我们完全可以使用lambda表达式来取代，这样的代码看起来更加的直观。
例三：使用抽象方法对象作为参数传入。
package lambda;
import java.util.Arrays;
import java.util.Comparator;
public class LambdaTest {
public static void main(String[] args) {
String[] planets = new String[]{"Mercury","venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
Arrays.sort(planets,LambdaTest.LengthCoparator.getInstence());
System.out.println(Arrays.toString(planets));
}
/*
* 新建内部类实现Comparator接口，实现排序方法
*/
static class LengthCoparator implements Comparator<String>{
private static LengthCoparator lc;
/**
* 使用字符串长度作为排序依据
*/
@Override
public int compare(String first, String second) {
// TODO Auto-generated method stub
return first.length() - second.length();
}
public static LengthCoparator getInstence(){
if(lc == null){
lc = new LengthCoparator();
}
return lc;
}
}
}输出结果：
[Mars, venus, Earth, Saturn, Uranus, Mercury, Jupiter, Neptune]使用lambda表达式实现：
package lambda;
import java.util.Arrays;
public class LambdaTest {
public static void main(String[] args) {
String[] planets = new String[]{"Mercury","venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
//此处可以省略参数类型，jvm可以检测出来
Arrays.sort(planets,(first,second)->{return first.length() - second.length();});
System.out.println(Arrays.toString(planets));
}
}输出结果：
[Mars, venus, Earth, Saturn, Uranus, Mercury, Jupiter, Neptune]例四：创建定时器的不同
package lambda;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;
import javax.swing.Timer;
public class LambdaTest {
public static void main(String[] args) {
Timer t = new Timer(1000,LambdaTest.Worker.getInstence());
while(true){
t.start();
}
}
/*
* 新建内部类实现Comparator接口，实现排序方法
*/
static class Worker implements ActionListener{
private static Worker lc;
@Override
public void actionPerformed(ActionEvent e) {
System.out.println(new Date());
}
public static Worker getInstence(){
if(lc == null){
lc = new Worker();
}
return lc;
}
}
}输出结果：
Fri May 11 15:57:32 CST 2018
Fri May 11 15:57:33 CST 2018
Fri May 11 15:57:34 CST 2018
Fri May 11 15:57:35 CST 2018
Fri May 11 15:57:36 CST 2018
Fri May 11 15:57:37 CST 2018
Fri May 11 15:57:38 CST 2018使用Lambda表达式创建：
package lambda;
import java.util.Date;
import javax.swing.Timer;
public class LambdaTest {
public static void main(String[] args) {
Timer t = new Timer(1000,ent ->{System.out.println(new Date());});
while(true){
t.start();
}
}
}输出结果：
Fri May 11 15:59:29 CST 2018
Fri May 11 15:59:30 CST 2018
Fri May 11 15:59:31 CST 2018
Fri May 11 15:59:32 CST 2018
Fri May 11 15:59:33 CST 2018
Fri May 11 15:59:34 CST 2018
Fri May 11 15:59:35 CST 2018
Fri May 11 15:59:36 CST 2018通过上面的例子，我们可以很明确的看出使用lambda表达式的优势，我就不再瞎说了。
使用lambda表达式的说明：
1、lambda表达式（”::”之前是类名，后面是方法名）。
- object::instanceMethod
- Class::staticMethod
- Class::instanceMethod
前两种情况：System.out::println 等价于 x-> System.out.println(x);或者Math::pow等价于(x,y) ->Math.pow(x,y);
对于第三种情况：第一个参数会成为方法的目标。例如String::commpareToIgnoreCase等价于(x,y)->x.compareToIgnoreCase(y);
2、在lambda表达式中使用this关键字，this指的是所在方法的实例对象，而不是该lambda表达式的接口的实例对象。
Timer t = new Timer(1000,ent ->{System.out.println(this);});该“this”指的是这段代码所在方法所属的实例对象，而不是actionPerformed方法所属的ActionListener接口对象。