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

目录

• 目的
• 推理一下
• 实现接口，使用方法
• 内部类实现接口，使用方法
• 局部内部类实现接口，使用方法
• 匿名内部类实现接口，使用方法
• 使用lamda表达式的，实现方法
• 可带参数
• 只有一个参数
• 有返回值
• 只有一条语句
• 究极省略，不能再省了
• lamda总结

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

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

目的

学习简化代码的思路，使用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表达式简化代码内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！