Lambda

Lambda思想概述

• 一个函数式思想，“强调做什么，而不是以什么形式去做”
• 总而言之，可以使代码更加简洁

Lambda的标准格式

 (String s) ->
 {
      System.out.println("hello");
 };

• ():里面可以没有内容，可以看成是方法形式参数为空
• ->:用箭头指向后面要做的事情
• {}:包含一段代码，我们称之为代码块，可以看成是方法体中的内容

关于一段代码用不同的形式去表示（更容易理解lambda）

• 普通形式（使用接口实现类去实现接口）

  //定义一个接口
  public interface Think()
  {
      void goHome();
  }
  
  //定义一个接口的实现类
  public class ThinkImpl implements think
  {
     @Override
      public void goHome()
      {
           System.out.println("好想回家");
      }
  }
  //使用接口实现类去实现接口
  public class demo {
      public static void main(String[] args) {
          Think t = new thinkImpl();
          useThink(t);
      }    
      private static void useThink(Think t)
      {
          t.goHome();
      }
  }
  
  

• 使用匿名内部类的形式

  //定义一个接口
  public interface Think()
  {
      void goHome();
  }
  
  
  //使用匿名内部类的形式实现接口
  public class demo {
      public static void main(String[] args) {
          useThink(new think() {
             @Override
             public void goHome() {
                 System.out.println("好想回家");
             }
         });
      }
      private static void  useThink(think t)
      {
          t.goHome();
      }
  }
  
  
  
  

• 使用Lambda的形式

  //定义一个接口
  public interface Think()
  {
      void goHome();
  }
  
  //使用Lambda的形式实现接口
  public class demo {
      public static void main(String[] args) {
  		userThink(() ->
          {
              System.out.println("好想回家");
          })
      }
      private static void  useThink(think t)
      {
          t.goHome();
      }
  }
  

• 简洁形式：Lambda > 匿名内部类 >普通形式

Lambda的带参数的形式

• 有时候我们接口中的抽象方法可能是带有参数的

• 这个时候Lambda括号里面的形式参数就要填

  //定义一个接口
  public interface Think()
  {
      void goHome(String s);
  }
  
  
  //使用Lambda的形式实现接口
  public class demo {
      public class dem {
      public static void main(String[] args) {
  		userThink((String s) ->
          {
              System.out.println(s);
          })
      }
      private static void  useThink(think t)
      {
          t.goHome();
      }
  }
  

Lambda省略模式

• 你可能认为这样的代码已经很简洁了，但是总有人不想敲代码，所以Lambda可以继续省略

• 参数类型可以省略

  useAdd((int x, int y)) ->
  {
      return x + y;
  });
  
  //对于这种形式，可以省略参数类型
  useAdd(( x,  y)) ->
  {
      return x + y;
  });
  //不过切记要注意，要么两个都省略，要么两个都不省略
  //例如
  /*
      useAdd(( x, int  y)) ->
      {
          return x + y;
      });
  */
  //这是不允许的
  

• 如果参数有且仅有一个，那么小括号也可以省略

  useAdd((int x)) ->
  {
      return x + y;
  });
  
  //可以省略（int x）的括号，如下
  useAdd(int x) ->
  {
      return x + y;
  });
  
  

• 如果代码块的语句有且仅有一个，那么可以省略代码块的大括号和分号

  userThink((s) ->
   {
  	System.out.println();
  });
    
  //如下
     userThink(s ->System.out.println());
  

• 别急，还有一个！！！如果上述这个省略，里面有return，那么return也要省略(这个是必须的)

  useAdd((int x)) ->
  {
      return x + y;
  });
  
  //如下
  useAdd( x -> x + y);
  
  

lambda的注意事项

• 当然这个东西也要自己的局限性
• 比如，使用Lambda必须要有接口，必须要求接口中只有一个抽象方法。(匿名内部类可以有多个哦 )
• 最后这个东西虽然很简洁，但是可读性可能也会有所下降，可能会影响团队协作。