JAVA lambda表达式奇淫技巧

lamda表达式

传统代码空间的设置操作

package org.example.lambda;

public class theFirstLambda {
    public static void main(String[] args) {
        //这是基本的实现匿名内部类操作的理解
        //匿名内部类一般都是用来实现接口所定义的方法操作的
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程执行操作了");
            }
        });
        thread.start();
    }
}

利用lambda操作实现匿名表达式操作

package org.example.lambda;

public class theFirstLambda {
    public static void main(String[] args) {
        //这是基本的实现匿名内部类操作的理解
        //匿名内部类一般都是用来实现接口所定义的方法操作的
        Thread thread=new Thread(()->{
            System.out.println("这是匿名表达式操作理解");
        });
        thread.start();
    }
}

• 底层中，java虚拟机并不会对lambda表达式的对象生成对应的匿名内部类的表达文件，总体对空间来说其实也没有节省多少，其实是将匿名内部类内嵌到主类之中了

• 利用javap -v完全可以查看相关的字节码文件操作

  • 通过对lambda的底层字节码的深入理解你完全可以看到，虚拟机在执行的时候是会对其中的匿名内部类进行一定的操作的，这就完全不是一种模糊化的理解了，我好像发现了新大陆，这个大陆能否让我成为大神，应该会是一把钥匙，真正的深入这个虚拟机底层了！！！

  Java以及IDEA下查看字节码的五种方法_怎么看文件字节码-CSDN博客

  主类的字节码文件

匿名内部类的字节码文件

• 很明显的看见，两个类是相互调用的关系，但是使用了lambda的语法糖操作，看看底层会有什么变化吧

两个方法形成了内嵌操作，并且其中自动生成了一个对应的匿名表达式的类，这个类就是匿名表达式的底层构造方法

• 关于24的堆栈信息操作理解，很明显出现了一个自动生成的方法，也就是对应的总体的字节码信息理解！

Exception in thread "Thread-0" java.lang.RuntimeException: 这里是线程异常操作
	at org.example.lambda.theFirstLambda.lambda$main$0(theFirstLambda.java:8)
	at java.base/java.lang.Thread.run(Thread.java:834)

• 利用抛出异常的形式也能发现，使用Lambda操作实现了一个自动类的操作理解

好了，说了这么多，我就来讲讲lambda表达式的常用的情形吧，Lambda一般用于实现接口的抽象方法，利用lambda可以不去实现接口的实现类，减少代码量，但是总的来说，这是java的一种语法糖，我觉得这种写法在平时的操作之中还是蛮装逼的，但是lambda用于实现接口的方法确实是非常的优质，减少了底层代码的空间利用率，确实是比较好的，看读者喜欢那种吧

实现一个自定义类的lambda表达式的demo

package org.example.lambda.testInterface;

@FunctionalInterface
public interface theTestInterface {
    String backString(Integer index);
}

• 如果一个接口需要实现lambda表达式，那么这个接口必须使用@FunctionalInterface注解，这样才能使用lambda语法，不然总体程序还是会出现一定的错误

theTestInterface theTestInterface=(Integer i)-> "this is why we play:"+i;
        //这样的实现就显然比较强大了，直接使用引用操作来进行传输对象的参数
        System.out.println(theTestInterface.backString(3));

利用匿名表达式来对接口的方法进行实现，确实减少了很大的代码量，并且我觉得底层空间也是减少了的

lambda与cpp方法引用

这里使用lambda表达式操作，为代码书写者提供了一些cpp的性能特性，我其实对cpp并不熟悉，但是这里所体现的思想也是一致的，利用一个类中的方法引用来实现接口的抽象方法，这种对应连接关系是非常优质的吗，也是这个小技巧所教会我的东西，可以理解为指针进行连接的操作!

		theTestInterface theTestInterface2=thelambda::backString;
        //传递方法的引用相当于进行了实现操作，这里操作接口的方法是非常强大的
        System.out.println(theTestInterface2.backString(3));
        //利用相关的操作实现的其他操作
        thelambda thelambda=new thelambda();
        //方法引用好像指针理解操作
        theTestInterface theTestInterface3=thelambda::backNoStaticString;
        System.out.println(theTestInterface3.backString(9));
    }
    public static String backString(Integer i){
        return "this is the string:"+i;
    }
    public String backNoStaticString(Integer i){
        return "why we want to be:"+i;
    }

• 如果是静态方法，可以直接利用主类进行引用
• 如果是非静态的方法，那么需要进行对象的创建，然后进行引用

读者肯定对这里非常熟悉了，这其实就是一种指针的思想，当然了在java中肯定比在c中更加安全！

只要实现了上述注解的类或者接口

都能使用lambda表达式进行操作，并且都能使用方法引用操作

package org.example.lambda.theArrayLambda;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;

public class theArrayLambda {

    //方法引用传递操作，本质还是指针操作理解！
    public static void main(String[] args) {
        Integer[] integer=new Integer[] {8,234,32,25,6,523,1,2,2345};
        //注意参数之间的操作实现
		Arrays.sort(integer,Integer::compare)
        //可以利用返回值操作来进行对比操作，但是这种方式是否真的比较灵活呢?
        //降序排列实现操作
        Arrays.sort( integer,theArrayLambda::smallCompare);
        System.out.println(Arrays.toString(integer));
    }
    //仅仅只是升序操作，这不也是默认的操作理解吗
    public static int smallCompare(int x,int y){
        return (x>y) ? -1:((x==y)?0:1);
    }
}

• 可以利用返回值进行方法引用
• 也可以利用相关的自定义对象进行引用

还有就是一定要习惯三元表达式，这个表达式也是一个降低代码量，并且可以提升抽象能力的代码技巧！

我是一名热爱生活的程序员，欢迎关注我的博客！