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

发布于 2020-9-16 15:50
浏览
0收藏

关于Lambda表达式:

 

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

 

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

通常,我们将Runnable实现类写在外面:

 

  1. 第一步我们将其改为静态内部类
  2. 再将其改为局部内部类
  3. 改为匿名内部类
  4. 再匿名内部类的基础上出去接口名和方法名即成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();
    }
}

 

通过多线程实现的这个例子,我们可能大概理解了一点,接下来我们再举一个例子加深一下印象,我们通过自定义一个接口,然后推导一下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,我能唱歌");
    }
}

 

通过两个例子,大家应该大概会用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);
	}
}

 

示例二:有参数的带有返回值的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));
	}
}

 

THE END

 

 

作者:Baret H ~ 

来源:CSDN

标签
收藏
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐