java基础 浅解1.8新增lambda表达式

lambda是java1.8的一个新特性，可以简化一些代码

lambda 表达式的语法格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

理解lambda之前我们首先应该理解一个什么叫做函数式接口。

函数式接口 ：

• 任何接口，如果只包含唯一一个抽象方法，那么就是一个函数式接口。

  public  interface 接口名{
      void 方法();
      
  }
  

但是函数式接口不代表只有一个方法，比如Comparator这个接口其注解带有@FunctionalInterface就不会报错，但是其有很多方法为什么也是函数式接口？

    1 ：default方法某默认实现，不属于抽象方法
    2 ：接口重写了Object的公共方法也不算入内

• 对于函数式接口，可以通过lambda表达式来创建接口对象

首先我们通过一个内部匿名类实现一个接口，对于匿名内部类在我一篇文章里面有详细解 Java基础 浅解抽象类与接口。

在java1.8之前我们这样使用匿名内部类来实现接口：

public class Test {
	public static void main(String[] args) {
		TestLambda testLambda=new TestLambda(){
			public void out(){
				System.out.println("----->");
				}
		};
		testLambda.out();
	}
}
 interface TestLambda{
    void out();

}

//输出
----->

但是如果我们使用lambda表达式来表示式什么样子呢，我们可以看一些一下代码

public class Test {
	public static void main(String[] args) {
        //方便对比，我们还放着内部匿名类
		TestLambda testLambda=new TestLambda(){
			public void out(){
				System.out.println("----->");
				}
		};
		testLambda.out();
        // 如果使用的lambda，
        TestLambda testLambda1=()->{System.out.println("----->lambda");};
		testLambda1.out();    
	}
}
 interface TestLambda{
    void out();
}
//输出
----->
----->lambda

可以看出lambda表达式的优势，减少起无用的代码保留了起原有的逻辑，还让让代码更加简洁，同时避免匿名内部创建的更多。

又有想法，lambda表达式是否可以有参数。

public class Test {
	public static void main(String[] args) {
		TestLambda testLambda=new TestLambda(){
			public void out(int i){
				System.out.println("----->"+i);
				}
		};
		testLambda.out(10);
		
		TestLambda testLambda1=(k)->{System.out.println("----->lambda "+k);};
		testLambda1.out(10);

	}
}
 interface TestLambda{
    void out(int i);
}
//输出
----->10
----->lambda 10

看到如上代码，既然lambda表达式是简化代码，那么是否可以再继续简化呢？

废话不说先上代码

public class Test {
	public static void main(String[] args) {
		TestLambda testLambda=new TestLambda(){
			public void out(int i){
				System.out.println("----->"+i);
				}
		};
		testLambda.out(10);
		
		TestLambda testLambda1=(k)->{System.out.println("----->lambda "+k);};
		testLambda1.out(10);
		// 简化省了参数的括号
		TestLambda testLambda2 = k->{System.out.println("testLambda2----->lambda  "+k);};
		testLambda2.out(20);
		
		// 简化省了参数的括号，同时省去 方法体的大花括号
		TestLambda testLambda3 = k->System.out.println("testLambda3----->lambda  "+k);
		testLambda3.out(30);
		
	}
}
 interface TestLambda{
    void out(int i);
}
//输出
----->10
----->lambda 10
testLambda2----->lambda  20
testLambda3----->lambda  30

可以见lambda可以省区方法中（）以及方法体{}，但是有没有什么限制呢，难道都可以省区？

那再回去试试没有参数的

public class Test {
	public static void main(String[] args) {
	
		
		TestLambda testLambda1=()->System.out.println("----->lambda ");;
		testLambda1.out();
		//TestLambda testLambda2=->System.out.println("----->lambda2 ");//Syntax error on token "->", -- expected 	
	}
}
 interface TestLambda{
    void out();

}
//输出
----->lambda 

可以看出如果是无参，虽然可以省去方法体{}，但是方法参数的（）是无法省区的，不然编译都无法通过，报错：Syntax error on token “->”, – expected

那么如果参数是多个？我们再测试一下

public class Test {
	public static void main(String[] args) {
	
		
		TestLambda testLambda1=(k,s)->{System.out.println(s+"  ----->lambda "+k);};
		testLambda1.out(10,"testLambda1");
		
//		TestLambda testLambda2 = k,s->{System.out.println(s+ "testLambda2----->lambda  "+k);};//Syntax error on token "->", -- expected 
		

		TestLambda testLambda3 = (k,s)->System.out.println(s+"testLambda3----->lambda  "+k);
		testLambda1.out(30,"testLambda3");
		
	}
}
 interface TestLambda{
    void out(int i,String s);

}
//输出
testLambda1  ----->lambda 10
testLambda3  ----->lambda 30

如果是有参数超过一个，也是必须带有（），否则就会报错，当然{}也是可以省去的。

但是由此我们又有一个怀疑了，那就是方法体我们其中只有一行，是否多行的话可行。

public class Test {
	public static void main(String[] args) {
	
		
		TestLambda testLambda1=(k,s)->{System.out.println("第一行");System.out.println(s+"  ----->lambda "+k);};
		testLambda1.out(10,"testLambda1");
		
//		TestLambda testLambda2 = k,s->{System.out.println(s+ "testLambda2----->lambda  "+k);};//提示s和k不存在

	}
}
 interface TestLambda{
    void out(int i,String s);

}
//输出
第一行
testLambda1  ----->lambda 10

可以如果方法体中的方法超过一行之后，就无法省去{}。突然有一个大胆下想法：好奇是否可以让接口中方法有返回参数

public class Test {
	public static void main(String[] args) {
	
		
		TestLambda testLambda1=  (k,s)->{return (s+"  ----->lambda "+k);};
		System.out.println(testLambda1.out(10,"testLambda1"));
		
	}
}
 interface TestLambda{
    String out(int i,String s);

}
//输出
testLambda1  ----->lambda 10

可见如果有返回值，只需要在其内部添加一个return即可，不过虽然只有一句，不过还有return就无法省去{}。其他的和无返回值一样的限制。

如果有需要return，但是又想省去{}是否可行呢？

public class Test {
	public static void main(String[] args) {
	
		
		TestLambda testLambda1=  (k,s)->s+"  ----->lambda "+k;
		System.out.println(testLambda1.out(10,"testLambda1"));
		
	}
}
 interface TestLambda{
    String out(int i,String s);

}
//输出
testLambda1  ----->lambda 10

神奇不，如果有renturn 而且只有一行代码，而这个可以直接省去 return 和{}。lambda表达式可以默认根据接口的方法将 编译以及运行的时候添加return关键字

由此我们可以看出lambda表达式的特征

• 前提：

  ​ 必须式接口而且只有一个抽象方法

• 特征

  • 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

  ​ 再lambda表达式使用过程中，我们可以看出来的，没有声明变量类型。

  • 可选的参数圆括号：一个参数无需定义圆括号，但多个参数或无参需要定义圆括号。
  • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号，如果单个语句是return虽然是一句但也得加{}。但是可以如果只有一行可以将return和{} 取消掉。
  • 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

补充一点，lambda可否调用外部的变量

public class Test {
	public static void main(String[] args) {
		int l=21;
		TestLambda testLambda=new TestLambda(){
			public void out(int i){
				i=i+l;
                 //l=i+l;Local variable l defined in an enclosing scope must be final or effectively final
				System.out.println("----->"+i);
				}
		};
		testLambda.out(10);
		testLambda=i->{
			i=i+l;
            //l=i+l;Local variable l defined in an enclosing scope must be final or effectively final
			System.out.println("----->"+i);
		};
		testLambda.out(10);
	
		
	}
}
 interface TestLambda{
    void out(int i);

}

//输出
----->31
----->31

两个没有变量，但是如果把i=i+l 变成l=l+i;后编译就会报错，无论时匿名内部类还是lambda都会报错：Local variable l defined in an enclosing scope must be final or effectively final

也就是说：lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。