写在前面的话：“在成功的道路上，活力是需要的，志向是可贵的，但更重要的是那毫无情趣的*乎*常的坚守的毅力和勇气。”你好，我是梦阳辰，未来我和你一起成长。
什么是Lambda表达式？
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。
Lambda允许把函数作为一个方法的参数（函数作为参数传递到方法中）。
为什么要使用Lambda表达式？
可以写出更简洁的，更灵活的代码。作为一种更紧凑的代码风格，是java的语言表达能力得到了提升。
对比：
import java.util.Comparator;
import java.util.TreeSet;
public class LambdaTest {
//原来的匿名内部类
public void test1(){
Comparator<Integer> com = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1,o2);
}
};
TreeSet<Integer> ts = new TreeSet<>(com);
}
//Lambda表达式
public void test2(){
Comparator<Integer> com = (x,y) ->Integer.compare(x,y);
TreeSet<Integer> ts = new TreeSet<>(com);
}
}
3.Lambda表达式的基础语法
Java8中引入了一个新的操作符“->"该操作符称为箭头操作符或Lambda操作符。
箭头操作符将Lambda表达式拆分为两个部分。
左侧：Lambda 表达式列表（接口中方法中的参数列表）。
右侧：表达式中所需执行的功能（接口中实现的代码）。
语法格式：
1.抽象方法，无参，无返回值
() -> System.out.println(“Hello Lambda”);
2.有一个参数，无返回值
(x) ->System.out.println(x);
public void test1(){
Consumer<String> con = (x) -> System.out.println(x);
con.accept("fda");
}
3.有一个参数，小括号可以省略不写。
4.有两个以上的参数，并且Lambda体中，有多条语句，有返回值。
Compatator com = (x,y) ->{
System.out.println(“函数式接口”);
return Integer.compare(x,y);
};
public void test2(){
Compatator<Integer> com = (x,y) ->{
System.out.println("函数式接口");
return Integer.compare(x,y);
};
}
5.有两个以上的参数，并且Lambda体中，只有一条语句，return和大括号都可以省略不写。
com = (x,y) -> Integer.compare(x,y);
6.Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器可以通过上下文推断。
lambda 表达式只能引用标记了 final 的外层局部变量（final可以省略），这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
Lambda表达式需要函数式接口的支持
函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。
使用注解@FunctionalInterface修饰，可以检查接口是否是函数式接口。
案例1：实现数据运算：
@FunctionalInterface
public interface Myfun {
public Integer getValue(Integer num);//抽象方法
}
public class Test {
public static void main(String[] args) {
Integer num= operation(100,x->x*x);//乘
Integer num2= operation(100,x->{
int result = x+900;return result;});//乘
System.out.println(num2);
}
/**
* 对数据进行操作
* @param num
* @param mf
* @return
*/
public static Integer operation(Integer num,Myfun mf){
return mf.getValue(num);
}
}
进阶练习：
1.调用Collections.sort()方法，通过定制排序比较两个Employee(先按年龄比，年龄相同
按姓名比)，使用Lambda作为参数传递。
import java.util.*;
public class Test {
public static void main(String[] args) {
List<Employee> list = Arrays.asList(
new Employee("MengYangChen",18,2000),
new Employee("Meng",21,1000),
new Employee("MenaYang",21,20000)
);
/* Comparator<Employee> a = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ;
}
}*/
/* Comparator<Employee> e = (x,y)->{
if(x.getAge()==y.getAge()){
return x.getName().compareTo(y.getName());
}
return Integer.compare(x.getAge(),y.getAge());};*/
Collections.sort(list,(x,y)->{
if(x.getAge()==y.getAge()){
return x.getName().compareTo(y.getName());
}
return Integer.compare(x.getAge(),y.getAge());});
Iterator<Employee> it = list.iterator();
while (it.hasNext()){
System.out.println(it.next().getName());
}
}
}
public class Employee {
private String name;
private int age;
private double salary;
public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
2.①声明函数式接口，接口中声明抽象方法，public String getValue(String str);
②声明类TestLambda ，类中编写方法使用接口作为参数，将一个字符串转换成大写，
并作为方法的返回值。
③再将一个字符串的第2个和第4个索引位置进行截取子串。
@FunctionalInterface
public interface Myfunction {
public String getValue(String str);
}
public class Test {
public static void main(String[] args) {
String upper = operate("abc",str->str.toUpperCase());
}
//对两个double类型数据进行操作
public static String operate (String str,Myfunction Myfun){
return Myfun.getValue(str);
}
}
3.①声明一个带两个泛型的函数式接口，泛型类型为<T,R>T为参数，R为返回值。
②接口中声明对应抽象方法
③在TestLambda类中声明方法，使用接口作为参数，计算两个long型参数的和。-
④再计算两个long型参数的乘积。-
package Chapters6.Lambda3;
public class Test {
public static void main(String[] args) {
operate(100,200,(x,y)->x+y);//加
operate(100,200,(x,y)->x*y);//乘
}
//对两个double类型数据进行操作
public static void operate (double a,double b,Myfunction<Double,Double> myfun){
System.out.println(myfun.getValue(a,b));
}
}
package Chapters6.Lambda3;
@FunctionalInterface
public interface Myfunction <T,R>{
public R getValue(T t1,T t2);
}
无论你正遭遇着什么，你都要从落魄中站起来重振旗鼓，要继续保持热忱，要继续保持微笑，就像从未受伤过一样。
