java8-Lambda表达式

最新推荐文章于 2024-09-15 09:47:04 发布
最新推荐文章于 2024-09-15 09:47:04 发布
阅读量88 收藏
点赞数
文章标签： java c# 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25518825/article/details/125940077
版权

1.为什么要用lambda表达式

package com.atguigu.java8;
​
public class Employee {
​
    private int id;
    private String name;
    private int age;
    private double salary;
​
    public Employee() {
    }
​
    public Employee(String name) {
        this.name = name;
    }
​
    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public double getSalary() {
        return salary;
    }
​
    public void setSalary(double salary) {
        this.salary = salary;
    }
​
    public String show() {
        return "测试方法引用！";
    }
​
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        long temp;
        temp = Double.doubleToLongBits(salary);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
​
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (age != other.age)
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
            return false;
        return true;
    }
​
    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
    }
}

优化方式一：策略设计模式需要的类

package com.atguigu.java8;
​
@FunctionalInterface
public interface MyPredicate<T> {
    public boolean test(T t);
}
package com.atguigu.java8;
​
public class FilterEmployeeForSalary implements MyPredicate<Employee> {
    @Override
    public boolean test(Employee t) {
        return t.getSalary() >= 5000;
    }
}
--------------------------------------------
package com.atguigu.java8;
public class FilterEmployeeForAge implements MyPredicate<Employee>{
    @Override
    public boolean test(Employee t) {
        return t.getAge() <= 35;
    }
}
package com.atguigu.java8;
​
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
​
import org.junit.Test;
​
public class TestLambda1 {
    
    //原来的匿名内部类
    @Test
    public void test1(){
        Comparator<String> com = new Comparator<String>(){
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }
        };
        
        TreeSet<String> ts = new TreeSet<>(com);
        
        TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>(){
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }
            
        });
    }
    
    //现在的 Lambda 表达式
    @Test
    public void test2(){
        Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());
        TreeSet<String> ts = new TreeSet<>(com);
    }
    
    List<Employee> emps = 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)
    );
​
    //需求：获取公司中年龄小于 35 的员工信息
    public List<Employee> filterEmployeeAge(List<Employee> emps){
        List<Employee> list = new ArrayList<>();
        
        for (Employee emp : emps) {
            if(emp.getAge() <= 35){
                list.add(emp);
            }
        }
        
        return list;
    }
    
    @Test
    public void test3(){
        List<Employee> list = filterEmployeeAge(emps);
        
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
    
    //需求：获取公司中工资大于 5000 的员工信息
    public List<Employee> filterEmployeeSalary(List<Employee> emps){
        List<Employee> list = new ArrayList<>();
        
        for (Employee emp : emps) {
            if(emp.getSalary() >= 5000){
                list.add(emp);
            }
        }
        
        return list;
    }
    
    //优化方式一：策略设计模式
    public List<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp){
        List<Employee> list = new ArrayList<>();
        
        for (Employee employee : emps) {
            if(mp.test(employee)){
                list.add(employee);
            }
        }
        
        return list;
    }
    
    @Test
    public void test4(){
        List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());
        for (Employee employee : list) {
            System.out.println(employee);
        }
        
        System.out.println("------------------------------------------");
        
        List<Employee> list2 = filterEmployee(emps, new FilterEmployeeForSalary());
        for (Employee employee : list2) {
            System.out.println(employee);
        }
    }
    
    //优化方式二：匿名内部类
    @Test
    public void test5(){
        List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee t) {
                return t.getId() <= 103;
            }
        });
        
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
    
    //优化方式三：Lambda 表达式
    @Test
    public void test6(){
        List<Employee> list = filterEmployee(emps, (e) -> e.getAge() <= 35);
        list.forEach(System.out::println);
        
        System.out.println("------------------------------------------");
        
        List<Employee> list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000);
        list2.forEach(System.out::println);
    }
    
    //优化方式四：Stream API
    @Test
    public void test7(){
        emps.stream()
            .filter((e) -> e.getAge() <= 35)
            .forEach(System.out::println);
        
        System.out.println("----------------------------------------------");
        
        emps.stream()
            .map(Employee::getName)
            .limit(3)
            .sorted()
            .forEach(System.out::println);
    }
}
​

2.lambda基础语法

package com.atguigu.java8;
​
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
​
import org.junit.Test;
​
/*
 * 一、Lambda 表达式的基础语法：Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符
 *                          箭头操作符将 Lambda 表达式拆分成两部分：
 * 
 * 左侧：Lambda 表达式的参数列表
 * 右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体
 * 
 * 语法格式一：无参数，无返回值
 *      () -> System.out.println("Hello Lambda!");
 * 
 * 语法格式二：有一个参数，并且无返回值
 *      (x) -> System.out.println(x)
 * 
 * 语法格式三：若只有一个参数，小括号可以省略不写
 *      x -> System.out.println(x)
 * 
 * 语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
 *      Comparator<Integer> com = (x, y) -> {
 *          System.out.println("函数式接口");
 *          return Integer.compare(x, y);
 *      };
 *
 * 语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
 *      Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
 * 
 * 语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
 *      (Integer x, Integer y) -> Integer.compare(x, y);
 * 
 * 上联：左右遇一括号省
 * 下联：左侧推断类型省
 * 横批：能省则省
 * 
 * 二、Lambda 表达式需要“函数式接口”的支持
 * 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰
 *           可以检查是否是函数式接口
 */
public class TestLambda2 {
    
    @Test
    public void test1(){
        int num = 0;//jdk 1.7 前，必须是 final
        
        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();
    }
    
    @Test
    public void test2(){
        Consumer<String> con = x -> System.out.println(x);
        con.accept("我大尚硅谷威武！");
    }
    
    @Test
    public void test3(){
        Comparator<Integer> com = (x, y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x, y);
        };
    }
    
    @Test
    public void test4(){
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    }
    
    @Test
    public void test5(){
//      String[] strs;
//      strs = {"aaa", "bbb", "ccc"};
        
        List<String> list = new ArrayList<>();
        
        show(new HashMap<>());
    }
​
    public void show(Map<String, Integer> map){
        
    }
    
    //需求：对一个数进行运算
    @Test
    public void test6(){
        Integer num = operation(100, (x) -> x * x);
        System.out.println(num);
        
        System.out.println(operation(200, (y) -> y + 200));
    }
    
    public Integer operation(Integer num, MyFun mf){
        return mf.getValue(num);
    }
}

需要的函数式接口

package com.atguigu.java8;
//函数式接口
@FunctionalInterface
public interface MyFun {
    public Integer getValue(Integer num);
    
}

3.练习

package com.atguigu.exer;
​
@FunctionalInterface
public interface MyFunction {
    public String getValue(String str);
}
package com.atguigu.exer;
​
public interface MyFunction2<T, R> {
   public R getValue(T t1, T t2);
}
package com.atguigu.exer;
​
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
​
import org.junit.Test;
​
import com.atguigu.java8.Employee;
​
public class TestLambda {
    
    List<Employee> emps = 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)
    );
    //1.调用Collections.sort() 方法，通过定制排序比较两个Employee (先按年龄比，年龄相同按姓名比)，使用Lambda作为参数传递。
    @Test
    public void test1(){
        Collections.sort(emps, (e1, e2) -> {
            if(e1.getAge() == e2.getAge()){
                    return e1.getName().compareTo(e2.getName());
            }else{
                return -Integer.compare(e1.getAge(), e2.getAge());
            }
        });
        
        for (Employee emp : emps) {
            System.out.println(emp);
        }
    }
    //2.①声明函数式接口， 接口中声明抽象方法，public String getValue(String str);
    //②声明类TestLambda，类中编写方法使用接口作为参数，将一个字符串转换成大写，并作为方法的返回值。。
    //③再将一个字符串的第2个和第4个索引位置进行藏取子串。。
    @Test
    public void test2(){
        String trimStr = strHandler("\t\t\t 我大尚硅谷威武   ", (str) -> str.trim());
        System.out.println(trimStr);
        
        String upper = strHandler("abcdef", (str) -> str.toUpperCase());
        System.out.println(upper);
        
        String newStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));
        System.out.println(newStr);
    }
    //需求：用于处理字符串
    public String strHandler(String str, MyFunction mf){
        return mf.getValue(str);
    }
​
    //3.①声明一个带两个泛型的函数式接口，泛型类型为<T, RP τT为参数，R为返回值。
    //②接口中声明对应抽象方法。
    //③在TestLambda 类中声明方法，使用接口作为参数，计算两个long 型参数的和。。
    //④再计算两个long 型参数的乘积。
    @Test
    public void test3(){
        op(100L, 200L, (x, y) -> x + y);
        
        op(100L, 200L, (x, y) -> x * y);
    }
    
    //需求：对于两个 Long 型数据进行处理
    public void op(Long l1, Long l2, MyFunction2<Long, Long> mf){
        System.out.println(mf.getValue(l1, l2));
    }
​
}
​
自由自在1039
关注
JAVA8-Lambda表达式
guanglihuan的专栏
03-25 749
Lambda表达式是Java 8中引入的一项特性，它提供了一种简洁的方法来表示只有一个方法的接口（即函数式接口）的实例。Lambda表达式通常用于创建匿名方法。这种表达式是函数式编程的核心，允许开发者写出更简洁、更灵活的代码。
java8--Lambda表达式
qq_48019875的博客
01-20 862
目录一、Java 8 Lambda表达式1、出现的背景2、Lambda表达式简介 一、Java 8 Lambda表达式 1、出现的背景 2、Lambda表达式简介
thymeleaf-extras-java8time-3.0.4.RELEASE.jar
12-10
thymeleaf-extras-java8time-3.0.4.RELEASE.jar
Java8新特性_Lambda基础语法@2018-05-31
qq_34983808的博客
05-31 180
1、基础语法 package com.atguigu.java8; import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.function.Consumer; ...
【java】java8 time
lihuapiao的专栏
04-12 744
1.前言 Java 8 之前的 时间api 一直不太理想，后来出现了 标准的 日期 时间 类库—— Joda-time Java 8  增加了 java.time 包，实现了 JSR-310 协议 2.api 介绍 // 以下api 均是不可变的并且是线程安全的 ZonedDateTime: 带有 时区 的 日期时间,存储了所有的日期，时间字段，例如：2007-12-03T10:15:...
如何：带有Thymeleaf和Spring Boot的Java 8日期和时间
最佳 Java 编程
05-31 834
如果您碰巧使用Spring Boot和Thymeleaf，并且需要在视图中格式化Java 8 Date＆Time对象，则可以使用thymeleaf-extras-java8time –用于Java 8 Date＆Time API的Thymeleaf模块。 向现有的基于Maven或Gradle的Spring Boot项目中添加thymeleaf-extras-java8time就像添加依赖...
java8 time year_java8处理日期和时间
weixin_33183792的博客
02-13 261
自省：java8用了好久了，虽然一直知道有新的时间API，但是一直用java.util.Date用习惯了，也没有特意的去了解java8的时间类java.time，虽然效果同样达到了，但不是当前最适当的方式，以后要吸取教训。在java8中，java.time包下主要包含下面几个主要的类：Instant：时间戳，相当于java.util的DateLocalDate：只包含日期，比如：2016-10-2...
Java - Lambda 表达式
Erzbir的博客
06-09 1436
Java Lambda 表达式笔记
java8-lambda表达式的基础使用.pdf
07-05
Java 8 中 Lambda 表达式的基础使用 Java 8 中的 Lambda 表达式是 Java 8 中最流行最常用的功能特性之一。它将函数式编程概念引入 Java，函数式编程的好处在于可以帮助我们节省大量的代码，非常方便易用，能够大...
java8看不到源码-java8-lambda-samples:伴随我关于Java8lambda表达式的闪电演讲的代码
06-04
Java 8 是一个重要的 Java 发行版本，引入了许多新特性，尤其是对函数式编程的支持，其中最引人注目的就是 lambda 表达式。Lambda 表达式是 Java 8 的核心亮点，它使得代码更加简洁、易读，特别是在处理集合和回调...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
常用函数式接口_Function
weiyoo55的博客
08-02 1865
1.Function<T,R>接口 java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据， 前者称为前置条件，后者称为后置条件。 Function接口中最主要的抽象方法为：R apply(T t),根据类型T的参数获取类型R的结果 使用的场景例如：将String类型转换为Integer类型 package com.FunctionalInterface.Function; import java.util.fun
Java8之新特性--Date/Time API详解
炸鸡小子的博客
03-21 8710
本章主要为大家讲下Java8中的Date/Time API，这次更新弥补了Java对时间类型的短板！ 一、概念： 1、Java8 Date/Time API相关的类：LocalDate，LocalTime，LocalDateTime，这三个类有一个公共特点就是同String类一样，都是密封类（final修饰），不允许继承（都位于java.time包下） 他们都有什么区别呢？ 2、Java8...
java8 LocalDate LocalDateTime等时间类介绍
热门推荐
sf_cyl的博客
07-21 2万+
这篇文章主要是java8中新的Date和Time API的实战。新的Date和Time类是java开发者社区千呼万唤始出来的。Java8 之前存在的Date类一直都受人诟病，很多人都会选择使用第三方的date库joda-time。Java8中的date和time api是jodatime的作者参与开发的，实现了JSR310的全部内容。这些新的api都在包java.time下。
Java8函数式接口介绍
weixin_40482816的博客
02-18 366
1、函数式编程 简介 我们最常用的面向对象编程（Java）属于命令式编程（Imperative Programming）这种编程范式。常见的编程范式还有逻辑式编程（Logic Programming），函数式编程（Functional Programming）。 函数式编程作为一种编程范式，在科学领域，是一种编写计算机程序数据结构和元素的方式，它把计算过程当做是数学函数的求值，而避免更改状态和...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1119
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 157
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 891
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 928
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
探索Java 8：Lambda表达式与闭包实战
"Java Closures and Lambda(Apress,2015)" 是一本关于Java 8新特性，特别是Lambda表达式的书籍。这本书深入探讨了Java 8如何通过引入Lambda表达式来革新这门编程语言，使得函数式编程变得更加便捷。 在Java 8中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

自由自在1039

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值