Java8新特性——Lambda表达式之四大核心函数式接口 & 方法/构造器/数组引用

简介: Java8新特性——Lambda表达式之四大核心函数式接口 & 方法/构造器/数组引用

文章目录:


1.四大核心函数式接口

1.1 Consumer : 消费型接口

1.2 Supplier : 供给型接口

1.3 Function : 函数型接口

1.4 Predicate : 断言型接口

2.方法引用

2.1 对象 :: 实例方法

2.2 :: 静态方法

2.3 :: 实例方法

3.构造器引用

4.数组引用

1.四大核心函数式接口


上一篇文章中说到了Lambda表达式中的基本语法,以及我们如何自定义函数式接口。但是在写代码的过程中,大家可能会发现一个问题:当我们有一个新的需求时,可以去自定义一个函数式接口,然后再创建一个它的实现类定义一些相关的业务逻辑行为。那么如果说我们有很多需求、这些需求可能还会不断地变化,那么我们岂不是每次都要去创建新的实现类、同时再去修改之前创建好的实现类中的业务代码?这可太麻烦了吧。。。

所以呢,Java8就为我们提供了四大核心函数式接口,使用起来非常的方便。


1.1 Consumer<T> : 消费型接口

package com.szh.java8;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/*
 * 
 */
public class MyTest3 {
    //Consumer<T> : 消费型接口
    @Test
    public void test1() {
        happy(6666.66,(m) -> System.out.println("本地双11共消费 " + m + " 元!!!"));
    }
    public void happy(double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }
}


1.2 Supplier<T> : 供给型接口

package com.szh.java8;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/*
 *
 */
public class MyTest3 {
    //Supplier<T> : 供给型接口
    @Test
    public void test2() {
        List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
        for (Integer num : numList) {
            System.out.println(num);
        }
    }
    public List<Integer> getNumList(int num, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            Integer n = supplier.get();
            list.add(n);
        }
        return list;
    }
}


1.3 Function<T, R> : 函数型接口

package com.szh.java8;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/*
 * 
 */
public class MyTest3 {
    //Function<T, R> : 函数型接口
    @Test
    public void test3() {
        String trimStr = strHandler("\t\t\t  张起灵-小哥   ", (str) -> str.trim());
        System.out.println(trimStr);
        String newStr = strHandler("我喜欢看盗墓笔记呀!!!",(str) -> str.substring(4,8));
        System.out.println(newStr);
    }
    public String strHandler(String str, Function<String,String> function) {
        return function.apply(str);
    }
}


1.4 Predicate<T> : 断言型接口

package com.szh.java8;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/*
 *
 */
public class MyTest3 {
    //Predicate<T> : 断言型接口
    @Test
    public void test4() {
        List<String> list = Arrays.asList("Hello","张起灵-小哥","HashMap","jdk8","List","Set");
        List<String> stringList = filterStr(list, (s) -> s.length() > 5);
        for (String string : stringList) {
            System.out.println(string);
        }
    }
    public List<String> filterStr(List<String> strings, Predicate<String> predicate) {
        List<String> strList = new ArrayList<>();
        for (String str : strings) {
            if (predicate.test(str)) {
                strList.add(str);
            }
        }
        return strList;
    }
}


除此之外,还有一些其他的函数式接口,它们有一部分是上面提到的四大核心函数式接口的子接口。


2.方法引用


当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用!     方法引用:使用操作符 “ :: ” 将方法名和对象或类的名字分隔开来。


如下三种主要使用情况

·       对象 :: 实例方法

·       :: 静态方法

·       :: 实例方法


可以将方法引用理解为 Lambda 表达式的另外一种表现形式,方法引用所引用的方法的参数列表与返回值类型,需要与函数式接口中抽象方法的参数列表和返回值类型保持一致!


2.1 对象 :: 实例方法

    @Test
    public void test1() {
        Consumer<String> con1 = (str) -> System.out.println(str);
        con1.accept("Hello World!!!");
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;
        con2.accept("Hello Java8!!!");
        Consumer<String> con3 = System.out::println;
        con3.accept("Hello Lambda!!!");
    }

    @Test
    public void test2() {
        Employee emp = new Employee();
        emp.setName("张起灵");
        emp.setAge(18);
        Supplier<? extends Object> sup1 = () -> emp.getName();
        String str = (String) sup1.get();
        System.out.println(str);
        Supplier<Integer> sup2 = emp::getAge;
        Integer age = sup2.get();
        System.out.println(age);
    }
package com.szh.java8;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
 *
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee {
    private Integer id;
    private String name;
    private Integer age;
    private Double salary;
    public Employee(Integer id) {
        this.id = id;
    }
    public Employee(Integer id,String name) {
        this.id = id;
        this.name = name;
    }
}


2.2 :: 静态方法

    @Test
    public void test3() {
        Comparator<Integer> com1 = (x,y) -> Integer.compare(x,y);
        System.out.println(com1.compare(10, 20));
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(300, 110));
    }


2.3 :: 实例方法

Lambda 的参数列表的第一个参数是实例方法的调用者,第二个参数(或无参)是实例方法的参数时,格式:ClassName::MethodName

    @Test
    public void test4() {
        BiPredicate<String,String> bp1 = (str1,str2) -> str1.equals(str2);
        System.out.println(bp1.test("Hello", "hello"));
        BiPredicate<String,String> bp2 = String::equals;
        System.out.println(bp2.test("Java", "Java"));
    }

3.构造器引用


格式 ClassName::new

与函数式接口相结合,自动与函数式接口中方法兼容。构造器的参数列表,需要与函数式接口中参数列表保持一致!

代码中Employee类参考上面的案例。

    @Test
    public void test5() {
        //无参构造器
        Supplier<Employee> sup1 = () -> new Employee();
        System.out.println(sup1.get());
        //无参构造器
        Supplier<Employee> sup2 = Employee::new;
        System.out.println(sup2.get());
        //一个参数构造器
        Function<Integer,Employee> function = Employee::new;
        Employee employee = function.apply(1001);
        System.out.println(employee);
        //两个参数构造器
        BiFunction<Integer,String,Employee> biFunction = Employee::new;
        Employee emp = biFunction.apply(1001, "张起灵");
        System.out.println(emp);
    }


4.数组引用


格式:类型[] :: new

    @Test
    public void test6() {
        Function<Integer,String[]> fun = (x) -> new String[x];
        String[] strings = fun.apply(10);
        System.out.println(strings.length);
        Function<Integer,String[]> fun2 = String[]::new;
        String[] strArray = fun2.apply(50);
        System.out.println(strArray.length);
    }

相关文章
|
2天前
|
缓存 Prometheus 监控
Java面试题:如何监控和优化JVM的内存使用?详细讲解内存调优的几种方法
Java面试题:如何监控和优化JVM的内存使用?详细讲解内存调优的几种方法
20 3
|
2天前
|
安全 Java 开发者
Java面试题:什么是Java 15中的密封类以及其限制?还有哪些其他特性用于限制类继承的机制吗?
Java面试题:什么是Java 15中的密封类以及其限制?还有哪些其他特性用于限制类继承的机制吗?
12 1
|
2天前
|
缓存 监控 算法
Java面试题:讨论JVM性能调优的常见方法和技巧。
Java面试题:讨论JVM性能调优的常见方法和技巧。
10 1
|
2天前
|
存储 设计模式 监控
Java面试题:简述JVM的内存结构,包括堆、栈、方法区等。栈内存优化的方法有 哪些?
Java面试题:简述JVM的内存结构,包括堆、栈、方法区等。栈内存优化的方法有 哪些?
12 0
|
安全 Java 开发者
Effective Java - 构造器私有、枚举和单例
Singleton 是指仅仅被实例化一次的类。Singleton代表了无状态的对象像是方法或者本质上是唯一的系统组件。使类称为Singleton 会使它的客户端测试变得十分困难。因为不可能给Singleton替换模拟实现。除非实现一个充当其类型的接口
|
2天前
|
存储 安全 Java
Java面试题:请解释Java内存模型(JMM)是什么,它如何保证线程安全?
Java面试题:请解释Java内存模型(JMM)是什么,它如何保证线程安全?
31 13
|
1天前
|
缓存 安全 Java
Java中线程池如何管理?
【7月更文挑战第11天】Java中线程池如何管理?
8 2
|
1天前
|
安全 算法 Java
Java中线程安全怎么做?
【7月更文挑战第11天】Java中线程安全怎么做?
9 2
|
1天前
|
存储 安全 算法
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第72天】 在现代软件开发中,尤其是Java应用开发领域,并发编程是一个无法回避的重要话题。随着多核处理器的普及,合理利用并发机制对于提高软件性能、响应速度和资源利用率具有重要意义。本文旨在探讨Java并发编程的核心概念、线程安全的策略以及性能优化技巧,帮助开发者构建高效且可靠的并发应用。通过实例分析和理论阐述,我们将揭示在高并发环境下如何平衡线程安全与系统性能之间的关系,并提出一系列最佳实践方法。
|
1天前
|
Java 调度
Java线程的六种状态
Java线程有六种状态: 初始(NEW)、运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、超时等待(TIMED_WAITING)、终止(TERMINATED)。
13 1