java成神之路——Lamda表达式推导

最新推荐文章于 2024-09-21 23:21:04 发布
最新推荐文章于 2024-09-21 23:21:04 发布
阅读量311 收藏 2
点赞数 2
分类专栏： Thread 文章标签： java lambda 接口 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37439086/article/details/111224707
版权

Lamda表达式

  • λ希腊字母表中排名第11位的字母，英文名称位Lamda。
  • 使用lamda表达式避免内部内定义过多
  • 其实质属于函数式编程
为什么要使用Lamda表达式
  • 避免内部内定义过多
  • 可以让代码看起来更加简洁
  • 去掉了没有意义的代码，保留了核心的代码
学习lamda前需要明白
  1. 理解Funcation Interface（函数式接口）是学习java8 lamda表达式的关键所在。
  2. 函数式接口的定义
    任何接口如果只包含唯一一个抽象方法，那么它就是一个函数式接口
    public Interface Runnable{
    public abstract void run();
    }
  3. 对于函数式接口，我们可以通过lamda表达式来创建该接口的对象

*** 现在我们用代码来推导Lamda公式**

  1. 定义一个函数式接口
interface ILike{
    void  lambda();
}
  1. 实现类
package lamda;

public class TestLamda {
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda");
    }
}
  1. 这里使用外部类我们会觉得比较麻烦，于是我们变把外部类放入静态内部类
package lamda;

public class TestLamda {
//静态内部类
   static class  Like implements  ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda1");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        Like like1 = new Like();
        like1.lambda();
    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda");
    }
}
  1. 这里我们使用局部内部类再一次简化
package lamda;

public class TestLamda {
   static class  Like2 implements  ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();
		//局部内部类
           class  Like3 implements  ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        }
       like = new Like3();
           like.lambda();
    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda1");
    }
}
  1. 使用匿名内部类简化
package lamda;

public class TestLamda {
   static class  Like2 implements  ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

           class  Like3 implements  ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        }
       like = new Like3();
           like.lambda();

           //匿名内部类，没有类的名称，必须借助接口或者父类
           like = new ILike() {
               @Override
               public void lambda() {
                   System.out.println("I Like Lambda4");
               }
           };
           like.lambda();
           
           //
    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda1");
    }
}
  1. 现在已经没有名字了，我们又该怎样简化呢？Jdk1.8 用lambda简化
package lamda;

public class TestLamda {
   static class  Like2 implements  ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

           class  Like3 implements  ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        }
       like = new Like3();
           like.lambda();

           ~~~~//匿名内部类，没有类的名称，必须借助接口或者父类
           like = new ILike() {
               @Override
               public void lambda() {
                   System.out.println("I Like Lambda4");
               }
           };~~~~  
           
           like.lambda();
            ***//用LAmbda简化 ,去掉接口和方法，因为只有一个方法；
        like = ()->{
                System.out.println("I Like Lambda5");
        };
        like.lambda();***

    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda1");
    }
}

这里再给大家举例一个带参数的简化过程，就不一步步说明了，直接把简化好的代码送上

package lamda;

public class TeatLambda2 {
    // 2 .使用静态内部类简化

   static class Love2 implements  Ilove{
        @Override
        public void love(int a) {
            System.out.println("I Love YOu"+a);
        }
    }

    public static void main(String[] args) {
        Ilove love = new Love();
        love.love(2);
        love = new Love2();
        love.love(3);
        // 3. 使用局部内部类简化
         class Love3 implements  Ilove{
            @Override
            public void love(int a) {
                System.out.println("I Love YOu"+a);
            }
        }
        love = new Love3();
         love.love(4);
         // 4. 使用匿名内部类简化
         love = new Ilove() {
             @Override
             public void love(int a) {
                 System.out.println("I Love You"+a);
             }
         };
         love.love(5);
        //5. 使用lamda表示简化
         love = (int a) ->{
             System.out.println("I Love You"+a);
         };
         love.love(6);
         //简化5.1 去掉参数类型
        love = (a) ->{
            System.out.println("I Love You"+a);
        };
        love.love(7);
        //简化5.2 去掉括号
        love = a ->{
            System.out.println("I Love You"+a);
        };
        
        love.love(8);
        //简化5.3 去掉花括号
        love = a -> System.out.println("I Love You"+a);
        love.love(9);
       
}
}

interface  Ilove{
    void love(int a);
}
// 1.使用外部类
class Love implements  Ilove{
    @Override
    public void love(int a) {
        System.out.println("I Love YOu"+a);
    }
}

总结

        * lamda表达式只有一行代码的情况才能简化成一行，如果有多行那么用代码块包裹
        *  前提是接口为函数式接口
       * 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号
java之Lamda表达式的介绍
m0_64365419的博客
12-25 2281
λ希腊字母表中排序第11位的字母，英文名称为Lambda，它Lambda表达式是Java SE 8中一个重要的新特性，允许通过表达式来代替功能接口，它与其他方法相同，提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)，在上述代码中，我们没有创建实现类[fun_test1]的实例化对象就实现了具体的show()方法,通常，我们也。Lambda表达式允许你直接把一个代码块赋值给一个变量。在讲如何使用Lamda表达式之前，我们先来学习一下。，那么它就是一个函数式接口，
Java8新特性——Lambda表达式
m0_64354070的博客
11-28 1396
Java8新特性——Lambda表达式 2.1 什么是Lambda表达式？ 2.2 为什么要使用Lambda表达式？ 2.3 从匿名内部类到 Lambda 的转换 3.1 语法一：无参无返回值，Lambda 体只需要一条语句 3.2 语法二：传递一个参数，无返回值 3.3 语法三：传递一个参数时，参数的小括号可以省略，无返回值 3.4 语法四：传递两个参数，有返回值 3.5 语法五：当 Lambda 体只有一条语句时，return 与大括号可以省略 4.1
python基础 推导式
wangyunchao_03的博客
02-24 955
#三元操作符 i=1 if i==1: print('i==1') else: print('i!=1') i==1 r=True if 1==1 else False print(r) # 可以把python 列表推导式理解为，利用其创建新列表list的一个简单方法。列表推导式比较像for循环语句，必要时也可以加入if条件语句完善推到式。 # 列表推导式标准格式 # 也就是：[...
java Lambda 推导
Small zhou的博客
09-06 145
Lambda 说明 package com.example.demo.bean; public class TestLambda1 { //3.静态内部类 static class Like2 implements ILike{ @Override public void lambda() { System.out.println("i like lambda2"); } } public st
lambda表达式的推导过程和简化过程
weixin_43393069的博客
08-18 398
推导过程 lambda表达式的基础是函数式接口即只定义一个方法的接口 /* 推导lambda表达式 */ public class TestLambda01 { //3.静态内部类 static class Like2 implements ILike { @Override public void lambda() { System.out.println("I like lambda2!"); } }
列表推导式
weixin_33827965的博客
05-28 192
Date: 2019-05-28 Author: Sun 什么是列表推导式？ ​ 列表推导能非常简洁的构造一个新列表:只用一条简洁的表达式即可对得到的元素进行转换变形。 ​ 格式 [表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件] result = [] for value in collection: if condition: ...
Java 入门指南：Java 8 新特性 —— Lambda 表达式
热带鱼的技术博客
09-21 1596
Java Lambda 表达式是 Java 8 引入的一个功能，它允许以更简洁的方式编写函数式接口的实现。 Lambda 表达式可以被认为是一种匿名函数，它没有名称，但有参数列表、函数体和可能的异常列表。它可以用来替代使用匿名内部类实现函数式接口的方式 Lambda 表达式可以简化代码，使代码更加简洁、可读性更强，尤其在使用函数式接口和结合 Java Stream API 进行编程时非常有用。
Java——lambda表达式的几种用法
weixin_55989490的博客
06-01 1359
java——lambda表达式的几种用法
学习Java 8【Lamda表达式开发】免费视频
11-22
本课程主要针对于Java 8（JDK 1.8）的新特性Lamda表达式进行了全面讲解。讲解了java基于函数编程的语法，以及与Lamda表达式操作有关的内建接口、批处理、MapReduce数据分析汇总处理。
Day7:列表和列表推导式
Ka_neki的博客
12-07 722
1.列表相关的运算符 1)数学运算符:+、* #列表1 + 列表2 - 将两个列表中的元素合并产生一个新的列表 list1 = [100,200,300] list2 = [10,20] print(list1 + list2) # [100,200,300,10,20] #列表 * N - 列表重复N次产生一个新的列表 list2 = [10,20] print(list2 * 3) # [10,20,10,20,10,20] 2)比较运算符:>、<、>=、&lt
day 7
ZX152811的博客
12-07 202
day 7列表和列表推导式 1、列表相关运算符 1.1数学运算符+、* 1.1.1 + 列表1+列表2——功能：将两个列表中的元素合并产生一个新的列表 不影响原列表 list1 = [100, 200, 300] list2 = [10, 20] print(list1 + list2) # [100, 200, 300, 10, 20] 1.1.2 * 列表*N N*列表 N个列表相加——列表中的元素重复N次，产生一个新的列表 print(list2 * 3) # [10, 20, 10,
python学习day07
qq_44981522的博客
12-07 226
python学习day07 一、列表相关的运算符 1.数学运算符：+、* 列表1 + 列表2 - 将两个列表中的元素合并产生一个新的列表 list1 = [100, 200, 300] list2 = [10, 20] print(list1 + list2) # [100, 200, 300, 10, 20] 列表 * N / N * 列表 - 列表中的元素重复N次产生一个新的列表 print(list2 * 3) # [10, 20, 10, 20, 10, 20] print(lis
列表推导式的条件判断语句
mygodit的博客
03-01 2625
常用的列表推导式的条件判断有两种写法: 第一种: [value for value in value_list if value.endswith(“sq”)] 第二种 [value.replace(“sq”, “xl”) if value.endswith(“sq”) else value for value in value_list] ...
列表推导式+lambda表达式的激情
SineIO
03-16 4629
Python这么优雅的语言，我也是醉了......事情由一段代码引发，请看：上述的列表推导式+lambda表达式+for循环，他们碰撞出来的结果搞的人晕头转向，咱们逐步来分析一下他们到底是个什么鬼。lambda表达式可以表示成：def func(x): return x*i加上for循环：for i in range(10): def func(x): return...
列表推导式&生成器表达式
qq_37493425的博客
01-21 574
egg_list=['鸡蛋%s'%i for i in range(10)] #列表推导式 print(egg_list) print([i*i for i in range(10)]) #列表推导式 laomuji=('鸡蛋%s'%i for i in range(10)) #生成器表达式 print(laomuji) for dan in laomuji: print...
列表推导式的使用
qq_42281826的博客
05-24 1629
列表推导式是一种轻量级的循环创建列表，列表生成式是一种简化代码的优美方式以下使用代码，展示一下列表推导式的使用：1.生成一个0-9的列表2.根据已有的列表快速创建一个新列表3.根据存在列表创建嵌套列表4.使用if子句作为过滤器5.根据两个列表创建一个列表6.两个for循环7.三个for循环8.根据列表推导式将一个3*4的列表，快速修改为一个4*3的问题以上是几种常见的列表推导式，比for循环创建列...
java arrays.sort() lamda表达式
最新发布
01-21
### Java 中使用 Lambda 表达式对数组进行排序 在 Java 编程中，`Arrays.sort()` 方法允许开发者通过传递 `Comparator` 接口的实例来指定自定义排序逻辑。自从引入了 Lambda 表达式之后，这种操作变得更加简洁直观。 对于字符串类型的数组，如果希望按照特定规则排序（比如拼接后的数值大小），可以通过以下方式实现： ```java String[] numStringArray = {"30", "301", "9"}; // 使用Lambda表达式作为参数传入sort方法 Arrays.sort(numStringArray, (s1, s2) -> { return Integer.compare(Integer.parseInt(s2 + s1), Integer.parseInt(s1 + s2)); }); ``` 这段代码展示了如何利用 Lambda 表达式简化传统匿名内部类形式的比较器[^2]。这里的关键在于将两个字符串连接起来形成新的整数并对比其值，从而决定原始字符串之间的顺序关系。 另外一种更加紧凑的方式是采用方法引用的形式来进行相同的操作： ```java String[] numStringArray = {"30", "301", "9"}; // 使用方法引用来代替完整的lambda表达式 Arrays.sort(numStringArray, (s1, s2) -> Integer.compare( Integer.parseInt(s2 + s1), Integer.parseInt(s1 + s2)) ); ``` 此版本不仅保持了可读性，而且进一步减少了冗余代码量[^4]。 当处理更复杂的数据结构如对象列表时，也可以应用类似的技巧。例如，假设有一个学生记录列表想要基于成绩降序排列，则可以这样做： ```java List<Student> students = ...; students.sort((o1, o2) -> Double.compare(o2.getScore(), o1.getScore())); ``` 上述例子说明了即使面对不同数据类型或业务场景下的排序需求，借助于 Lambda 表达式的灵活性依然能够轻松应对[^3]。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值