2-N 剖析 Java Lambda 表达式

自JDK 1.8之始 Java Lambda 引入，不仅使Java的语言变得更简洁，而且省去了原来处理匿名内部类的麻烦。接下来我先从应用场景一步步深入。
使用一个类，实现接口方法

interface Stustudy{
    public  void study();
}

编写一个类

class Stu implements  Stustudy{
    private String name;
    private int age;
    public Stu() {
    }
    public Stu(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void study() {
        System.out.println("test");
    }
}

通过类调用方法

Stu s1=new Stu("a",12);
        s1.study();

通过匿名内部类调用方法

	Stustudy st=new Stustudy() {
            @Override
            public void study() {
                System.out.println("------");
            }
        };
        st.study();

1.接下来通过Lamdba表达式实现

Stustudy st=()->{
            System.out.println("test");
        };
        st.study();

还可以简化为

Stustudy st=()-> System.out.println("test");;
st.study();

以上示例是一个无参的实现。我们再演示一个有参或多参的实现
2.有参数情况 接口

interface Stustudy{
    public  void study(String name);
}

//------------声明一个类承接比较器接口并加入比较对象
class Stu implements  Stustudy{
    private String name;
    private int age;
    public Stu() {
    }
    public Stu(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void study(String name) {
        System.out.println(name+"test");
    }
}

调用

Stustudy st=(s1)-> System.out.println(s1+"test");;
st.study("---->");

3.多参

interface Stustudy{
    public  void study(String name,int age);
}

调用

Stustudy st=(s1,s2)-> System.out.println(s1+"test----"+s2);;
st.study("---->",10);

4.演示带返回值

interface Stustudy{
    public  String study(String name);
}

 Stustudy st=(s1)-> {
            System.out.println("test");
            return "xxxx test";
        };
       String f= st.study("---->");
        System.out.println(f);

通过以上表达式可以看出 匿名内部类是由表达式自动实现的；这种场景局限于接口只有一个方法时才可以。但Lamdba 表达式的威力还不仅如此。

那么我们再深入一下，有一个需求：实现一个数组成员是类，对它进行排序；上篇已经介绍过了是通过比较器实现。现在通过Lamdba表达式实现。
类代码

class Stu{
    private String name;
    private int age;
    public Stu() {
    }
    public Stu(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

调用方式

Stu[] sl={new Stu("a",23),new Stu("c",18),new Stu("d",19)};
    Comparator<Stu> com=(s1,s2)->s1.getAge()-s2.getAge();
    Arrays.sort(sl,com);
    // 测试效果
    for (Stu sa: sl
         ) {
        System.out.println(sa.toString());
    }

简化调用

Stu[] sl={new Stu("a",23),new Stu("c",18),new Stu("d",19)};
    Arrays.sort(sl,(s1,s2)->s1.getAge()-s2.getAge());
    // 测试效果
    for (Stu sa: sl) {
        System.out.println(sa.toString());
    }

这样做就不需要再通过在类内继承比较器接口进行实现了。

纯手工原创，欢迎分享，创作不易，请注明出处。