lambda表达式的使用

本文深入探讨Java 8中引入的Lambda表达式,解释其语法与优势,包括简化线程创建、函数式接口使用及与其他Java API的集成。通过实例对比传统编程方式,展示Lambda表达式的简洁性和功能性编程特性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

神奇的lambda表达式

在jdk1.8中新增加了lambda表达式,可能有的小伙伴在github上面学习别人的项目的时候会看到有这样的符号

->

一个箭头类似于JS中的箭头函数,很神奇吧,这个就是jdk8中新增的lambda表达式。

为什么我们要使用lambda表达式

有的小伙伴可能会问为什么我们要使用lambda表达式,lambda表达式采用的是函数式编程,无需关心如何实现,并且代码非常的简洁,清晰易懂,下面我们就通过一个例子来看下传统方式和使用lambda表达式实现线程

传统的模式使用线程

   new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("ok");
            }
        }).start();

用lambda实现线程

new Thread(()->System.out.println("ok")).start();

可以从上面的例子中看到,传统模式写的代码很多,比较麻烦,而使用lambda来实现,非常的简单,也非常的清晰,并且是面向函数式的,无须关心它实现了内部的接口。

lambda入门

@FunctionalInterface
interface IntNumber {
    int sayNumber(int i);
    default int add(int x,int y){
        return x + y;
    }
}
public class LambdaDemo {
    public static void main(String[]args){
    
        IntNumber i1 = (i) -> i*2;
        System.out.println(  i1.sayNumber(100));
        System.out.println(        i1.add(11,13));
        System.out.println("i1"+i1);
        
        IntNumber i2 = i -> i*2;
        
        IntNumber i3 = (int i) -> {
            System.out.println("---------");
            return i *2;
        };
    }
}

在上面中我们定义了一个IntNumber的接口,这个接口有1个默认实现sayNumber方法,也有一个jdk8的默认底层实现default add的方法,default 关键字在jdk8中新增加的,叫默认的底层实现,而在我们这个案例中,真正的默认实现是sayNumber。

 (i) -> i*2;

括号里面的i 代表要操作的变量, 其中 i*2代表的是让i的值 * 2,注意当参数只有一个的时候,i的括号是可以省略的,当参数在1个以上就要加()。

 IntNumber i3 = (int i) -> {
   System.out.println("---------");
   return i *2;
 };

(int i)是明确了参数的类型是int ,右边的逻辑被{}包裹起来,这样就可以在里面写具体的业务了。

需要注意如下:

@FunctionalInterface

这个代表的是函数接口,最好在接口上加上这个注解

在lambda中变量类型的定义

在lambda中我们可以使用普通变量类型定义,也可以使用数组,也可以强转类型实现,如下:

@FunctionalInterface
interface IMath{
    int add(int x,int y);
}

@FunctionalInterface
interface IMath2{
    int sub(int x,int y);
}

public class TypeDemo {
    public static void main(String[]args){
        //变量类型的定义
        IMath lambda = (x,y) -> x+ y;
        System.out.println(lambda.add(1,3));

        //数组里的定义
        IMath[] lambdas = {(x,y) -> x + y};
        for (IMath iMath : lambdas) {
            iMath.add(1,2);
            iMath.add(3,5);
            iMath.add(7,9);
        }

        System.out.println(lambdas);

        //强转
        Object lambda2 = (IMath)(x,y) -> x + y;

        //通过返回类型
        IMath createLambda = CreateLambda();

        TypeDemo demo = new TypeDemo();

        //当有二次性的时候使用方法强转
        demo.test((IMath) (x, y) -> x + y);
      	}

        public void test(IMath math){

        }

	    public void test(IMath2 math){
	
	    }
        public static IMath CreateLambda(){

        return (x,y) -> x + y;
    }
}

上面定义了两个接口分别是IMath 和IMath2,并且使用了@FunctionalInterface注解来声明是一个函数接口,IMath中有一个add的方法,我们通过IMath接口来使用lambda表达式。

  IMath lambda = (x,y) -> x+ y;
  System.out.println(lambda.add(1,3));

在上面我说过当有2个参数及以上的时候就要加括号了,而箭头的右边 就是逻辑了,在这里我们希望 让x和y的值相加。

IMath[] lambdas = {(x,y) -> x + y};

这个是数组的定义

Object lambda2 = (IMath)(x,y) -> x + y;

当类型为Object的时候,需要进行强转

IMath createLambda = CreateLambda();
public static IMath CreateLambda(){
  return (x,y) -> x + y;
}

我们可以接收一个静态方法方法这样使用也是没有问题的。

 TypeDemo demo = new TypeDemo();

  //当有二次性的时候使用方法强转
  demo.test((IMath) (x, y) -> x + y);
   public void test(IMath math){

   }

   public void test(IMath2 math){

  }

上面定义了2个接口 IMath和IMath2当我们调用的时候会发生报错这个时候就要明确选择哪一个了,然后进行了强转的操作。

lambda常用的一些方法

消费者接口

public class FunctionDemo {
    public static void main(String[]args){
        Predicate<Integer> predicate = i -> i > 0;
        System.out.println(predicate.test(10));

        IntPredicate intPredicate = i -> i > 10;

        System.out.println(":" + intPredicate.negate());
        //消费者函数
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("消费了数据");
    }
}

我们使用Predicate这个函数接口来使用lambda表达式

 Predicate<Integer> predicate = i -> i > 0;

我们给了Integer的泛型,当参数为一个的时候可以省略括号,右边的就是业务逻辑

predicate.test(10);

这是一个断言函数和Assert一样,返回的是boolean值。

 Consumer<String> consumer = s -> System.out.println(s);

Consumer是一个消费者函数,当左边的参数和右边要返回参数名称相同类型相同时候我们可以这样简写如下

System.out::println;
 consumer.accept("消费了数据");

accept这个方法只能接受字符串。

在lambda中使用Function函数

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

        Function<Integer,Function<Integer,Integer>> t = x -> y -> x + y;
        System.out.println("高阶函数:" + t.apply(1).apply(3));

        Function<Integer,Function<Integer,Function<Integer,Integer>>> functions = x -> y -> z -> x + y + z;

        Function<Integer,Function<Integer,Function<Integer,Function<Integer,Integer>>>>t2  =  x -> y -> z -> f -> x + y + z + f;
        System.out.println("高阶函数2:" + t2.apply(3).apply(4).apply(5).apply(6));
        System.out.println(functions.apply(3).apply(4).apply(5));
        int [] nums = {2,3,4};
        Function f = functions;
         for(int i = 0; i < nums.length; i++){
             if(f instanceof  Function){
               Object obj =  f.apply(nums[i]);
               if (obj instanceof Function){
                   f = (Function) obj;
               }else {
                   System.out.println("调用结束:" + obj);
               }
             }
         }
    }
}

使用Function这个函数来使用lambda表达式

Function<Integer,Function<Integer,Integer>> t = x -> y -> x + y;

可以看到这个Function函数接受的是Integer类型的参数,返回的是Function,然后又嵌套了一个Function,被嵌套的这个Function接受参数和返回参数都是Integer类型。

这里注意可以看出规律是一个高阶函数。

总结

lambda非常方便和JS中箭头函数十分相似,左边代表参数,箭头的右边则是逻辑业务代码,lambda语法上更加的精炼,帮我们解决很多的问题,lambda还可以结合Stream流以及jdk9中的Reactive Stream一起使用非常的强大。

当你想要在某个地方定义一个简短的匿名函数时,可以使用C++中的lambda表达式lambda表达式是C++11引入的一种特性,它允许你在需要函数对象的地方定义一个函数,而不必显式地创建一个函数对象。 下面是一个lambda表达式的基本语法: ``` [capture](parameters) -> return_type { // 函数体 } ``` - `capture`:捕获列表,用于指定lambda表达式可以访问的外部变量。可以为空`[]`,表示不捕获任何外部变量;可以使用`[var]`来捕获一个变量;可以使用`[var1, var2]`来捕获多个变量。也可以使用`[=]`来按值捕获所有外部变量,或者使用`[&]`来按引用捕获所有外部变量。 - `parameters`:参数列表,与函数的参数列表类似。可以省略参数列表,如果不需要参数的话。 - `return_type`:返回类型,用于指定lambda表达式的返回类型。可以省略返回类型,编译器会根据函数体自动推断返回类型。 下面是一个简单的例子,演示了如何使用lambda表达式来对一个整数数组进行排序: ```cpp #include <iostream> #include <vector> #include <algorithm> int main() { std::vector<int> nums = {2, 4, 1, 3}; // 使用lambda表达式排序 std::sort(nums.begin(), nums.end(), [](int a, int b) { return a < b; }); // 输出排序后的结果 for (int num : nums) { std::cout << num << " "; } return 0; } ``` 输出结果为:1 2 3 4 在这个例子中,lambda表达式被用作`std::sort`函数的第三个参数,用于指定排序的规则。lambda表达式捕获了外部变量`a`和`b`,并根据它们的大小关系来确定排序顺序。 希望这个例子可以帮助你理解lambda表达式使用。如果还有其他问题,请随时提问!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值