lamda表达式

lamda表达式是jdk1.8新特性之一

lamda表达式的前提：有一个函数式接口。

函数式接口定义：接口中有一个函数。

下面用代码做演示。

首先接口中的函数时无参的
本来是下面这样的：接口，接口实现类，和main方法。也就是说需要一个接口，两个类。

package com.yang;

public class Noargs {

    public static void main(String[] args) {
        Ilike like = new Like();
        like.likeLamda();
    }
}

//定义函数式接口
interface Ilike{
    void likeLamda();
}
//定义接口实现类
class Like implements Ilike{
    @Override
    public void likeLamda() {
        System.out.println("I like Java");
    }
}

然后实现类可以用静态内部类代替，就演化成：一个接口，一个类！

package com.yang;

public class Noargs {
    
    //静态内部类
    static class Like implements Ilike{
        @Override
        public void likeLamda() {
            System.out.println("I like Java");
        }
    }

    public static void main(String[] args) {
        Ilike like = new Like();
        like.likeLamda();
    }
}

//定义函数式接口
interface Ilike{
    void likeLamda();
}

而静态内部类还可以用局部内部类来代替。

package com.yang;

public class Noargs {
    public static void main(String[] args) {
        //局部内部类
        class Like implements Ilike{
            @Override
            public void likeLamda() {
                System.out.println("I like Java");
            }
        }
        Ilike like = new Like();
        like.likeLamda();
    }
}

//定义函数式接口
interface Ilike{
    void likeLamda();
}

局部内部类再简化，就是匿名内部类：没有类的名称，必须借助接口或者父类。

package com.yang;
public class Noargs {
  public static void main(String[] args) {
        //匿名内部类
        Ilike like = new Ilike() {
            @Override
            public void likeLamda() {
                System.out.println("I like Java");
            }
        };
        like.likeLamda();        
    }
}

//定义函数式接口
interface Ilike{
    void likeLamda();
}

再简化，就是lamda表达式了。比匿名内部类，省略了：

package com.yang;
public class Noargs {
    
    public static void main(String[] args) {

        //lamda表达式
        Ilike like = () -> {
            System.out.println("I like Java");
        };
        like.likeLamda();

    }
}

//定义函数式接口
interface Ilike{
    void likeLamda();
}

然后是有参的

package com.yang;

public class Args {
    public static void main(String[] args) {
        Ilove love = new Love();
        love.loveLamda(2);
        
    }
}

//函数式接口
interface Ilove{
    void loveLamda(int a);
}

//实现类
class Love implements Ilove{
    @Override
    public void loveLamda(int a) {
        System.out.println("I love Java" + a);
    }
}

静态内部类：

package com.yang;

public class Args {
    //静态内部类
    static class Love implements Ilove{
        @Override
        public void loveLamda(int a) {
            System.out.println("I love Java" + a);
        }
    }
    
    public static void main(String[] args) {
        Ilove love = new Love();
        love.loveLamda(2);

    }
}

//函数式接口
interface Ilove{
    void loveLamda(int a);
}

局部内部类：

package com.yang;

public class Args {


    public static void main(String[] args) {
        //局部内部类
        class Love implements Ilove{
            @Override
            public void loveLamda(int a) {
                System.out.println("I love Java" + a);
            }
        }
        Ilove love = new Love();
        love.loveLamda(2);

    }
}

//函数式接口
interface Ilove{
    void loveLamda(int a);
}

匿名内部类：

package com.yang;

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

        //匿名内部类
        Ilove love = new Ilove(){
            @Override
            public void loveLamda(int a) {
                System.out.println("I love Java" + a);
            }
        };
    }
}

//函数式接口
interface Ilove{
    void loveLamda(int a);
}

lamda表达式：

package com.yang;

public class Args {  
    public static void main(String[] args) {
        Ilove love = (int a) ->{
            System.out.println("I love Java" + a);
        };
        love.loveLamda(2);
    }
}

//函数式接口
interface Ilove{
    void loveLamda(int a);
}

还可以再简化：去掉参数类型。

package com.yang;

public class Args {

    public static void main(String[] args) {
       //去掉参数类型
        Ilove love = (a) ->{
            System.out.println("I love Java" + a);
        };
        love.loveLamda(2);
    }
}

//函数式接口
interface Ilove{
    void loveLamda(int a);
}

还可以去掉括号：

package com.yang;

public class Args {

    public static void main(String[] args) {
    	//去掉括号
        Ilove love = a ->{
            System.out.println("I love Java" + a);
        };
        love.loveLamda(2);
    }
}

//函数式接口
interface Ilove{
    void loveLamda(int a);
}

还可以去掉花括号：

package com.yang;

public class Args {

    public static void main(String[] args) {
		//去掉花括号
        Ilove love = a -> System.out.println("I love Java" + a);
        love.loveLamda(2);
    }
}

//函数式接口
interface Ilove{
    void loveLamda(int a);
}

但是要注意：
1.lamda表达式只能在只有一行代码的情况下才能简化为一行（就是去掉花括号的情况），如果有多行的话，只能用花括号。
2.前提是：接口时函数式接口
3.如果是多个参数的话，去掉参数类型时，要去掉只能都去掉，而且必须要加上括号。