Java使用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可省，直接写值。