JAVA中的lambda表达式

一、什么是lambda表达式？

Lambda表达式：特殊的匿名内部类，语法更简洁

二、为什么使用Lambda表达式？
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使java的语言表达能力得到了提升。

三、Lambda的使用

public class day1 {
    public static  void main(String[] args){

        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println(
                        123

                );
            }
        };
     Runnable runnable1=()-> System.out.println(123);
     Thread thread=new Thread();
     thread.start();
     new Thread(()-> System.out.println(456));
    }
}

import java.util.Comparator;
import java.util.TreeSet;

public class day {
    public static void main(String[] args){
        Comparator<String> comparator=new Comparator<String>() {
            @Override
            public int compare(String o, String t1) {
                return o.length()-t1.length();
            }
        };
        Comparator<String> comparator1=(String t1,String t2)->{return t1.length()-t2.length();};
        Comparator<String> comparator2=(t1,t2)->t1.length()-t2.length();
        TreeSet<String> treeSet=new TreeSet<>(comparator);
        TreeSet<String> treeSet1=new TreeSet<>(comparator1);
        TreeSet<String> treeSet2=new TreeSet<>(comparator2);
        
    }
}

(1)语法格式一：无参、无返回值
Runnable r2 = () -> {System.out.println(“我爱长沙臭豆腐”);}

(2)语法格式二：Lambda需要一个参数、无返回值
Consumer con2 = (String s) ->{System.out.println(s);};

(3)语法格式三：数据类型可以省略，因为可由编译器推断得出，称为"类型推断"
Consumer con3 = (str) ->{ System.out.println(str); };

(4)语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
Consumer con4 = str ->{ System.out.println(str);};

(5)语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
Comparator com2 = (o1, o2) ->{
//多条执行语句
System.out.println(o1);
System.out.println(o2);
return Integer.compare(o1, o2);
};

(6)语法格式六：当Lambda体只有一条语句时，return 与 大括号若有，都可以省略
Comparator com3 = (o1, o2) -> Integer.compare(o1, o2);

-> ：Lambda操作符 或 箭头操作符
->左边：Lambda的形参列表（其实就是接口中的抽象方法的形参列表）
->右边：Lambda体（其实就是重写的抽象方法的方法体）

• **->左边：Lambda的形参列表的参数类型可以省略（类型推断）；

•   如果Lambda形参列表只有一个参数，小括号可以省略
  

• ->右边：Lambda体应该使用一对{}包裹，如果Lambda体只有一条执行语句（可能是return语句），

•   可以省略一对{}和return关键字**
  

Lambda表达式的本质：作为接口的实例（没有接口就没有意义啦！一定是依附接口而存在的）

public class LambdaDemo2 {
	//(1)语法格式一：无参、无返回值
	@Test
	public void test1(){
		Runnable r1 = new Runnable(){
			@Override
			public void run() {
				System.out.println("我爱北京天安门");
			}			
		};
		
		 r1.run();
		 
		 System.out.println("---------使用 Lambda 实现");
		 Runnable r2 = () -> System.out.println("我爱长沙臭豆腐");
		 r2.run();
	}
	
	//(2)语法格式二：Lambda需要一个参数、无返回值
	@Test
	public void test2(){
		Consumer<String> con = new Consumer<String>(){
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		};
		
		con.accept("AAA");
		
		System.out.println("---------使用 Lambda 实现");
		Consumer<String> con2 = (String s) ->{//大括号 是可以 省略的
				System.out.println(s);
			};
		con2.accept("DDD");
	}
	
	//(3)语法格式三：数据类型可以省略，因为可由编译器推断得出，称为"类型推断"
	@Test
	public void test3(){
		System.out.println("---------使用 Lambda 实现");
		Consumer<String> con2 = (String s) ->{//大括号 是可以 省略的
				System.out.println(s);
			};
		con2.accept("EEE");
		
		System.out.println("---------使用 Lambda 实现  数据类型可以省略");
		Consumer<String> con3 = (s) ->{//大括号 是可以 省略的    String也可以省略
				System.out.println(s);
			};
		con3.accept("FFF");
	}
	
	@Test
	public void test4(){
		ArrayList<String> list = new ArrayList<>();//类型推断
		//int [] arr = new int[]{1,2,3};
		int [] arr = {1,2,3};//类型推断
 	}
	
	//(4)语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
	@Test
	public void test5(){
		System.out.println("---------使用 Lambda 实现  数据类型可以省略");
		Consumer<String> con3 = (s) ->{//大括号 是可以 省略的    String也可以省略
				System.out.println(s);
			};
		con3.accept("FFF");
		
		System.out.println("---------使用 Lambda 实现  一个参数，小括号可以省略");
		Consumer<String> con4 = s ->{ 
			System.out.println(s);
		};
		con4.accept("GGG");
	}
	
	//(5)语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
	@Test
	public void test6(){
		Comparator<Integer> com1 = new Comparator<Integer>(){
			@Override
			public int compare(Integer o1, Integer o2) {
				//多条执行语句
				System.out.println(o1);
				System.out.println(o2);
				return Integer.compare(o1, o2);
			}
		};
		
		int c1 = com1.compare(12, 22);
		System.out.println(c1);
		
		System.out.println("---------使用 Lambda 实现 ");
		Comparator<Integer> com2 = (o1, o2) ->{// 两个或两个以上参数，括号不能省
			//多条执行语句
			System.out.println(o1);
			System.out.println(o2);
			return Integer.compare(o1, o2);
		};
		int c2 = com2.compare(32, 22);
		System.out.println(c2);
	}
	
	//(6)语法格式六：当Lambda体只有一条语句时，return 与 大括号若有，都可以省略
	@Test
	public void test7(){
		Comparator<Integer> com2 = (o1, o2) ->{
			return Integer.compare(o1, o2);
		};
		int c2 = com2.compare(32, 22);
		System.out.println(c2);
		
		System.out.println("---------当Lambda体只有一条语句时，return 与 大括号若有，都可以省略 ");
		Comparator<Integer> com3 = (o1, o2) -> Integer.compare(o1, o2);
			
		int c3 = com3.compare(32, 222);
		System.out.println(c3);
	}
	
	@Test
	public void test8(){
		System.out.println("---------使用 Lambda 实现  数据类型可以省略");
		Consumer<String> con3 = (s) ->{//大括号 是可以 省略的    String也可以省略
				System.out.println(s);
			};
		con3.accept("FFF");
		
		System.out.println("---------当Lambda体只有一条语句时，return 与 大括号若有，都可以省略 ");
		Consumer<String> con4 = s -> System.out.println(s);
		con4.accept("GGG");
	}
}