函数式接口的实例-构造器引用-数组引用

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量106 收藏
点赞数
分类专栏： javaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunqianLOL/article/details/120169390
版权 
package com.lambda;

/**
 * @author 21115 @ date 2021/9/8
 */
public class Employee {

    private int id;
    private String name;
    private int age;
    private double 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 Employee() {}

    public Employee(int id) {
        this.id = id;
    }

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Employee employee = (Employee)o;

        if (id != employee.id) {
            return false;
        }
        if (age != employee.age) {
            return false;
        }
        if (Double.compare(employee.salary, salary) != 0) {
            return false;
        }
        return name != null ? name.equals(employee.name) : employee.name == null;
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + age;
        temp = Double.doubleToLongBits(salary);
        result = 31 * result + (int)(temp ^ (temp >>> 32));
        return result;
    }
}


package com.lambda;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;

import org.junit.Test;

/**
 * 1.使用情景：当要换递给 Lambda 体的操作，已经有实现的方法了，可以使用方法引用！
 * 
 * 2.方法引用，本质上就是 Lambda 表达式，而 Lambda 表达式作为函数式接口的实例。
 * 
 * ..所以方法引用，也是函数式接口的实例。
 * 
 * 3.使用格式：类(或对象) :: 方法名
 * 
 * 4.具体分为如下的三种情况：
 * 
 * ..情况1 对象 :: 非静态方法(不能 对象 :: 静态方法)
 * 
 * ..情况2 类 :: 静态方法
 * 
 * ..情况3 类 :: 非静态方法
 * 
 * 5.方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的
 * 
 * 。。形参列表和返回值类型相同！(针对于 情况1 和 情况2)
 * 
 * 
 */
public class MethodRefTest {

    // 情况一：对象 :: 实例方法
    // Consumer 中的 void accept(T t)
    // PrintStream 中的 void println(T t)
    @Test
    public void test1() {
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");

        System.out.println("*** *** *** *** ***");
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;
        con2.accept("beijing");
        // 北京
        // *** *** *** *** ***
        // beijing
    }

    // Supplier 中的 T get()
    // Employee 中的 String getName()
    @Test
    public void test2() {
        // Employee emp = new Employee(1001, "Tom", 23, 5600);
        //
        // Supplier<String> sup1 = () -> emp.getName();
        // System.out.println(sup1.get());
        //
        // System.out.println("*** *** *** *** ***");
        // Supplier<String> sup2 = emp::getName;
        // System.out.println(sup2.get());
        // // Tom
        // // *** *** *** *** ***
        // // Tom
    }

    // 情况二：类 :: 静态方法
    // Comparator 中的 int compare(T t1,T t2)
    // Integer 中的 int compare(T t1,T t2)
    @Test
    public void test3() {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12, 21));

        System.out.println("*****************");

        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12, 3));
        // -1
        // *****************
        // 1
    }

    // Function 中的 R apply(T t)
    // Math 中的 Long round(Double d)
    @Test
    public void test4() {
        Function<Double, Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };

        System.out.println("**********************");

        Function<Double, Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(12.3));

        System.out.println("**********************");

        Function<Double, Long> func2 = Math::round;
        System.out.println(func2.apply(12.6));
        // **********************
        // 12
        // **********************
        // 13
    }

    // 情况三：类 :: 实例方法 (有难度)
    // Comparator 中的 int comapre(T t1, T t2)
    // String 中的 int t1.compareTo(t2)
    @Test
    public void test5() {
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "abd"));

        System.out.println("********************");

        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abd", "abm"));
        // -1
        // ********************
        // -9
    }

    // BiPredicate 中的 boolean test(T t1, T t2);
    // String 中的 boolean t1.equals(t2)
    @Test
    public void test6() {
        BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);
        System.out.println(pre1.test("abc", "abc"));

        System.out.println("*******************");
        BiPredicate<String, String> pre2 = String::equals;
        System.out.println(pre2.test("abc", "abd"));
        // true
        // *******************
        // false
    }

    // Function 中的 R apply(T t)
    // Employee 中的 String getName();
    @Test
    public void test7() {
        // Employee employee = new Employee(1001, "Jerry", 23, 6000);
        //
        // Function<Employee, String> func1 = e -> e.getName();
        // System.out.println(func1.apply(employee));
        //
        // System.out.println("********************");
        //
        // Function<Employee, String> func2 = Employee::getName;
        // System.out.println(func2.apply(employee));

        // Jerry
        // *******************
        // Jerry
    }
}


package com.lambda;

import java.util.Arrays;
import java.util.function.Function;

import org.junit.Test;

/**
 * 一、构造器引用
 * 
 * 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
 * 
 * 抽象方法的返回值类型即为构造器所属的类的类型
 * 
 * 二、数组引用
 * 
 * 大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。
 */
public class ConstructorRefTest {
    // 构造器引用
    // Supplier 中的 T get()
    // Employee 的空参构造器：Employee()
    @Test
    public void test1() {
        // Supplier<Employee> sup = new Supplier<Employee>() {
        // @Override
        // public Employee get() {
        // return new Employee();
        // }
        // };
        // System.out.println("************************");
        // Supplier<Employee> sup1 = () -> new Employee():
        // System.out.println(sup1.get());
        //
        // System.out.println("************************");
        //
        // Supplier<Employee> sup2 = Employee::new;
        // System.out.println(sup2.get());

        // ************************
        // Employee().....
        // Employee{id=0,name='null',age=0,salary=0.0}
        // ************************
        // Employee().....
        // Employee{id=0,name='null',age=0,salary=0.0}
    }

    // Function 中的 R apply(T t)
    @Test
    public void test2() {
        // Function<Integer, Employee> func1 = id -> new Employee(id);
        // Employee employee = func1.apply(1001);
        // System.out.println(employee);
        //
        // System.out.println("*****************");
        //
        // Function<Integer, Employee> func2 = Employee::new;
        // Employee employee1 = func2.apply(1002);
        // System.out.println(employee1);

        // Employee(int id).....
        // Employee{id=1001,name='null',age=0,salary=0.0}
        // *****************
        // Employee(int id).....
        // Employee{id=1002,name='null',age=0,salary=0.0}
    }

    // BiFunction 中的 R apply(T t,U u)
    @Test
    public void test3() {
        // BiFunction<Integer, String, Employee> func1 = (id, name) -> new Employee(id, name);
        // System.out.println(func1.apply(1001, "Tom"));
        //
        // System.out.println("*****************");
        //
        // BiFunction<Integer, String, Employee> func2 = Employee::new;
        // System.out.println(func2.apply(1002, "Tom"));

        // Employee{id=1001,name='Tom',age=0,salary=0.0}
        // *****************
        // Employee{id=1002,name='Tom',age=0,salary=0.0}
    }

    // 数组引用
    // Function 中的 R apply(T t)
    @Test
    public void test4() {
        Function<Integer, String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));

        System.out.println("*********************");

        Function<Integer, String[]> func2 = String[]::new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));

        // [null, null, null, null, null]
        // *********************
        // [null, null, null, null, null, null, null, null, null, null]
    }
}
Java8 函数式接口、方法引用、构造器引用详解
Vivienne_ChenW的博客
04-18 507
Stream
函数式接口、方法引用
weixin_43575838的博客
07-29 513
主要内容 常用函数式接口 方法引用 学习目标 能够使用@FunctionalInterface注解 能够自定义无参无返回函数式接口 能够自定义有参有返回函数式接口 能够理解Lambda延迟执行的特点 能够使用Lambda作为方法的参数 能够使用Lambda作为方法的返回值 能够使用输出语句的方法引用 能够通过4种方式(对象名,类名,父类引用super,本类引用this)使用方法引用 能够使用类和数组的构造器引用 能够使用Supplier函数式接口 能够使用Consumer函数式接
方法引用实现函数式接口六——数组
SaHuaLa的博客
05-31 216
随风
函数式接口实例化的替代方案
墨言的博客
06-01 1万+
Lambda表达式入门必看博客
实例化接口的几种方式
热门推荐
MeatLoveJK的博客
07-14 1万+
一、接口介绍 1.接口自身无法被实例化，只能通过它的实现类来实现。 2.采用interface关键字来声明一个接口。 3.接口里面的抽象方法可以直接使用 返回值 方法名（参数）；来定义。会自动加上public abstract 修饰符。 4.接口里面可以有多个默认方法（default修饰）且必须自己实现之，访问权限修饰符是public 5.接口里面可以有成员变量，但默认修饰符是public s...
在接口函数中传递数组参数
miranda的专栏
04-19 3094
应用：ocx、com语言：vc++实现：定义参数时，选择类型为VARIANT例如：BOOL CMap3DAXCtrl::AddTrackLines(LPCTSTR sName, short nCount, const VARIANT FAR& lonArray, long clr, short nLineWidth) { // TODO: Add your dispatch handler cod
JAVA8之函数式接口返回实例
Zn昕的博客
07-07 5895
JAVA8之函数式接口返回实例一.    概述        上篇说到,函数式接口返回实例有两种种方式,而上篇最后的示例实际上就是第一种返回实例的方式,也是用的最多的最基础的一种方式--lambda表达式创建实例.这里就不再介绍了.着重介绍方法引用返回实例的方式.本章节可能会涉及一些后面将要讲到的知识点,此处重点是展示,后面会仔细讲解.二.    方法引用返回实例      1.    构造器引用...
Java基础知识-day12【函数式接口、方法引用】修改后文档.pdf
10-26
【函数式接口与方法引用】在Java中，函数式接口是指具有且仅具有一个抽象方法的接口，这一特性使得它们成为实现Lambda表达式的基础。Lambda表达式是Java 8引入的一种新特性，允许以简洁的方式表示匿名函数。函数式...
Java Lambda表达式简化函数式接口实例
"Java面向对象系列[Lambda]讨论了如何使用Lambda表达式简化代码，特别是处理函数式接口的情况。在示例中，展示了如何通过Lambda替换匿名内部类，以更简洁的方式实现特定行为。" Lambda表达式是Java 8引入的一个重要...
JDK1.8新特性之函数式接口&&方法引用
qq_67638073的博客
06-14 367
JDK为我们提供的常用的函数式接口，主要是在java.util.function中。方法引用是，当lambda表达式符合特定情况时的一种缩写，它使得我们我们的lambda表达式更加精简，不过值得注意的是，方法引用只能引用已经存在的方法。
Java8一Lambda与函数式接口
J.Jian博客
05-02 8712
关于Lambda表示在工作学习中会经常用到，但并没有全面的去了解。在这里做一个较为详细的记录供以后学习查阅。主要参考Java 8 Lambda 表达式 引言 Java8之前，我们在使用Runnale创建线程的时候，经常需要将Runable实例传入new Thread中。一般采用匿名内部类将函数作为参数的形式传入 new Thread(new Runnable() { @O...
函数式编程lambda 和常用函数式接口
qq_40600507的博客
10-10 519
一. 函数式接口 概念：有且仅有一个抽象方法的接口，称之为函数式接口，可以包含其他方法（默认，静态的，私有的）。 适用于函数式编程场景的接口，Java中函数式编程体现为Lambda，函数式接口也可理解为适用于Lambda使用的接口。只有确保接口中有且仅有一个方法，Java中的Lambda才能顺利进行推导。 备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。 例如在遍历集合时使用的f...
一文读懂JavaScript函数式编程重点-- 实践 总结
tzllxya的博客
06-24 3770
一文读懂JavaScript函数式编程重点-- 实践 总结 好记性不如烂笔头,有时间将JS函数式编程,在JS方面毕竟有限，如果真要学习好函数式编程，建议学习下Haskell，本文就是将关于JS方面知识点尽可能总结全面。 柯里化 偏应用 组合与管道 函子 Monad 1. 柯里化 什么是柯里化呢？ 柯里化是把一个多参数函数转化为一个嵌套的一元函数的过程。下面我们用介绍柯里化时候很...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 244
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Servlet的生命周期
最新发布
wyk的博客
11-13 818
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
1112--接口
kequanrrr的博客
11-12 363
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 645
Rest请求处理
JAVA学习接口案例实例
shangan_3的博客
11-08 233
【代码】JAVA学习接口案例实例。
深入理解Java的类加载与卸载机制
Luffy的博客
11-12 856
类加载是指JVM将.class文件中的二进制数据读入内存中，经过一系列验证、解析和初始化，最终在JVM中生成可以被使用的Class对象。JVM会为每个类加载并生成一个唯一的Class对象，这个对象封装了类的所有信息，包括方法、属性等。类加载的三大步骤：1.加载（Loading）：从不同的源（如文件、网络）获取类的二进制字节码，并生成Class对象。2.链接（Linking）：对类的二进制进行校验和解析，确保类文件格式正确。验证（Verification）：检查字节码是否符合JVM的规范。
ArkTS--应用状态
qq_63946637的博客
11-10 626
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值