Lamda作为Java8引入的语法，不会的话也不影响我们的正常开发，但如果学会的话，可以极大地减少我们的无用代码数量，让我们一起来看一下！

1.Lamda表达式常用情景：实现Runnbale接口创建线程

我们经常可以在编程中看到如下代码：

public class test {
	
	public static void main(String[] args) {

		Thread thread = new Thread(()-> {/*某耗费时间的代码*/});
		thread.start();
	}
}

这其实就是我们Lamda表达式的使用方式之一：快速创建匿名类
如果我们不使用Lamda表达式，当然也可以实现相同的功能，不过，要花费的固定格式的代码就要多很多。

比如：

public class test {
	
	public static void main(String[] args) {

		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				/*耗费时间的代码*/
			}
		});
		thread.start();
	}
}

可以看到，如果实现接口，要将实现接口的固定格式全部写出（接口名方法名等），而Lamda则可以使用一行代码搞定，极大简化我们的代码，看起来不会乱糟糟~

2.Lamda表达式的使用

Lamda表达式的基本格式：()->{}
其中（）括号内填写的是方法的参数，{}大括号内填写的是方法实现语句

举例说明：实现Runnable接口，就可以这样来写

public class test {
	public static void main(String[] args) {
		Runnable myRunnable = () -> {
			for(int i=0;i<100;i++)
			{
				System.out.println(i);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}; 
		
	}
}

因为run方法没有参数，所以并不需要在括号内填写参数。

现在来举个例子模拟有参数的情况：

现在我们创建一个IEat接口，其中有一个eat方法，还有一个PersonEat方法，使用到了该接口的抽象方法，方法中内容需要我们自己实现，参数为eat的内容！

public class test {
	//此方法调用了IEat接口中的eat方法
	public static void personEat(IEat e)
	{
		e.eat("蔬菜");
	}
	public static void main(String[] args) {
		IEat e = new IEat() {
			@Override
			public void eat(String v) {
				System.out.println("正在吃"+v);
			}
		};
		personEat(e);
	}
}
interface IEat
{
	void eat(String v);
}

以上就是我们通过匿名类实现接口并使用的例子，可以发现，我们写了很多的不必要内容，来实现eat方法！

而使用我们Lamda表达式就很方便：

public class test {
	//此方法调用了IEat接口中的eat方法
	public static void personEat(IEat e)
	{
		e.eat("蔬菜");
	}
	public static void main(String[] args) {
		IEat e = (String v) -> {System.out.println("正在吃" + v);};
		personEat(e);
	}
}
interface IEat
{
	void eat(String v);
}

此时就可以发现，我们化简了很多规定格式的代码，使项目更加简洁，省掉了很多不必要的内容！

变式写法：

1.我们在此基础上，还可以去参数类型

IEat e = (v) -> {System.out.println("正在吃" + v);};

2.除了去掉参数类型 ，如果只有一个参数，还可以去掉括号

IEat e = v -> {System.out.println("正在吃" + v);};

3.如果实现方法的代码只有一条，连大括号都可以去掉

IEat e = v -> System.out.println("正在吃" + v);

4.如果在想懒一下，我们甚至可以直接将Lamda表达式直接写入到参数内

personEat(v -> System.out.println("正在吃" + v));

写到这个时候我们就可以很明显发现，我们（画红框）7行代码，使用Lamda表达式之后，只需要一行代码就可以搞定！

此时如果有人问：

方法没有参数怎么办？

public class test {

	//此方法调用了IEat接口中的eat方法
	public static void personEat(IEat e)
	{
		e.eat();
	}
	public static void main(String[] args) {
		//直接使用空括号就可以了
		personEat(() -> System.out.println("正在吃蔬菜"));
	}
}
interface IEat
{
	//没有参数
	void eat();
}

有返回值怎么办？

public class test {
	
	//此方法调用了IEat接口中的eat方法
	public static void personEat(IEat e)
	{
	    //输出处理结果
		System.out.println(e.eat("蔬菜"));
	}
	
	public static void main(String[] args) {
		//对字符串进行处理
		personEat(v -> "正在吃" + v);
	}
}

interface IEat
{
	//返回字符串
	String eat(String v);
}

总结来说：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流式计算

Lamda表达式

1、λ 希腊字母表中排序第十一位的字母，英语名称为 Lamda
2、避免匿名内部类定义过多
3、可以让你的代码看起来很简洁
4、去掉了一堆没有意义的代码，留下核心的逻辑
3、其实质属于函数式编程的概念

(params)-> expression[表达式]
(params) -> statement[语句]
(params) -> {statements}

a -> System.out.println("i like lamda-->"+a)

new Thread (()->System.out.println(“多线程学习。。。。”)).start();

怎么理解

1、理解Functional interface（函数式接口）是学习java8 lamda表达式的关键所在。

2、函数式接口的定义：

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

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

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

代码推导λ表达式

package com.haiyang.lamda;

public class TestLamda01 {

    //3、静态内部类，同样实现ILike接口
    static class Like2 implements ILike{
        @Override
        public void lamda() {
            System.out.println("i like lamda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lamda();
        like = new Like2();
        like.lamda();

        //4、局部内部类
        class Like3 implements ILike{
            @Override
            public void lamda() {
                System.out.println("i like lamda3");
            }
        }
        like = new Like3();
        like.lamda();

        //5、匿名内部类，没有类的名称。必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lamda() {
                System.out.println("i like lamda4");
            }
        };
        like.lamda();

        //6、lamda表达式
        like = ()->{
            System.out.println("i like lamda5");
        };
        like.lamda();
    }
}


//1、定义一个只有一个抽象方法的接口
interface ILike{
    abstract void lamda();
}

//2、实现类
class Like implements ILike{

    @Override
    public void lamda() {
        System.out.println("i like lamda1");
    }
}

输出：

带一个参数的Lamda简化

package com.haiyang.lamda;

public class TestLamda02 {

    public static void main(String[] args) {
        ILive live = null;

        //Lamda简化
        live = (int a)->{
            System.out.println("I live you"+a);
        };
        live.live(1);

        //Lamda简化参数类型
        live = (a)->{
            System.out.println("I live you"+a);
        };
        live.live(2);

        //Lamda简化括号
        live = a->{
            System.out.println("I live you"+a);
        };
        live.live(3);

        //Lamda简化花括号（只有一条语句时）
        live = a->System.out.println("I live you"+a);
        live.live(4);
    }

}

interface ILive{
    abstract void live(int a);
}

输出：

带多个参数的Lamda简化

package com.haiyang.lamda;

public class TestLamda02 {

    public static void main(String[] args) {
        ILive live = null;

        //Lamda简化
        live = (int a,int b)->{
            System.out.println("I live you"+a+b);
        };
        live.live(1,1);

        //Lamda简化参数类型（要去掉就要都去掉）
        live = (a,b)->{
            System.out.println("I live you"+a+b);
        };
        live.live(2,2);


        //Lamda简化花括号（只有一个语句时）
        live = (a,b)->System.out.println("I live you"+a+b);
        live.live(3,3);
    }

}

interface ILive{
    abstract void live(int a,int b);
}

输出：