记Java8新特性的学习（一）---lambda表达式基本使用
一：Lamdba表达式使用及介绍：
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
格式：
(parameters) -> expression
或
(parameters) ->{ statements; }
以下是lambda表达式的重要特征:
- 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
- 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
- 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
- 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值
二：Lambda 表达式实例
2.1 参数说明
// 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)
2.2 接口参数Lamdba调用说明
package com.atguigu.lamdba;
/**
* 接口类
* 通过Lambda表达式可以便捷实现接口的具体实现
*/
public class Java8Tester {
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
public int operate(int a, int b, MathOperation mathOperation){
return mathOperation.operation(a, b);
}
}
public class Main {
public static void main(String args[]){
Java8Tester tester = new Java8Tester();
/**
* Lamdba表达式可以简便的实现接口作为函数
* 以下为接口的实现,使用Lamdba可以便捷声明接口的实现方法
*/
// 类型声明 算数+法
Java8Tester.MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明 算数-法
Java8Tester.MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句 算数*法 -标准写法 -当然我们有时为了简便 类型有时候很明显时可以省略
Java8Tester.MathOperation multiplication = (int a, int b) -> { return a * b; };
// 没有大括号及返回语句 算数/法
Java8Tester.MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 不用括号
Java8Tester.GreetingService greetService1 = message ->
System.out.println("Hello " + message);
// 用括号
Java8Tester.GreetingService greetService2 = (message) ->
System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");
greetService2.sayMessage("Google");
}
}
我们可以看到，通过接入Lamdba表达式，可以非常便捷的实现策略模式。做一事所需要的不同实现，可以很方便的展示。
下面是一个进阶的例子，对比lamdba使用前后内容
//原来的匿名内部类
@Test
public void test1(){
Comparator com = new Comparator(){
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(), o2.length());
}
};
TreeSet ts = new TreeSet<>(com);
TreeSet ts2 = new TreeSet<>(new Comparator(){
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(), o2.length());
}
});
}
//现在的 Lambda 表达式
@Test
public void test2(){
Comparator com = (x, y) -> Integer.compare(x.length(), y.length());
TreeSet ts = new TreeSet<>(com);
}
List emps = Arrays.asList(
new Employee(101, "张三", 18, 9999.99),
new Employee(102, "李四", 59, 6666.66),
new Employee(103, "王五", 28, 3333.33),
new Employee(104, "赵六", 8, 7777.77),
new Employee(105, "田七", 38, 5555.55)
);
//需求：获取公司中年龄小于 35 的员工信息
public List filterEmployeeAge(List emps){
List list = new ArrayList<>();
for (Employee emp : emps) {
if(emp.getAge() <= 35){
list.add(emp);
}
}
return list;
}
@Test
public void test3(){
List list = filterEmployeeAge(emps);
for (Employee employee : list) {
System.out.println(employee);
}
}
//需求：获取公司中工资大于 5000 的员工信息
public List filterEmployeeSalary(List emps){
List list = new ArrayList<>();
for (Employee emp : emps) {
if(emp.getSalary() >= 5000){
list.add(emp);
}
}
return list;
}
//优化方式一：策略设计模式
public List filterEmployee(List emps, MyPredicate mp){
List list = new ArrayList<>();
for (Employee employee : emps) {
if(mp.test(employee)){
list.add(employee);
}
}
return list;
}
@Test
public void test4(){
List list = filterEmployee(emps, new FilterEmployeeForAge());
for (Employee employee : list) {
System.out.println(employee);
}
System.out.println("------------------------------------------");
List list2 = filterEmployee(emps, new FilterEmployeeForSalary());
for (Employee employee : list2) {
System.out.println(employee);
}
}
//优化方式二：匿名内部类
@Test
public void test5(){
List list = filterEmployee(emps, new MyPredicate() {
@Override
public boolean test(Employee t) {
return t.getId() <= 103;
}
});
for (Employee employee : list) {
System.out.println(employee);
}
}
//优化方式三：Lambda 表达式
@Test
public void test6(){
List list = filterEmployee(emps, (e) -> e.getAge() <= 35);
list.forEach(System.out::println);
System.out.println("------------------------------------------");
List list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000);
list2.forEach(System.out::println);
}