Java8中引入了一个新的操作符"->"该操作符称为箭头操作符或Lambda操作符，箭头操作符将Lambda表达式拆分为两部分：
左侧：Lambda表达式的参数列表
右侧：Lambda表达式所需要执行的功能，即Lambda体
1 () -> System.out.println("hello");
1 (x) -> System.out.println("hello" + x);
1 x -> System.out.println("hello" + x);
1 Comparator<Interger> com = (x, y) -> { 2 System.out.println("hello"); 3 return Interger.compare(x, y); 4 };
1 Comparator<Interger> com = (x, y) -> Interger.compare(x, y);
1 Comparator<Interger> com = (Interger x,Interger y) -> Interger.compare(x, y);
接口->外部实现类->静态内部类->局部内部类->匿名内部类->lambda->方法引用方式
1 /** 2 * 定义一个函数式接口： 3 * 函数式接口是一个接口中只有一个非默认且非Object类的方法 4 */ 5 @FunctionalInterface 6 interface ILike { 7 //默认都为抽象方法（一般都省略abstract） 8 void lambda(); 9 10 default void print() { 11 System.out.println("我是默认方法"); 12 } 13 14 String toString(); 15 16 boolean equals(Object obj); 17 } 18 19 //外部实现类 20 class Like1 implements ILike { 21 22 @Override 23 public void lambda() { 24 System.out.println("外部实现类"); 25 } 26 } 27 28 public class TestLambda { 29 30 31 public static void printLambda() { 32 System.out.println("我是TestLambda类的静态方法"); 33 } 34 35 //静态内部类 36 static class Like2 implements ILike { 37 38 @Override 39 public void lambda() { 40 System.out.println("静态内部类"); 41 } 42 } 43 44 45 public static void main(String[] args) { 46 47 ILike like = new Like1(); 48 like.lambda(); 49 50 like = new Like2(); 51 like.lambda(); 52 53 //局部内部类 54 class Like3 implements ILike { 55 56 @Override 57 public void lambda() { 58 System.out.println("局部内部类"); 59 } 60 } 61 62 like = new Like3(); 63 like.lambda(); 64 65 //匿名内部类，没有类的名字，必须借助接口或者父类实现 66 like = new ILike() { 67 @Override 68 public void lambda() { 69 System.out.println("匿名内部类"); 70 } 71 }; 72 73 like.lambda(); 74 75 //lambda表达式 76 like = () -> System.out.println("lambda表达式"); 77 like.lambda(); 78 79 //方法引用方式（类::静态方法） 80 like = TestLambda::printLambda; 81 like.lambda(); 82 83 } 84 85 }
函数式接口：接口中只有一个抽象的方法（非default且非Object类中的方法），称之为函数式接口。可以使用注解 @FunctionalInterface 修饰（用于检查是否是函数式接口）
主要有三种语法格式：（所引用的方法参数和返回值要与函数式接口的抽象方法参数和返回值一致）
1 @Test 2 public void test() { 3 4 //lambda 5 PrintStream ps = System.out; 6 Consumer<String> con1 = (x) -> ps.println(x); 7 con1.accept("con1"); 8 9 //对象::实例方法名（返回值和参数需要与方法调用者一致） 10 Consumer<String> con2 = System.out::println; 11 con2.accept("con2"); 12 13 //lambda 14 Comparator<Integer> com1 = (x, y) -> Integer.compare(x, y); 15 System.out.println(com1.compare(5, 6)); 16 17 //类::静态方法名（返回值和参数需要与方法调用者一致） 18 Comparator<Integer> com2 = Integer::compare; 19 System.out.println(com2.compare(5, 6)); 20 21 //lambda 22 BiPredicate<String, String> bp1 = (x, y) -> x.equals(y); 23 System.out.println(bp1.test("aaa","aaa")); 24 25 //类::实例方法名（条件是第一个参数为实例方法调用者，第二个参数为实例方法的参数） 26 // （返回值和参数需要与方法调用者一致） 27 BiPredicate<String,String> bp2 = String::equals; 28 System.out.println(bp2.test("aaa","aaa")); 29 30 }
格式：ClassName::new（所调用的构造器参数要与函数式接口的抽象方法参数一致）
1 class Mytest{ 2 3 private Integer id; 4 private String testmes; 5 6 public Mytest() { 7 } 8 9 public Mytest(Integer id) { 10 this.id = id; 11 } 12 13 public Mytest(Integer id, String testmes) { 14 this.id = id; 15 this.testmes = testmes; 16 } 17 18 @Override 19 public String toString() { 20 return "Mytest{" + 21 "id=" + id + 22 ", testmes=‘" + testmes + ‘\‘‘ + 23 ‘}‘; 24 } 25 } 26 27 @Test 28 public void test2(){ 29 30 //Lambda(调用无参构造函数) 31 Supplier<Mytest> sup1 = ()->new Mytest(); 32 System.out.println(sup1.get()); 33 34 //构造器引用方式(调用无参构造函数) 35 Supplier<Mytest> sup2 = Mytest::new; 36 System.out.println(sup2.get()); 37 38 //Lambda(调用一个参数和一个返回值构造函数) 39 Function<Integer,Mytest> fun1 = (x)->new Mytest(x); 40 System.out.println(fun1.apply(3)); 41 42 //构造器引用方式(调用一个参数和一个返回值构造函数) 43 Function<Integer,Mytest> fun2 = Mytest::new; 44 System.out.println(fun2.apply(3)); 45 46 //Lambda(调用两个参数和一个返回值构造函数) 47 BiFunction<Integer,String,Mytest> bi1 = (x,y)->new Mytest(x,y); 48 System.out.println(bi1.apply(3,"mytest3")); 49 50 //构造器引用方式(调用两个参数和一个返回值构造函数) 51 BiFunction<Integer,String,Mytest> bi2 = Mytest::new; 52 System.out.println(bi2.apply(3,"mytest3")); 53 54 }
3.数组引用
格式：Type::new
1 @Test 2 public void testarray(){ 3 4 //lambda 5 Function<Integer,String[]> fun1 = (x) -> new String[x]; 6 System.out.println(fun1.apply(10).length); 7 8 //数组引用 9 Function<Integer,String[]> fun2 = String[]::new; 10 System.out.println(fun2.apply(15).length); 11 12 }
原文：https://www.cnblogs.com/zhihaospace/p/11991716.html