1、Lambda 表达式
Lambda 表达式(也称为闭包)是整个Java8发行版本中最受期待的在Java语言层面上的改变,Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中),或者把代码看成数据,Lambda 表达式用于简化Java中接口式的匿名内部类,被称为函数式接口的概念,函数式接口就是一个具有一个方法的普通接口,像这样的接口,可以被隐式转换为Lambda 表达式。
语法:
(参数1,参数2...)->(...)
(1)没有参数的时候使用Lambda 表达式
(2)带参数时使用Lambda 表达式
(3)代码块中只一句代码时使用Lambda 表达式
(4)代码块中有多句代码时使用Lambda 表达式
(5)有返回值的代码块
(6)参数中使用final 关键字
/**
* @Date: 2018/12/8 10:23
* @Description:
*/
public class LambdaDemo {
// public static void main(String args[]) {
// IEat iEat = new IEatImpl();
// iEat.eat();
//
// //匿名内部类的使用
// IEat iEat1 = new IEat() {
// public void eat() {
// System.out.println("eat banana");
// }
// };
// iEat1.eat();
//
// //Lambda 表达式
// //好处:1.代码更加的简介;2.不会单独生成class文件
// //一个接口中只有一个方法的时候能使用Lambda 表达式
// //如果一个接口有多个方法就不能使用Lambda 表达式,只能用传统的匿名内部类
// //IEat iEat2 = () ->{ System.out.println("eat peach");};
//
// //没有参数时候的使用
// IEat iEat2 = () -> System.out.println("eat peach");
// iEat2.eat();
// }
public static void main(String args[]) {
//1.带参数时使用,参数的类型可以省略
// IEat iEat = (thing,name) -> System.out.printf("eat:", thing + "...." + name);
// iEat.eat("apple","anf");
//2.带参数时使用,参数的类型可以省略,代码中有多行参数
// IEat iEat = (thing,name) -> {
// System.out.printf("eat:", thing);
// System.out.println(name);
// };
// iEat.eat("apple","anf");
//3.带返回值的方法
// IEat iEat = (thing , name) ->{
// System.out.println(name + "eat" + thing);
// int i = 10;
// return i;
// };
// iEat.eat();
//4.带返回值的方法中只有一句实现代码
// IEat iEat = (thing , name) -> thing == null?1:0;
// iEat.eat();
//5.参数中使用final 关键字
// IEat iEat = (final String thing ,final String name) -> thing == null?1:0;
// iEat.eat();
}
}
//只有一个抽象方法的接口
interface IEat{
public void eat();
public void eat(final String thing,final String name);
}
//实现类
class IEatImpl implements IEat{
public void eat() {
System.out.println("eat apple");
}
@Override
public void eat(String thing,String name) {
System.out.println("string thing");
}
}
2.接口中的默认方法和静态方法
interface A{
public default void print(){};
public static void method(){};
}
默认方法与静态方法并不影响函数式接口的契约,可以任意使用。
package demo;
import lombok.Data;
/**
* @Date: 2018/12/8 11:14
* @Description:
*/
@Data
public class Student {
private String name;
private Integer age;
public Student(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
import demo.Student;
import java.util.Arrays;
import java.util.Comparator;
/**
* @Date: 2018/12/8 10:23
* @Description:
*/
public class LambdaDemo {
public static void main(String args[]) {
//排序
//Comparator<Student> comparator = (o1,o2) ->o1.getAge() - o2.getAge();
Arrays.sort(students,(o1,o2) ->o1.getAge() - o2.getAge());
System.out.println(Arrays.toString(students));
}
}
//只有一个抽象方法的接口
interface IEat{
public void eat();
public void eat(final String thing,final String name);
//默认方法, 默认方法与静态方法并不影响函数式接口的契约,可以任意使用。
public default void print(){
System.out.println("print test");
}
//静态方法 ,默认方法与静态方法并不影响函数式接口的契约,可以任意使用。
public static void method(){
System.out.println("static method");
}
}
//实现类
class IEatImpl implements IEat{
public void eat() {
System.out.println("eat apple");
}
@Override
public void eat(String thing,String name) {
System.out.println("string thing");
}
}