关于Lambda表达式的推导与简单使用~

棉花糖

发布于 2020-9-16 15:50

浏览

0收藏

关于Lambda表达式：

是java8的新特性，可以避免匿名内部类定义过多
使用 Lambda 表达式可以对某些接口进行简单的实现
不是所有的接口都可以使用 Lambda 表达式来实现。
Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法，比如默认方法，不强制实现类重写默认方法
其实质属于函数式编程的概念

首先，我们来推导一下Lambda表达式，我们借助多线程的实现最常用方式实现Runnable接口进行推导：

通常，我们将Runnable实现类写在外面：

第一步我们将其改为静态内部类
再将其改为局部内部类
改为匿名内部类
再匿名内部类的基础上出去接口名和方法名即成Lambda表达式

代码示例：

package 多线程;
 
public class lamdaThread {
    //静态内部类
    static class myThread implements Runnable {
        @Override
        public void run() {
            System.out.println("调用run方法");
        }
    }
 
    public static void main(String[] args) {
        //局部内部类
        class test implements Runnable {
            @Override
            public void run() {
                System.out.println("调用run方法");
            }
        }
 
        //匿名内部类，必须借助接口或者父类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("调用run方法");
            }
        }).start();
 
        //jdk8简化lambda,除去接口名和方法名
        new Thread(() -> {
            System.out.println("调用run方法");
        }).start();
    }
}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.
28.
29.
30.
31.
32.
33.
34.

通过多线程实现的这个例子，我们可能大概理解了一点，接下来我们再举一个例子加深一下印象，我们通过自定义一个接口，然后推导一下Lambda表达式

代码示例：

package 多线程;
 
public class lambda {
    //静态内部类
    static class singer2 implements Sing {
        @Override
        public void song() {
            System.out.println("我是歌手2,我能唱歌");
        }
    }
 
    public static void main(String[] args) {
        Sing s = new Singer1();
        s.song();
        s = new singer2();
        s.song();
 
        //局部内部类
        class singer3 implements Sing {
            @Override
            public void song() {
                System.out.println("我是歌手3,我能唱歌");
            }
        }
        s = new singer3();
        s.song();
 
        //匿名内部类
        s = new Sing() {
            @Override
            public void song() {
                System.out.println("我是歌手4,我能唱歌");
            }
        };
        s.song();
 
        //lambda
        s = () -> {
            System.out.println("我是歌手5,我能唱歌");
        };
        s.song();
    }
}
 
interface Sing {
    void song();
}
 
//外部类
class Singer1 implements Sing {
    @Override
    public void song() {
        System.out.println("我是歌手1,我能唱歌");
    }
}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.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.

通过两个例子，大家应该大概会用Lambda表达式进行简单的操作，那碰到有参数或者带有返回值的情况下呢，接下来我们再给出两个示例：

示例一：有参数的lambda表达式

interface Ilove{
	void love(int a);
}
class Love implements Ilove{
	public void love(int a) {        
		System.out.println("I Love "+ a);
	}
}
public class Interface2 {
	public static void main(String[] args) {
	//lambda
	Ilove love=(int a)->{
		System.out.println("I Love "+a);
	};
	love.love(100);
	
	//类型可以省略
	love=(a)->{
		System.out.println("I Love "+a);
	};
	love.love(50);
	
	//括号可以省略
	love=a->{
		System.out.println("I Love "+a);
	};
	love.love(20);
	
	//只有一行代码花括号可以省略
	love=a->System.out.println("I Love "+a);
	love.love(10);
	}
}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.
28.
29.
30.
31.
32.
33.

示例二：有参数的带有返回值的lambda表达式

/*
 * 有参数的含return的lambda表达式
 */
interface Ilove{
	int love(int a,int b);
}
class Love implements Ilove{
	public int love(int a,int b) {        
		return a+b;
	}
}
public class Interface2 {
	public static void main(String[] args) {
	Ilove love=(int a,int b)->{
		return a+b;
	};
	System.out.println(love.love(100,50));
	
	//类型可以省略
	love=(a,b)->{
		return a+b;
	};
	System.out.println(love.love(50,80));
	
	//只有一行代码花括号可以省略
	love=(a,b)->{return a+b;};
	System.out.println(love.love(10,10));
	
	//等价于
	love=(a,b)->a+b;
	System.out.println(love.love(80,5));
	}
}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.
28.
29.
30.
31.
32.
33.