Lamda表达式好处、Lamda表达式演变、Lamda表达式使用总结

使用Lamda表达式的好处

• 避免匿名内部类定义过多
• 可以让代码看起来更简洁
• 去掉一对无意义的代码，只留下核心逻辑

Functional Interfere：函数式接口

理解Functional Interfere：函数式接口是学习Lamda表达式的关键。

注意：只有函数式接口才可以使用Lamda表达式

函数式接口定义：

• 任何接口，如果只包含唯一一个抽象方法，那么就是一个函数式接口

public interface Runable(){
	public abstract void run();
}

• 对于函数式接口，可以通过Lamda表达式来创建该接口的对象

Lamda表达式的演变过程

1.一个接口对应多个实现类，造成编写的文件数量很多

package testlamda;

public class Test1 {
    public static void main(String[] args) {
        PeopleCan iCan = new ICan();
        iCan.doSomething();
    }
}

//1.定义一个函数式接口
interface PeopleCan {
    //Java 中接口的方法默认是 public abstract的
    void doSomething();
}

//2.定义实现类
class ICan implements PeopleCan{

    @Override
    public void doSomething() {
        System.out.println("我能吃饭");
    }
}

正常是独立文件定义接口和实现类，这里只是演示，就在一个文件定义。

2.使用内部类定义实现类

2.1静态内部类

其他类中定义定义实现类，省去一个实现类文件ICan2

package testlamda;

public class Test2 {

    //2.定义实现类：静态内部类
    static class ICan2 implements PeopleCan2{

        @Override
        public void doSomething() {
            System.out.println("我能吃饭2");
        }
    }

    public static void main(String[] args) {
        PeopleCan2 iCan = new ICan2();
        iCan.doSomething();
    }
}

//1.定义一个函数式接口
interface PeopleCan2 {
    //Java 中接口的方法默认是 public abstract的
    void doSomething();
}

2.2局部内部类

用的时候再定义实现类ICan3

package testlamda;

public class Test3 {

    public static void main(String[] args) {

        //2.定义实现类：局部内部类
        class ICan3 implements PeopleCan3{

            @Override
            public void doSomething() {
                System.out.println("我能吃饭3");
            }
        }
        PeopleCan3 iCan = new ICan3();
        iCan.doSomething();
    }
}

//1.定义一个函数式接口
interface PeopleCan3 {
    //Java 中接口的方法默认是 public abstract的
    void doSomething();
}

2.3匿名内部类

匿名内部类(没有类的名称，必须借助接口或者父类)，这个实现类没有名字

package testlamda;

public class Test4 {

    public static void main(String[] args) {

        //2.定义实现类：匿名内部类(没有类的名称，必须借助接口或者父类)
        PeopleCan4 iCan = new PeopleCan4(){
            @Override
            public void doSomething() {
                System.out.println("我能吃饭4");
            }
        };
        iCan.doSomething();
    }
}

//1.定义一个函数式接口
interface PeopleCan4 {
    //Java 中接口的方法默认是 public abstract的
    void doSomething();
}

3.Lamda表达式

package testlamda;

public class Test5 {

    public static void main(String[] args) {

        //2.定义实现类：Lamda表达式,()里可以传参数
        PeopleCan4 iCan = () -> {
            System.out.println("我能吃饭5");
        };
        iCan.doSomething();
    }
}

//1.定义一个函数式接口
interface PeopleCan5 {
    //Java 中接口的方法默认是 public abstract的
    void doSomething();
}

3.1Lamda表达式继续简化

package testlamda;

public class Test5 {

    public static void main(String[] args) {

        //Lamda表达式,()里可以传参数
//        PeopleCan5 iCan = (String sth) -> {
//            System.out.println(sth);
//        };

        //简化1：省略参数类型,多个参数也可以去掉参数类型,但要去就都去掉
//        PeopleCan5 iCan = (sth) -> {
//            System.out.println(sth);
//        };

        //简化2：省略括号()
//        PeopleCan5 iCan = sth2 -> {
//            System.out.println(sth2);
//        };

        //简化3：省略括号{},这个省略是因为方法体只有System.out.println(sth3);一行，多行就不能省略
        PeopleCan5 iCan = sth3 -> System.out.println(sth3);
        iCan.doSomething("我能吃饭5");
    }
}

//1.定义一个函数式接口
interface PeopleCan5 {
    //Java 中接口的方法默认是 public abstract的
    void doSomething(String sth);
}

Lamda表达式使用总结

• 省略括号{},这个省略是因为方法体只有一行，多行就不能省略
• 省略参数类型,多个参数也可以去掉参数类型,但要去就都去掉
• 只有函数式接口才可以使用Lamda表达式

JUC：11四大原生函数式接口：函数型接口Function、判断型函数接口Predicate、Supplier供给型接口、消费型接口Consumer

lambda表达式过滤、链式编程、函数式接口、Stream流式计算