积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里，不积小流无以成江海。齐骥一跃，不能十步，驽马十驾，功不在舍。面对悬崖峭壁，一百年也看不出一条裂缝来，但用斧凿，能进一寸进一寸，能进一尺进一尺，不断积累，飞跃必来，突破随之。

目录

Lamda表达式是Java8中的，是避免匿名内部类定义过多，其实质属于函数式编程。可以去掉没有意义的代码，只留下核心的逻辑。

函数式接口

• 任何接口，如果只包含唯一一个抽象方法，那么它就是函数式接口。
• 对于函数式接口，可以通过Lamda表达式来创建该接口的对象。

接下来通过一个示例来说明Lamda的使用方法，同时也把几种类复习一下。

无参示例

首先，我们先正常写一个接口和其实现类。

外部类

public class TestLamda {
    public static void main(String[] args) {
        LamdaDao dao = new LamdaImpl();
        dao.showLamda();

    }
}

//函数式接口
interface LamdaDao{
    void showLamda();
}

//外部类
class LamdaImpl implements LamdaDao{

    @Override
    public void showLamda() {
        System.out.println("输出Lamda -> 1");
    }
}


//输出
输出Lamda -> 1

内部类

public class TestLamda {
    //静态内部类
    static class LamdaImpl implements LamdaDao{

        @Override
        public void showLamda() {
            System.out.println("输出Lamda -> 2");
        }
    }

    public static void main(String[] args) {
        LamdaDao dao = new LamdaImpl();
        dao.showLamda();

    }
}

//函数式接口
interface LamdaDao{
    void showLamda();
}


//输出
输出Lamda -> 2

匿名内部类

public class TestLamda {

    public static void main(String[] args) {
        LamdaDao dao = new LamdaDao() {
            @Override
            public void showLamda() {
                System.out.println("输出Lamda -> 3");
            }
        };
        dao.showLamda();

    }
}

//函数式接口
interface LamdaDao{
    void showLamda();
}


//输出
输出Lamda -> 3

Lamda表达式

public class TestLamda {

    public static void main(String[] args) {
        LamdaDao dao = ()->{ //如果这里的语句只有一句，可以省略括号
                System.out.println("输出Lamda -> 4"); 
            };
        dao.showLamda();

    }
}

//函数式接口
interface LamdaDao{
    void showLamda();
}

//输出
输出Lamda -> 4

可能分开写不太好开区别，现在把所有的合并，就可以明显看出区别。

public class TestLamda {
    //静态内部类
    static class LamdaImpl2 implements LamdaDao{

        @Override
        public void showLamda() {
            System.out.println("输出Lamda -> 2");
        }
    }

    public static void main(String[] args) {
        //外部类的示例
        LamdaDao dao = new LamdaImpl();
        dao.showLamda();

        //静态内部类的示例
        dao = new LamdaImpl2();
        dao.showLamda();

        //匿名内部类的示例
        dao = new LamdaDao() {
            @Override
            public void showLamda() {
                System.out.println("输出Lamda -> 3");
            }
        };
        dao.showLamda();

        //Lamda表达式的示例
        dao = ()->{ //如果这里的语句只有一句，可以省略括号
            System.out.println("输出Lamda -> 4");
        };
        dao.showLamda();

    }
}

//函数式接口
interface LamdaDao{
    void showLamda();
}

//外部类
class LamdaImpl implements LamdaDao{

    @Override
    public void showLamda() {
        System.out.println("输出Lamda -> 1");
    }
}


//输出
输出Lamda -> 1
输出Lamda -> 2
输出Lamda -> 3
输出Lamda -> 4

可以看见Lamda的写法非常简洁。这是无参的写法，下面是有参数的写法。

有参示例

有参的与无参的大同小异，具体看代码：

public class TestLamda {
    //静态内部类
    static class LamdaImpl2 implements LamdaDao{

        @Override
        public void showLamda(int x) {
            System.out.println("输出Lamda -> 2");
        }
    }

    public static void main(String[] args) {
        //外部类的示例
        LamdaDao dao = new LamdaImpl();
        dao.showLamda(777);

        //静态内部类的示例
        dao = new LamdaImpl2();
        dao.showLamda(777);

        //匿名内部类的示例
        dao = new LamdaDao() {
            @Override
            public void showLamda(int x) {
                System.out.println("输出Lamda -> 3");
            }
        };
        dao.showLamda(777);

        //Lamda表达式的示例
        dao = (int x)->{
            System.out.println("输出Lamda -> 4");
        };
        dao.showLamda(777);

    }
}

//函数式接口
interface LamdaDao{
    void showLamda(int x);
}

//外部类
class LamdaImpl implements LamdaDao{

    @Override
    public void showLamda(int x) {
        System.out.println("输出Lamda -> 1");
    }
}


//输出
输出Lamda -> 1
输出Lamda -> 2
输出Lamda -> 3
输出Lamda -> 4

可以看见，和无参的没有区别，只是多了参数而已。针对参数，Lamda还有一些简写形式：

public class TestLamda {
    //静态内部类
    static class LamdaImpl2 implements LamdaDao{

        @Override
        public void showLamda(int x) {
            System.out.println("输出Lamda -> 2");
        }
    }

    public static void main(String[] args) {
        LamdaDao dao = null;

        //Lamda表达式的示例
        dao = (int x)->{
            System.out.println("输出Lamda -> 4");
        };
        dao.showLamda(777);

        //Lamda表达式的示例，简写形式一：不要参数类型
        dao = (x)->{
            System.out.println("输出Lamda -> 44");
        };
        dao.showLamda(777);

        //Lamda表达式的示例，简写形式二：不要参数括号（注意，只能是参数为一个时才可以用，多个时必须加括号）。执行代码也是一样，只有一句时可以不要，但有多个时必须加上括号
        dao = x-> System.out.println("输出Lamda -> 444");;
        dao.showLamda(777);
    }
}

//函数式接口
interface LamdaDao{
    void showLamda(int x);
}


//输出
输出Lamda -> 4
输出Lamda -> 44
输出Lamda -> 444

所以，只要记住这两种就行：

//Lamda表达式的示例
dao = (int x)->{
    System.out.println("输出Lamda -> 4");
};
dao.showLamda(777);

//简写形式一：不要参数类型
dao = (x)->{
    System.out.println("输出Lamda -> 44");
};
dao.showLamda(777);

Lamda的使用场景

排序

注意：基本类型不能使用！如：int不能使用。String可以使用

import java.util.Arrays;

public class TestLamda {
    public static void main(String[] args) {
        Integer[] a = new Integer[15];
        a[1]=12;
        a[2]=234;
        a[3]=26;
        a[4]=24;
        a[5]=132;
        Arrays.sort(a,1,6,(o1,o2)->(o1-o2)); //升序，降序为o2-o1
        for(int i=1;i<=5;++i){
            System.out.println(a[i]);
        }
    }
}

//输出
12
24
26
132
234

import java.util.Arrays;

public class TestLamda {
    public static void main(String[] args) {
        String[] ss = new String[4];
        ss[1] = "a";
        ss[2] = "gd";
        ss[3] = "cya";
        Arrays.sort(ss,1,4,(o1,o2)->(o1.compareTo(o2)));
        for(int i=1;i<=3;++i){
            System.out.println(ss[i]);
        }
    }
}

//输出
a
cya
gd