JDK1.8新特性之Lambda表达式学习
什么是Lambda？
Lambda是一个匿名函数，即一个没有函数名的函数（简化了匿名委托的使用，让你的代码更加简洁）
匿名委托就是匿名内部类
下面举两个例子:
Thread thread = new Thread(new Runnable() {
@Override //这个就是一个匿名内部类
public void run() {
System.out.println("这是个Runable接口实例，用的是匿名内部类");
}
});
thread.start();//使用了7行代码调用了这个内部类
Thread thread2 = new Thread(()-> System.out.println("这是个Runable接口实例，用的是Lambda表达式"));
thread2.start();
//控制台结果：
//这是个Runable接口实例，用的是匿名内部类
//这是个Runable接口实例，用的是Lambda表达式 //现在有一组set集合，添加字符串进行排序
TreeSet treeSet = new TreeSet<>();//treeSet与普通set相比是根据首字母自动排序的
treeSet.add("a");
treeSet.add("dd");
treeSet.add("ccc");
treeSet.add("bbbb");
System.out.println(treeSet);//输出结果为[a, bbbb, ccc, dd]，此时是首字母排序
//现在我们需要按照字符串长度进行排序
TreeSet treeSet1 = new TreeSet<>(new Comparator() { //new Comparator为排序器
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(),o2.length());
}
});
treeSet1.add("a");
treeSet1.add("dd");
treeSet1.add("ccc");
treeSet1.add("bbbb");
System.out.println(treeSet1);//输出结果为[a, dd, ccc, bbbb]
//内部类又有很多，我们可以使用Lambda进行替换
TreeSet treeSet2 = new TreeSet<>((a, b) -> Integer.compare(a.length(),b.length()));
treeSet2.add("a");
treeSet2.add("dd");
treeSet2.add("ccc");
treeSet2.add("bbbb");
System.out.println(treeSet2);//输出结果仍然为[a, dd, ccc, bbbb]
我们发现Lambda表达式可以简化我们使用匿名内部类的使用，那么具体是如何使用呢？
package com.bruno_cheng.jdk;
import java.util.Comparator;
public class LambdaDemo2 {
public static void main(String[] args) {
//Lambda代码格式一：无参数，无返回值
//()->System.out.println("规范一");
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("这是个匿名内部类");
}
};
runnable = ()->System.out.println("这是个匿名内部类");
//语法格式二：有一个参数，并且无返回值
//(x) -> System.out.println("规范二");
//语法格式三：若只有一个参数，小括号可以省略不写
//x->System.out.println("规范三");
//语法规范四：有两个以上的参数，有返回值，并且Lambda体中有多条语句
Comparator comparator = new Comparator() {
@Override
public int compare(String o1, String o2) {
int i = Integer.compare(o1.length(),o2.length());
System.out.println("规范四");
return i;
}
};
comparator = (o1, o2) -> {
int i = Integer.compare(o1.length(),o2.length());
System.out.println("规范四");
return i;};
//语法规范五：Lambda语句只有一个执行体，return和大括号可以不写：
Comparator comparator2 = new Comparator() {
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(),o2.length());
}
};
comparator2 = (o1, o2) ->Integer.compare(o1.length(),o2.length());
//语法规范六：lambda表达式的参数列表的数据类型可以不写
// （JVM会通过上下文可以推断出数据类型，例如通过泛型就可以推断数据类型）
// Integer.compare(int a,int b); -->> Integer.compare(a,b);
}
}
```
通过上面的规范实例我们可以看出使用Lambda可以有效的简化代码。
下面通过一个简答的练习感受下：
- 1.定义一个接口：接收两个参数（两个参数类型一样的泛型），返回int
- 2.定义一个person类，3个属性name，age，score
现在要求:
- 1.实现接口，比较两个的age大小；
- 2.实现接口，比较两个的score大小；
- 3.使用内置的compare接口对数组排序；
接口：
package com.bruno_cheng.jdk.com.bruno_cheng;
public interface TestInterface{
//定义一个接口：接收两个参数（两个参数类型一样的泛型），返回int
int method( T t1,T t2);
} person类：
package com.bruno_cheng.jdk.com.bruno_cheng;
public class Person {
private String name;
private int age;
private int score;
//getter &setter
public void init(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
测试类：
package com.bruno_cheng.jdk.test;
import com.bruno_cheng.jdk.bruno_cheng.Person;
import com.bruno_cheng.jdk.bruno_cheng.TestInterface;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
public class Test {
public static void main(String[] args) {
List person = new ArrayList<>();
person.add(new Person("张三",18,100));
person.add(new Person("李四",19,90));
person.add(new Person("王五",19,95));
//- 1.实现接口，比较两个的age大小；
//不使用Lambda
TestInterface personTestInterface2 = new TestInterface() {
@Override
public int method(Person p1, Person p2) {
return Integer.compare(p1.getAge(),p2.getAge());
}
};
//使用Lambda后
TestInterface personTestInterface = (p1,p2) ->Integer.compare(p1.getAge(),p2.getAge());
//- 2.实现接口，比较两个的score大小；
personTestInterface = (p1,p2) ->Integer.compare(p1.getScore(),p2.getScore());
//此时我们可以发现，我们这里只需要该Lambda表达式右边的改动即可，不需想上面那样重复很多代码。
//- 3.使用内置的compare接口对分数排序；
// person.sort(new Comparator() {
// @Override
// public int compare(Person o1, Person o2) {
// return Integer.compare(o1.getScore(),o2.getScore());
// }
// });
System.out.println(person);
//[Person{name='李四', age=19, score=90}, Person{name='王五', age=19, score=95}, Person{name='张三', age=18, score=100}]
person.sort((Person o1, Person o2) ->Integer.compare(o1.getScore(),o2.getScore()));
System.out.println(person);
}
}
此时我们可以发现Lamda需要函数式接口：
什么是函数式接口？
函数式接口就是接口中只有一个抽象方法的的接口。可以使用注解@FunctionalInterface修饰可以检查是否是函数式接口
package com.bruno_cheng.jdk.bruno_cheng;
@FunctionalInterface //检查是否是函数式接口
public interface TestInterface{
//定义一个接口：接收两个参数（两个参数类型一样的泛型），返回int
int method( T t1,T t2);
}
JAVA内置的函数式接口
代码测试如下：
package com.bruno_cheng.jdk.test;
import com.bruno_cheng.jdk.bruno_cheng.Person;
import java.util.function.*;
/**
* 测试java内置函数式接口
*/
public class Test2 {
public static void main(String[] args) {
//1.在内部类实现,传入参数,返回boolean类型(Predicate)
//使用Predicate接口,,判断返回值类型判断某个person对象是否大于18岁
Predicate predicate = (p)->p.getAge()>18;
boolean b = predicate.test(new Person("张三",20,90));
System.out.println(b);//true
//2.在内部类实现,传入参数,没有返回值(Consumer)
//使用Consumer接口,传入一个字符串,>>打印<<字符串长度.
Consumer consumer = str -> System.out.println("\""+str+"\"的长度"+str.length());
consumer.accept("早上好啊");//"早上好啊"的长度4
//3.在内部类实现,传入参数,没有返回值(Function)
//使用Consumer接口,传入一个字符串,>>返回<<字符串长度.
Function function = s -> s.length();
Integer integer = function.apply("中午好");
System.out.println(integer);//3
//4.在内部类实现,不传入参数,有返回值(Supplier)
//使用Supplier接口,创建一个姓名等于张三,年龄18,分数80分的对象.
Supplier supplier = ()-> new Person("张三", 18, 80);
System.out.println(supplier.get()); //Person{name='张三', age=18, score=80}
//5.在内部类实现,传入一个参数,返回一个参数(UnaryOperator)
//使用UnaryOperator接口,传入一个字符串,返回全部转为大写的新字符串
UnaryOperator unaryOperator = (str) ->str.toUpperCase();
//UnaryOperator继承Function
System.out.println(unaryOperator.apply("abcd"));//ABCD
}
}
PS:这里就可以看出:函数式编程式对行为的封装。