Java8 Lambda 表达式总结

最新推荐文章于 2023-05-09 16:55:05 发布
最新推荐文章于 2023-05-09 16:55:05 发布
阅读量431 收藏
点赞数 1
分类专栏： Java Lambda 文章标签： Java Lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38637066/article/details/83042358
版权
Java 同时被 2 个专栏收录
19 篇文章 0 订阅
订阅专栏
Lambda
1 篇文章 0 订阅
订阅专栏
  1. 最简单的Lambda 表达式 x-> System.out.println(x);
    左边 为参数列表 参数类型写不写都行 Java JVM 会根据上下文 推断类型
    右边 结构体 为函数功能的实现。

2.语法格式一 ： 无参数，无返回值 （）->System.out.println("Hello Lambda!");

// Runnable 接口函数
 public abstract void run();

 @Test
    public void test1(){
        int num = 0;  // jdk 1.7前  必须final  1.8 后系统默认加上

        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World !" + num);
            }
        };
        r.run();

        System.out.println("================");
        Runnable r1 = () -> System.out.println("Hello Lambda");
        r1.run();

    }

上图可以看出 Lambda 使 代码更加简洁。

语法格式二： 一个参数，无返回值， 只有一个参数 小括号 可以不写
Consumer接口为Java8 的内置接口

        Consumer<String> con = (x) -> System.out.println("x");
        con.accept("Hello World");
        Consumer<String> con2 = x -> System.out.println("x");
        con2.accept("Hello World");

语法格式三：多个参数,有返回值 并且Lambda 体中有多条语句

    @Test
    public void test3(){
        Comparator<Integer> com = (o1, o2) -> {
          System.out.println("函数式接口");
          return o1.compareTo(o2);
        };
    }

语法格式四： 若 Lambda 体只有一条语句 return 和 大括号都可以不写

    @Test
    public void test4(){
        Integer num2 =  operation(100,num -> num * num);
        Integer num3 =  operation(100,num -> {return num * num;});
        System.out.println(num2);
        System.out.println(num3);
    }

二.Lambda 表达式 需要“函数式接口” 的支持

  •   函数式接口： 接口中只有一个抽象方法的接口 ， 称为 函数式接口 

  •   可以使用注解@FunctionalInterface 修饰   检查接口是否是函数式接口
  • 练习
    在这里插入图片描述

答案：
1.题目一
Employee 类

    public int id;
    public String name;
    public int age;
    public double salary;

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
// get set toString ...... 自己补充

 List<Employee> employees = Arrays.asList(
            new Employee(101, "张三", 18, 9999.99),
            new Employee(102, "李四", 59, 6666.66),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55)
    );



    @Test
    public void test1(){
        Collections.sort(employees,(e1,e2) -> {
            if(e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());`在这里插入代码片`
            }else {
                return e1.getAge() - e2.getAge();
            }
        });
        for (Employee e: employees) {
            System.out.println(e);
        }
    }

2.题目二

@FunctionalInterface
public interface MyFunction {
    String getValue (String str);
}

    @Test
    public void test2(){
        System.out.println(strHandler("\t\t\t Hello World ", str -> str.replaceAll(" ", "")));
        System.out.println(strHandler("  \t\t\t Hello World  ", str -> str.trim()));
        System.out.println(strHandler(" add \t\t\t Hello World  ", str -> str.toUpperCase()));
        System.out.println(strHandler(" add \t\t\t Hello World  ", str -> str.substring(0,4)));
    }

    public String strHandler(String str,MyFunction mf){
        return mf.getValue(str);
    }

3.题目三

@FunctionalInterface
public interface MyFunction2<T,R> {
    R getValue(T t1,T t2);
}

    // 需求 ： 对两个 long 型数据进行处理
    public void op (Long l1,Long l2,MyFunction2<Long,Long> m){
        System.out.println(m.getValue(l1,l2));
    }
    @Test
    public void test3(){
        op(100l,200l,(x,y) -> x+y);
        op(100l,200l,(x,y) -> x-y);
        op(100l,200l,(x,y) -> x*y);
    }

三.Java 四大内置Lambda函数

 1.Consumer<T> :消费型接口
        void accept(T t);
        
 2.Supplier<T> :供给型接口
        T get();
 3.Function<T,R> :函数型接口
        R apply(T t);
 4. Predicate<T> : 断言型接口
        boolean test(T t);

package java8.lambda;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @program: java8
 * @description:
 * @author: ChenYu
 * @create: 2018-10-13 20:24
 **/

public class TestLambda04 {


    /*
         1.Consumer<T> :消费型接口
          void accept(T t);
    * */
    @Test
    public void test(){
        happy(10000,(x) -> System.out.println("消费 " + x +  "元"));
    }
    public void happy(double money, Consumer<Double> con){
        con.accept(money);
    }


    /*
     2.Supplier<T> :供给型接口
     T get();
    */

    /* 产生指定个数的整数 并放入 集合中*/
    @Test
    public void test2(){
        List<Integer> list = getNumList(10,() -> (int) (Math.random() * 100));
        list.stream().forEach(System.out::println);
    }

    public List<Integer> getNumList(int num, Supplier<Integer> sup){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(sup.get());
        }
        return list;
    }




    /*
        3.Function<T,R> :函数型接口
        R apply(T t);
    */

    /*
       用于处理字符串
    * */
    @Test
    public void test3(){
        System.out.println(strHandler("\t\t\t Hello World ", str -> str.replaceAll(" ", "")));
        System.out.println(strHandler("  \t\t\t Hello World  ", str -> str.trim()));
        System.out.println(strHandler(" add \t\t\t Hello World  ", str -> str.toUpperCase()));
        System.out.println(strHandler(" add \t\t\t Hello World  ", str -> str.substring(0,4)));
    }

    public String strHandler(String str, Function<String,String> function){
        return function.apply(str);
    }


   /*

     4. Predicate<T> : 断言型接口
          boolean test(T t);
    */

    /*
       把满足条件的字符串放入集合中
    * */
    @Test
    public void test4(){
        List<String> list = Arrays.asList("hello","test","aaa","www","ok");
        List<String> resList = filterStr(list,s -> s.length()>=3);
        resList.stream().forEach(System.out::println);
    }

    public List<String> filterStr(List<String> list, Predicate<String> predicate){
        List<String> reslist = new ArrayList<>();
        for (String s : list) {
            if(predicate.test(s)){
                reslist.add(s);
            }
        }
        return reslist;
    }




}

Lambda的优点演示
1.新建一个Employee 类

 public int id;
    public String name;
    public int age;
    public double salary;

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
// 省略 get set toString等

2.首先有一个需求 是能根据员工的年龄或者工资进行过滤。
最原始的写法如下 这样代码冗长，可读性不好。

 List<Employee> employees = Arrays.asList(
            new Employee(101, "张三", 18, 9999.99),
            new Employee(102, "李四", 59, 6666.66),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55)
    );



    public List<Employee> filterByAge(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee employee: list) {
            if(employee.age >= 35){
                emps.add(employee);
            }
        }
        return emps;
    }

    public List<Employee> filterBySalary(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee employee: list) {
            if(employee.salary >= 5000){
                emps.add(employee);
            }
        }
        return emps;
    }
    
   @Test
    public void mytest(){
        List<Employee> emps = filterByAge(employees);
        for (Employee e: emps) {
            System.out.println(e);
        }
        System.out.println("-------------------");
        emps = filterBySalary(employees);
        for (Employee e: emps) {
            System.out.println(e);
        }
    }

3.用策略模式进行优化的写法
新建MyPredicate 类

@FunctionalInterface
public interface MyPredicate<T> {
    boolean test(T t);
}

分别写两个实现类实现该接口

public class FilterEmployeeByAge implements  MyPredicate<Employee>{
    @Override
    public boolean test(Employee employee) {
        return employee.age >= 30;
    }
}
public class FilterEmployeeBySalary implements  MyPredicate<Employee>{
    @Override
    public boolean test(Employee employee) {
        return employee.salary>=5000;
    }
}

测试


    // 优化方式 1  策略设计模式
    // 缺点 类太多
    // 提取共同代码
    public List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
        List<Employee> emps = new ArrayList<>();
        for (Employee employee: list) {
            if(mp.test(employee)){
                emps.add(employee);
            }
        }
        return emps;
    }


    @Test
    public void test4(){
        List<Employee> emps = filterEmployee(employees,new FilterEmployeeByAge());
        for (Employee e: emps) {
            System.out.println(e);
        }
        System.out.println("-----------------------");
        emps = filterEmployee(employees,new FilterEmployeeBySalary());
        for (Employee e: emps) {
            System.out.println(e);
        }

    }

在此基础上可以使用匿名内部类

  // 优化方式二  匿名内部类
    @Test
    public void test5(){
        List<Employee> emps = filterEmployee(employees, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.age>=30;
            }
        });
        for (Employee e: emps) {
            System.out.println(e);
        }
        System.out.println("-----------------------");
        emps = filterEmployee(employees, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.salary>=3000;
            }
        });
        for (Employee e: emps) {
            System.out.println(e);
        }
    }

Lambda表达式写法


    // 优化方式三  lanbda 表达式

    @Test
    public void test6(){
        List<Employee> emps = filterEmployee(employees,(e) -> e.getAge()>=30);
        emps.forEach(System.out::println);
        System.out.println("-----------------------");
        emps = filterEmployee(employees,employee -> employee.getSalary()>=5000);
        emps.forEach(System.out::println);
    }

// 优化方式四 lanbda 表达式 +streamAPI

@Test
public void test7(){
    employees.stream().filter((employee -> employee.getAge()>=30)).forEach(System.out::println);
    System.out.println("===================");
    employees.stream().filter((employee -> employee.getSalary()>=5000)).forEach(System.out::println);
    System.out.println("==================");
    employees.stream().filter((employee -> employee.getSalary()>=5000)).limit(2).forEach(System.out::println);
}

项目地址：https://github.com/xiaoshabi2/java8
努力的_码农
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java8 lambda表达式学习总结
04-23
NULL 博文链接：https://shmilyaw-hotmail-com.iteye.com/blog/2251821
Java语法基础
裴鹏飞的博客
07-07 216
运算符与语法 修改：根据乔俊龙同学意见，做整体修改。  编程语言，计算数据并得到预期的结果。首先要有保存中间数据的容器。用于数据读取、中间量暂存、结果数据在被获取之前。 下面的例子是一个java的数据模型。我们称为Java bean。其中会说明上述的java语法规范。 Java数据模型是一种将数据与其行为集成在一起的模式。 使用JavaBean时，我们需要在应用程序中加
Java8 Lambda表达式教程
热门推荐
io
10-16 26万+
Java8新特性，Lambda表达式与集合类bulk operation教程。迄今为止最全面的中文原创java lambda表达式教程。
Java 1.8新特性
m0_60600640的博客
02-10 380
Lambda: Lambda表达式是一种没有名字的函数,也可称为闭包，是Java 8 发布的最重要新特性。 本质上是一段匿名内部类，也可以是一段可以传递的代码。 还有叫箭头函数的 特点: 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 使用 Lambda 表达式可以使代码变的更加简洁紧凑。 应用场景: 列表迭代 Map映射 Reduce聚合 代替一个不想命名的函数或是类，该函数或类往往并不复杂。 想尽量缩短代码量的各个场景均可以 语法特点: 可选类型声明：不需要...
java8 :: 用法 （JDK8 双冒号用法）
xuxiake的博客世界
09-15 718
java8中新增的箭头符号x -> methodParam.accept(x)，其实它相当于methodParam::accept，主要是配合forEach之类的往方法中传值。 public class AcceptMethod { static void printValur(String str){ System.out.println("print valu...
JDK8新特性Lambda了解一下
qq_44779847的博客
06-24 148
这里写目录标题Lambda 表达式lambda表达式的重要特征:Lambda 表达式实例注意 Lambda 表达式 Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。 lambda表达式的重要特征: 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。 可选的大括号：如果主体包
Java特殊符号用法
XinYuDaHai的博客
03-24 2967
1. 类名::方法名 叫做method reference，效果等价于lambda表达式（x->fun()），都是functional interface实例的简写，编译器会将自动将其转换为实例对象）
java 8 lamda Stream的Collectors.toMap 参数
lixixi
04-30 771
摘自： https://www.cnblogs.com/ampl/p/10904306.html java 8 lamda Stream的Collectors.toMap 参数 使用toMap()函数之后，返回的就是一个Map了，自然会需要key和value。 toMap()的第一个参数就是用来生成key值的，第二个参数就是用来生成value值的。 第三个参数用在key值冲突的情况下：如果新元素产...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
lambda表达式是JAVA8中提供的一种新的特性，它支持Java也能进行简单的“函数式编程”。 下面这篇文章主要给大家介绍了关于Java8新特性Lambda表达式的一些复杂用法的相关资料，需要的朋友可以参考借鉴，下面来一起看...
Java 8 lambda表达式
06-27
java lambda表达式,lambda 表达式基本上表达了函数式接口的实例（具有单一抽象方法的接口称为函数式接口。一个例子是 java.lang.Runnable）。lambda 表达式实现了唯一的抽象函数，因此实现了函数式接口 lambda ...
Java8之lambda表达式基本语法
08-29
本文通过示例大家给大家介绍了java8之lambda表达式的基本语法，感兴趣的的朋友一起看看吧
java8lambda表达式Demo
12-28
java8lambda表达式的安卓Studio工程Demo，供初步学习使用
Java中Lambda表达式的使用
程序员的博客
03-26 6万+
此笔记仅用作复习使用：https://www.cnblogs.com/franson-2016/p/5593080.html Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda表达式还增强了集合库。...
Java中Lambda表达式使用及详解
qq_45263520的博客
03-27 7万+
Java中Lambda表达式使用及详解 前言 一、Lambda表达式的简介 Lambda表达式（闭包）：java8的新特性，lambda运行将函数作为一个方法的参数，也就是函数作为参数传递到方法中。使用lambda表达式可以让代码更加简洁。 Lambda表达式的使用场景：用以简化接口实现。 关于接⼝实现，可以有很多种⽅式来实现。例如：设计接⼝的实现类、使⽤匿名内部类。 但是lamb
Java学习——lambda表达式
qq_45944185的博客
03-04 8488
lambda表达式
【Java基础】Java Lambda表达式详解
yubao0723的专栏
03-01 1万+
java8 中引入的 Lambda 表达式真的是个好东西，掌握之后，写代码更简洁了，一起来看看 Lambada 表达式常见的写法，加深理解。
java lambda表达式详解
2301_76965813的博客
05-09 4035
能对函数式接口起作用**。这很容易理解，如果一个接口有多个待实现的方法，Lambda表达式就不能分辨出它现在是对接口中哪个方法进行实现。
Java 8 的新特性和改进总览
CTO=开发管理+架构+技术专栏
04-29 1081
这篇文章是对Java 8中即将到来的改进做一个面向开发者的综合性的总结，JDK的这一特性将会在2013年9月份发布。 在写这篇文章的时候，Java 8的开发工作仍然在紧张有序的进行中，语言特新和API仍然有可能改变，我会尽我最大的努力保持这份文档跟得到Java 8的改动。 Java 8的预览版，也就是 “Project Lambda”，现在可以从java.net下载到。 我使用了I
Springboot aop 实现全局配置事务
qq_38637066的博客
09-20 9200
1.springboot实现事务只需要 在头上加上@Transactional注解 @Transactional 默认只捕获RuntimeException.class 对Exception异常得需要 @Transactional(rollbackFor = {Exception.class}) 捕获回滚。 2.当项目特别大的时候，对所有的service 都加上事务 ，显得非常麻烦。可以通过ao...
java8 lambda表达式
最新发布
09-13
Java 8引入了Lambda表达式作为这个版本的一个重要特性。...总结来说，Java 8的Lambda表达式是一种用于实现接口中抽象方法的匿名函数，通过简洁的语法和灵活的使用方式，可以使代码更加简洁和可读性更高。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值