本文链接： https://blog.csdn.net/weixin_44494648/article/details/99605789

Lambda表达式（1）

初步的了解，分享一下，深入学习了之后再补充分享
有如下的一段代码，有A01,A02两个类，A03是一个接口，被A02实现，之后简称1，2，3；

class A01{
    A03 a;

    public A01(A03 a) {
        this.a = a;
    }
    void kk(){
        a.mm();
    }
}

interface A03{
    void mm();
}

如果我要创建1这个类，在构造器之中就要传入一个3这个接口，可以使用如下方法：

//由于接口不能直接new ,所以要创建一个接口的实现类实现接口中的方法，再将其作为创建1这个类的初试化时的参数

class A02 implements A03{
    @Override
    public void mm() {
        System.out.println("mmm");
    }
}

//然后这样创建
 A03 a03=new A02();
new A01(a03);

其实我们可以发现完全没有必要创建2这个类；
因为创建一个接口时可以直接实现其抽象方法

这样就可以new 出一个接口

 new A03() {
            @Override
            public void mm() {
					 System.out.println("mmm");
            }
        };

同样我们也可以不用创建一个专门的类去实现接口，而是再用的时候实现以下接口中的抽象方法
代码如下

在这里，我们知道可以再
 new A01(
                new A03() {
                    @Override
                    public void mm() {
                        System.out.println("fffff");
                    }
                }
        );

再进一步：
我们想，假如，这个接口中只有这一个没有实现的方法，那我们是不是连new 这个接口都不用了，因为这并不会引发歧义，而且更简洁，java 8增加了这个表达式

new A01(
                () -> {
                    System.out.println("fffff");
                }
        );

我们可以这样理解，创建1这个类，就要一个已经实现的接口，所以首要任务就是实现接口中的抽象方法，对于1这个类来说，只要抽象方法实现了，这个类所要的信息就够了，我们可以直接将这个方法传过去。但前提是接口只有一个方法要实现，否则就会引起歧义

对于这个方法我们可以声明参数列表，以及返回值

public class Demo02 {
    public static void main(String[] args) {
        new B01(
                (int a,char b,String c)->{
                	//...实现抽象方法          	
                    return 0;
                }
        );
    }
}

//创建这个类的对象时，需要传入一个”接口对象“
class B01{
    B03 b03;

    public B01(B03 b03) {
        this.b03 = b03;
    }

    
}
interface B03{
    int mm (int a,char b,String c);
}

这个在多线程，或者TreeSet使用自定义排序时可以用到

多线程，形成死锁的代码

public class Demo01 {
    public static void main(String[] args) {
        A a=new A();
        A b=new A();
        //创建线程时，将run方法用Lambda
        new Thread(
                ()->{
                    synchronized (a){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (b){

                        }
                    }
                }
        ).start();
        
        new Thread(
                ()->{
                    synchronized (b){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (a){

                        }
                    }
                }
        ).start();
    }
}

//这个类是为类加锁
class A{

}

TreeSet使用的Conparator接口自定义顺序
（想了解这个的可以看：TreeSet使用）

 TreeSet<M> ts1=new TreeSet<M>(
                (o1,o2)->{
                    if(o1.a>o2.a){
                        return -1;
                    }else if(o1.a<o2.a){
                        return 1;
                    }else
                        return 0;
                }
        );

这个代码是这样

 TreeSet<M> ts=new TreeSet<>(new A());


//其中要创建这样的类，和多线程基本相似
//一个继承 Comparator的类其中M是M类
class A<E> implements Comparator<M>{
	//字节设置
    @Override
    public int compare(M o1, M o2) {
       if(o1.a>o2.a){
           return -1;
       }else if(o1.a<o2.a){
           return 1;
       }else
           return 0;
    }
}

Lambda表达式（1）--java学习笔记

Lambda表达式（1）

猜你喜欢