java-Lambda表达式

Lambda表达式是JDK8开始新增的一种语法形式；它的作用是用于简化匿名内部类的代码写法，可推导，则可简化。但只能简化函数式接口的匿名内部类

Lambda的操作符“->”,该操作符被称为Lambda操作符或箭头操作符，将Lambda分为2部分：

• 左侧：指定了Lambda表达式需要的参数列表
• 右侧指定了Lambda体，是抽象方法的实现逻辑，也即Lambda表达式要执行的功能

注意: Lambda表达式只能简化函数式接口的匿名内部类

Lambda书写格式
(被重写方法的形参列表) -> {     
	被重写方法的方法体代码。
}
举例：
Inter inter = （int a,int b,String s） -> {
	System.out.println("重写方法")
}

什么是函数式接口？

• 接口的实现类只需要重写一个抽象方法，那么此接口是函数式接口
• Object类中的方法作为抽象方法，那么实现类可以不重写
• 注意：将来我们见到的大部分函数式接口，上面都可能会有一个@FunctionalInterface的注解，有该注解的接口就必定是函数式接口。

//函数式接口
//@FunctionalInterface --->校验一个接口是否属于函数式接口
package com.Lambda.Lambda;
@FunctionalInterface
public interface Lambda_Test {
    public abstract void method();
  	//Object类中的方法作为抽象方法，那么实现类可以不重写
  	public abstract String toString();
}

下面举个例子

如果我们写一个匿名内部类来实现功能，那么写法为：

public class Lambda_Test {
    public static void main(String[] args) {
        new out() {
            @Override
            public void ring() {
                System.out.println("小明去唱歌了");
            }
        };
    }
}
//函数式接口
@FunctionalInterface
public interface out {
    public void ring();
}

我们可以用lambda表达式来进行简化

public class Lambda_Test {
    public static void main(String[] args) {
        out a = ()->{
            System.out.println("小明在唱歌");
        };
        a.ring();
    }
}

//函数式接口
@FunctionalInterface
public interface out {
    public void ring();
}

Lambda的省略规则：

• 参数类型可以省略不写。

• 如果只有一个参数，参数类型可以省略，同时()也可以省略。

• 如果Lambda表达式中的方法体代码只有一行代码，可以省略大括号不写，同时要省略分号！此时，如果这行代码是return语句，return也要省略不写，如果三者同时存在，必须全部省略。

public class Lambda_Test {
    public static void main(String[] args) {
       out a = ()-> System.out.println("小明去唱歌了");
       a.ring();
    }
}
interface out {
    public void ring();
}

方法引用

静态方法的引用:类名::静态方法。

使用场景:如果某个Lambda表达式里只是调用一个静态方法，并且前后参数的形式一致，就可以使用静态方法引用。

举例：对某对象数组进行升序操作

public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("杨幂", 25, 176);
        students[1] = new Student("张晓明", 35, 152);
        students[2] = new Student("朱茵", 21, 167);
        students[3] = new Student("杨幂", 34, 182);
          //升序
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });

使用Lambda表达式来进行操作

Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());

使用静态方法来简化Lambda表达式

Arrays.sort(students,Compare::CompareAge);
//静态方法
class Compare {
    public static int CompareAge(Student o1, Student o2) {
        //升序排序
        return o1.getAge() - o2.getAge();
    }
}

实例方法的引用:对象名::实例方法。

使用场景:如果某个Lambda表达式里只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用。

举例：

//实例方法
Compare compare = new Compare();
Arrays.sort(students,((o1, o2) -> compare.compare(o1,o2)));
//简化操作
Arrays.sort(students,compare::compare);
class Compare {
    public int compare(Student o1, Student o2){
        return o1.getAge()-o2.getAge();
    }
}

特定类型的方法引用:类型::方法。

使用场景:如果某个Lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数

都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用。

举例：

public static void main(String[] args) {
    String[] name = {"boby", "angela", "Andy","dlei", "caocao","Babo","jack","Cici"};
    //忽略字母大小写进行排序
    Arrays.sort(name, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            //制定比较规则
            return o1.compareToIgnoreCase(o2);
        }
    });
    //lambda简化
    Arrays.sort(name, ( o1,  o2)->  o1.compareToIgnoreCase(o2));
    //特定方法的引用
    Arrays.sort(name,String::compareToIgnoreCase);
    System.out.println(Arrays.toString(name));
}

[了解]

构造器引用:类名::new。

使用场景:如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用。

举例：

public class Test02 {
    public static void main(String[] args) {
        //匿名内部类
        Students s = new Students() {
            @Override
            public Student creat(String name, int age, double height) {
                return new Student(name, age, height);
            }
        };
        //lambda简化
        Students s1 = (name, age, height) -> new Student(name, age, height);
        //构造器引用
        Students cc = Student::new;
        Student c = cc.creat("赵子龙",18,180);
        System.out.println(c);
    }

}
interface Students {
    Student creat(String name, int age, double height);
}