一、Lambda 表达式基础语法

一、Lambda基础语法
只为开起来方便自己做些笔记，若有不准确的地方还望各位大佬指正
JAVA 8 中引入了一个新的操作符 “->” 该操作符称为 “箭头操作符” 或lambda 操作符，箭头操作符将lambda表达式拆分成两部分
左侧：lambda表达式的参数列表
右侧：lambda表达式中所需要执行的功能，即lambda体

在这里插入代码片
public class TestLambda{
	
		
	/**①无参数，无返回值
	 *（）-> System.out.println("Hello Lambda");
	**/
	@Test
	public void test1(){
		//以前的写法
		Runnable r = new Runnable(){
			@Override
			public void run(){
				System.out.println("Hello World!");
			}
		};
		r.run();
		System.out.println("------1.8写法-------")
		Runnable r1 = ()-> System.out.println("Hello World!");
		r1.run();
	}
	
	/**
	  * 语法格式二
      * 有一个参数，并且无返回值
      *  (x) -> System.out.println(x);  
      **/
      @Test
      public void test2(){
		Consumer<String> con = (x) -> System.out.println(x);
		con.accept("Hello Lambda");
	  }
	
	  /**
	    * 语法格式三：
	    *   若只有一个参数下括号可以省略不写
	    *   x -> System.out.println(x)
	    **/
	  public void test3(){
		Consumer<String> con = x -> System.out.println(x);
		con.accept("Hello World");
	}
    
     /**
       * 语法格式四:
       * 	若有两个以上的参数，有返回值，并且Lambda 体中有多条语句
       * 	Comparator<Integer> com = (x,y) ->{
       * 						System.out.println("函数时接口");
       *						return Integer.compare(x,y);
       * 						};
       */
       public void test4(){
			Comparator<Integer> com = (x,y) ->{
						System.out.println("函数式接口");
						return Integer.compare(x,y);
							}
		}
		
	  /**
		* 语法格式五：
		*    若 Lambda 体中只有一条语句，return 和大括号可以省略不写
		* 	  Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
		**/
		@Test
		public void test5(){
			Comparator<Integer> com = (x,y) -> Integer.compare(100,101);
			System.out.println(com);
		}
	
	/**
	  * 语法格式六；
	  * 	Lambda 表达式需要“函数式接口”的支持
	  * 	函数式接口：接口中只有一个抽象方法的接口，称为函数式接口，可以使用@FunctionalInterface修饰
	  *     可以检查是否式函数式接口
	  **/
	@Test
	public void test6(){
		Integer num = opertion(100,x -> x * x);
		System.out.println(num);
	}
	//需求；对一个数进行计算
	public Integer opertion(Integer num,MyFucnInt mf){
		return mf.getValue(num);
	}
}

@FunctionalInterface
public interface MyFuncInt{
	public Integer getValue(Integer num);
}

下面是对上面的一些练习

public class TestLambda{

	List<Employee> emps = Arrays.asList(
		    new Employee(101,"张三",18),
            new Employee(102,"李四",28),
            new Employee(103,"王五",38),
            new Employee(104,"赵六",48),
            new Employee(104,"田七",58)
	);
	
  /**
    * 调用Conllections.sort()方法，通过定制排序比较两个Employee(先按年龄，
    * 年龄相同，按姓名比)使用lambda作为传递参数
    * Employee 可以自定义个 id,name,age参数的类，构造方法和get和set方法都定义上
    **/
	@Test  
	public void test(){
		Conllections.sort(emps,(e1,e1)->{
			if(e1.getAge() == e2.getAge()){
				return e1.getName().comapre(e2.getName());	
			}else{
				return e1.getAge().compare(e2.getAge());
			}
       });
		for(Empleyee emp: emps){
			System.out.println(emp);
		}
	}

	/**
     *  ① 声明函数式接口，接口中声明抽象方法，public String getValue(String str)
     *  ② 声明类TestLambda ，类中编写方法使用接口作为参数，将一个字符串转换成大写，
     *     并作为方法的返回值
     *  ③ 再将一个字符串的第2个和第4个索引位置进行截取子串
     */
	@Test
	public void test2(){
		String trimStr = strHandler("\t\t\t\ Hello World",(str) -> str.trim());
		System.out.println(trimStr);

		String upperStr = strHandler("abcd",(str) -> str.toUpperCase());
		System.out.println(upperStr);
		
		String newStr = strHandler("Hello World",str -> str.subString(2,5));
		System.out.println(newStr);
	}
	
	public String strHandler(String str,MyFuncStr mf){
		return mf.getValue(str);
	}
	
	/**
     * ① 声明一个带两个泛型的函数式接口，泛型类型<T,R> ,T为参数，R为返回值
     * ② 接口中声明对应抽象方法
     * ③ 再TestLambda 类中声明方法，使用接口作为参数，计算两个long 型参数的和
     * ④ 再计算两个long 型参数的乘ji
     */
     //需求 对于两个Long型数据进行处理
     @Test
     public void test3(){
		op(100L,200L,(x,y) -> x + y);
		op(100L,200L,(x,y) -> x * y);
	}
	
	public void op(Long l1,Long l2,MyFuc2para<Long,Long> mf){
		System.out.println(mf.getValue(l1,l2));
	}
}

@FunctionalInterface
public interface MyFuncStr{
	public String getValue(String str);
}

@FunctionalInterface
public interface MyFun2para<T,R>{
	public R getValue(T t1,T t2);
}