Lambda

Lambda

是一个匿名函数 ,本质是"语法糖", 由编译器推断并帮你转换成为一段可以传递的代码(将代码像数据一样进行传递).

可以写出更简洁跟灵活的代码.

作为一种更紧凑的代码风格,使Java语言表达能力得到提升.

六大基础语法详解

1. /**
    * 语法1.无参，无返回值
    */
   @Test
   public void test2(){
       int i = 0;
       //Lambda内部用到外部变量会自动转成final
       //可以使用定义数组的方式，在Lambda内对外部变量修改
       //int[] ints = new int[1];
       //ints[1] = i;
       Runnable runnable =()-> {
       //ints = ...
           System.out.println(i);
       };
   }
   

2. /**
    * 语法2：有一个参数，无返回值
    */
   @Test
   public void test3(){
       Consumer<String> com = (x) -> { System.out.println(x);};
       com.accept("过汉水之滨忆zhi");
   }
   

3. /**
    * 语法3：有一个参数，无返回值下，省略括号
    */
   @Test
   public void test4(){
       Consumer<String> com = x -> { System.out.println(x);};
       com.accept("过汉水之滨忆zhi");
   }
   

4. /**
    * 语法4：有两个以上参数，有返回，并且Lambda体中有多条语句
    */
   @Test
   public void test5(){
       Comparator<Integer> com = (x,y) -> {
           System.out.println("111");
           return Integer.compare(x,y);
       };
   }
   

5. /**
    * 语法5：有两个以上参数，有返回，并且Lambda体中只有一条语句，return 和大括号都可以省略不写
    * Lambda表达式的参数列表的参数类型可以省略不写。JVM编译器通过上下文推断数据类型
    */
   @Test
   public void test6(){
       Comparator<Integer> com = (x,y) ->  Integer.compare(x,y);
   }
   

总结

上联：左右遇一括号省

下联：左侧推断类型省

横批：能省则省

2.四大内置函数

类型	类	抽象方法
消费型接口	Consumer	void accept(T t);
供给型接口	Supplier	T get();
函数型接口	Function<T,R>	R apply(T t);
断言型接口	Predicate	boolean test(T t)

代码示例

1.  //消费型Consumer
       //需求：传入一个参数做业务处理，不需要返回值
       public void happy(double money, Consumer<Double> con){
           con.accept(money);
       }
       @Test
       public void test1(){
           happy(1000,(m)-> System.out.println("无忌每次去洗脚，每次消费"+m+"元"));
       }
   

2. //供给型接口：Supplier
       //需求：产生指定数量的整数，放到集合中，返回集合
       public List<Integer> getNumList(int num, Supplier<Integer> sp){
           List<Integer> result = new ArrayList<>();
           for (int i = 0; i <num ; i++) {
               result.add(sp.get());
           }
           return result;
       }
       @Test
       public void test2(){
           List<Integer> numList = getNumList(5,()-> (int)(Math.random()*100));
           numList.forEach(System.out::println);
       }
   

3. //函数型
       //需求3：传入一个字符串，返回一个字符串
       public String strHander(String str, Function<String,String> fun){
           return fun.apply(str);
       }
       @Test
       public void test3(){
           String result = strHander("武林盟主：",x->x+"张无忌");
           System.out.println(result);
       }
   

3.方法引用，构造器引用的使用

方法引用与对象引用

• 若Lambda体中的内容方法已经实现了，我们可以使用"方法引用"
• 可以理解为方法引用是Lambda表达式的另一种表现形式

1. //对象::实例方法名
   @Test
   public void test1(){
       PrintStream printStream = System.out;
       //要注意的是接口的抽象方法的形参表，返回类型需要和调用的类方法形参表 返回类型保持一至
       Consumer<String> con = System.out::println;
       con.accept("1234456");
   }
   

2. //类::静态方法名
   @Test
   public void test2(){
       //要注意的是接口的抽象方法的形参表，返回类型需要和调用的类方法形参表 返回类型保持一致
       Comparator<Integer> com = (x,y)-> Integer.compare(x,y);
       Comparator<Integer> com2 = Integer::compare;
   }
   

3. //类::实例方法名
   @Test
   public void test3(){
       //需求：比较两个字符串是否相等
       //要求：第一个参数是实例方法的调用者，第二个参数是方法的传入参数
       BiPredicate<String,String> bp = (x,y)->x.equals(y);
       BiPredicate<String,String> bp2 = String::equals;
   }
   

4. //构造器引用
   @Test
   public void test4(){
       Supplier<Person> student = Person::new;
       Person person = student.get();
   
       Function<Integer,Person> student1 = Person::new;
       Person apply = student1.apply(25);
       System.out.println(apply.getAge());
   }