java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java lambda表达式简化代码

Java使用lambda表达式简化代码的示例详解

作者:在博客做笔记的路人甲

这篇文章主要给大家介绍了Java如何使用lambda表达式简化代码的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

代码,自然写的越简洁越好啦,写的人舒服,看的人也舒服,一切为了高效。

要把有限的时间花到其它有意思的事情上去。

目的

学习简化代码的思路,使用jdk8新特性lamada表达式。

推理一下

某接口,只有一个方法。

比如这个:

package java.lang;

@FunctionalInterface
public interface Runnable {
    void run();
}

或者是这个:

interface MyInterface{
    void sayHi();
}

实现接口,使用方法

一般我们要使用Runable子类开启一个线程,要实现Runnable接口,调用Threead类的start方法:

public class LeaningLamda implements Runnable{
    public static void main(String[] args) {
        new Thread(new LeaningLamda()).start();
    }
    @Override
    public void run() {
        System.out.println(this.getClass()+"我已经在跑了!");
    }
}

或者用sayHi方法干点什么,要先实现接口,再调用:

public class LeaningLamda2 implements MyInterface{
    public static void main(String[] args) {
        new LeaningLamda2().sayHi();
    }

    @Override
    public void sayHi() {
        System.out.println("ok ok ok ok ,i am say Hi!");
    }
}
interface MyInterface{
    void sayHi();
}

内部类实现接口,使用方法

如果这个方法我就用一次,那我可以在内部类中实现它,提高程序性能:

public class LeaningLamda{
    static class MyRun implements Runnable{
        @Override
        public void run() {
            System.out.println(this.getClass()+"我已经在跑了!");
        }
    }

    public static void main(String[] args) {
        new Thread(new MyRun()).start();
    }
}

一样的用sayHi方法:

public class LeaningLamda2 {
    static class MyHi implements MyInterface{
        @Override
        public void sayHi() {
            System.out.println("ok ok ok ok ,i am say Hi!");
        }
    }

    public static void main(String[] args) {
        new MyHi().sayHi();
    }
}
interface MyInterface{
    void sayHi();
}

局部内部类实现接口,使用方法

既然只使用一次,那我为啥不把它放在使用的方法里面去,性能不就又UpUpUpUp。

像这样: 

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

        class MyRun implements Runnable{
            @Override
            public void run() {
                System.out.println(this.getClass()+"我已经在跑了!");
            }
        }
        //调用在定义后面,谢谢。
        new Thread(new MyRun()).start();
    }
}

或是这样:

public class LeaningLamda2 {
    public static void main(String[] args) {
        
        class MyHi implements MyInterface{
            @Override
            public void sayHi() {
                System.out.println("ok ok ok ok ,i am say Hi!");
            }
        }
        new MyHi().sayHi();
    }
}
interface MyInterface{
    void sayHi();
}

匿名内部类实现接口,使用方法

我就用一次,要什么名字啊?能少输入一个字符都是赚的。需要借助父类或者接口名来实现。

你看:

public class LeaningLamda{
    public static void main(String[] args) {
        
        //需要借助父类或者接口来声明
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(this.getClass()+"我已经在跑了!");
            }
        }).start();
    }
}

又如:

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

        new MyInterface(){
            @Override
            public void sayHi() {
                System.out.println("ok ok ok ok ,i am say Hi!");
            }
        }.sayHi();
    }
}
interface MyInterface{
    void sayHi();
}

使用lamda表达式的,实现方法

jdk 8 看不下去了,给我们提供了一个更加简化的方案,你看:

lamda表达式实现创建单个简单线程:

public class LeaningLamda{
    public static void main(String[] args) {
        
        new Thread(()-> {
                System.out.println("我已经在跑了!");
            }
        ).start();
    }
}

lamda表达式sayHi:

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

        //此处需要借助一个父类或接口对象来存放,调用它
        MyInterface ls = ()->{  
            System.out.println("ok ok ok ok ,i am say Hi!"); };
        ls.sayHi();
    }
}
interface MyInterface{
    void sayHi();
}

可带参数

lamda表达式可以带参数,可以不指定类型,它会自适应类型:

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

        MyInterface ls = (i,str)->{
            System.out.println("int:"+i);
            System.out.println("String:"+str);};

        ls.sayHi(520,"i love you!");
    }
}
interface MyInterface{
    void sayHi(int i,String str);
}

运行结果:

只有一个参数

那我括号都可以省了!

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

        MyInterface ls = str-> {System.out.println("String:"+str);};
        ls.sayHi("i love you!");
    }
}
interface MyInterface{
    void sayHi(String str);
}

运行结果:

有返回值

如果有返回值呢,正常返回:

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

        MyInterface ls = (String str)-> {
            String str2 = "最后的赢家是:"+str;
            return str2;};
        System.out.println(ls.sayHi("lurenjia"));
    }
}
interface MyInterface{
    String sayHi(String str);
}

只有一条语句

如果方法只有一条语句,那大括号也没有必要,可以省略:

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

        MyInterface ls = (int i,String str)-> System.out.println("int:"+i+"----String:"+str);
        ls.sayHi(520,"i love you!");
    }
}
interface MyInterface{
    void sayHi(int i,String str);
}

究极省略,不能再省了

 就一条语句,是返回值:

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

        MyInterface ls = str-> "最后的赢家是:"+str;
        System.out.println(ls.sayHi("中国"));
    }
}
interface MyInterface{
    String sayHi(String str);
}

运行结果:

lamda总结

常用于创建简单线程。

1、接口只有一个方法,可有参数,可有返回值。

2、本方法内容简单,使用较少。

3、基本形式为:

接口或父类   名称  = (参数类型1 参数1,参数类型2 参数2,...)->{
            内容
        };
名称.方法(参数1,参数2,...);

4、可以省略的是:

1、lamada参数类型可省,它自适应。

2、方法内容只有一条内容,大括号可省。

3、内容只有一句返回语句,return可省,直接写值。

到此这篇关于Java使用lambda表达式简化代码的示例详解的文章就介绍到这了,更多相关Java lambda表达式简化代码内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文