Lambda思想概述

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

Lambda的标准格式

  • 格式:

    1
    2
    3
    4
    (String s) ->
    {
         System.out.println("hello");
    };

  • ():里面可以没有内容，可以看成是方法形式参数为空

  • ->:用箭头指向后面要做的事情

  • {}:包含一段代码，我们称之为代码块，可以看成是方法体中的内容

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    //定义一个接口
    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的形式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    //定义一个接口
    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表达式中System.out.println("好想回家");是重写了t.goHome()里面的方法

Lambda的带参数的形式

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    //定义一个接口
    public interface Think()
    {
        void goHome(String s);
    }


    //使用Lambda的形式实现接口
    public class demo {

        public static void main(String[] args) {
    		userThink((String s) ->
            {
                System.out.println(s);
            })
        }
        private static void  useThink(Think t)
        {
            t.goHome();
        }
    }

Lambda省略模式

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

  • 参数类型可以省略

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    useAdd((int x, int y)) ->
    {
        return x + y;
    });

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    useAdd((int x)) ->
    {
        return x + y;
    });

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

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

    1
    2
    3
    4
    5
    6
    7
    userThink((s) ->
     {
    	System.out.println();
    });
      
    //如下
       userThink(s ->System.out.println());

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

    1
    2
    3
    4
    5
    6
    7
    8
    useAdd((int x)) ->
    {
        return x + y;
    });

    //如下
    useAdd( x -> x + y);

lambda的注意事项

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