Java Lambda语法介绍

admin2024-07-02  15

Java Lambda语法介绍,第1张

目录

一、概述

二、Lambda语法的历史

2.1 Lambda名字的含义

2.2 Lambda的历史

三、Lambda语法的核心接口

3.1 Lambda的四大核心接口

3.1.1 概述

3.1.2 Consumer 接口

3.1.3 Supplier 接口

3.1.4 Function 接口,>

3.1.5 Predicate 接口

四、Lambda的引用

4.1 概述

4.2 方法的引用

4.2.1 对象::实例方法

4.2.2 类::静态方法

4.2.3 类::实例方法

4.3 构造器的引用

4.4 数组的引用

五、Lambda的使用场景

5.1 简化编程

5.2 函数式接口

5.3 事件处理

5.4 并行处理


一、概述

Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中),它允许我们以简洁、可读的方式表示匿名函数。通过Lambda表达式,我们可以将代码块作为参数传递给其他函数,从而实现更灵活的编程。

二、Lambda语法的历史

2.1 Lambda名字的含义

Lambda 这个名字 并不是一个什么的缩写,它是希腊第十一个字母 λ 的读音,同时它也是微积分函数中的一个概念,所表达的意思是一个函数入参和出参定义,在编程语言中其实是借用了数学中的 λ,并且多了一点含义,在编程语言中功能代表它具体功能的叫法是匿名函数(Anonymous Function),根据百科的解释:匿名函数在计算机编程中是指一类无需定义标识符(函数名)的函数或子程序。

2.2 Lambda的历史

说起Lambda 的历史,虽然它在 JDK8 发布之后才正式出现,但是在编程语言界,它是一个具有悠久历史的东西,最早在 1958 年在Lisp 语言中首先采用,而且虽然Java脱胎于C++,但是C++在2011年已经发布Lambda 了,但是 JDK8 的 LTS 在2014年才发布,现代编程语言则是全部一出生就自带 Lambda 支持。

三、Lambda语法的核心接口

3.1 Lambda的四大核心接口

3.1.1 概述

Java8为了我们方便编程,就为我们提供了四大核心函数式接口,分别是Consumer<T> : 消费型接口、Supplier<T> : 供给型接口、Function<T, R> : 函数型接口、Predicate<T> : 断言型接口,具体如下图所示:

Java Lambda语法介绍,第2张

3.1.2 Consumer<T> 接口

代码例子:

package main.java.com.ningzhaosheng.lambada.demo;

import java.util.function.Consumer;

/**
 * @author ningzhaosheng
 * @date 2024/6/27 17:57:21
 * @description Consumer接口 测试例子
 */
public class TestConsumer {

    public static void main(String[] args) {
        task(66.66,(m) -> System.out.println("本次一共花费"+m+ "元!!!"));
    }

    public static void task(double money, Consumer<Double> consumer){
         consumer.accept(money);
    }
}

Java Lambda语法介绍,第3张

3.1.3 Supplier<T> 接口

代码例子:

package main.java.com.ningzhaosheng.lambada.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

/**
 * @author ningzhaosheng
 * @date 2024/6/27 18:03:18
 * @description Supplier 接口测试例子
 */
public class TestSupplier {

    public static void main(String[] args) {
        List<Integer> list = getNumList(10, () -> (int) (Math.random() * 100));
        for (Integer num : list) {
            System.out.println("随机数:" + num);
        }
    }

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

Java Lambda语法介绍,第4张

3.1.4 Function<T, R> 接口

代码例子:

package main.java.com.ningzhaosheng.lambada.demo;

import java.util.function.Function;

/**
 * @author ningzhaosheng
 * @date 2024/6/27 18:10:01
 * @description Function 接口测试例子
 */
public class TestFunction {

    public static void main(String[] args) {
        String trimStr = stringHandler("\t\t\t hello,你好啊,升哥!",(str)->str.trim());
        System.out.println("字符串去掉空格==========="+trimStr);

        String newStr = stringHandler("桃子姑娘是一个很漂亮的姑娘,我们青梅竹马,两小无猜,我很喜欢桃子姑娘!",(str)->str.substring(26));
        System.out.println("截取字符串==========="+newStr);
    }

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

Java Lambda语法介绍,第5张

3.1.5 Predicate<T> 接口

代码例子:

package main.java.com.ningzhaosheng.lambada.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * @author ningzhaosheng
 * @date 2024/6/27 18:21:37
 * @description Predicate 接口测试例子
 */
public class TestPredicate {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("Hello", "你好啊,升哥", "HashMap", "Python", "JDK8", "Map", "List", "Set", "Collection");
        List<String> stringList = filterStr(list, (str) -> str.length() > 5);
        for (String string : stringList) {
            System.out.println("打印满足条件的字符串=========" + string);
        }
    }

    public static List<String> filterStr(List<String> strings, Predicate<String> predicate) {
        List<String> stringList = new ArrayList<String>();
        for (String str : strings) {
            if (predicate.test(str))
                stringList.add(str);
        }
        return stringList;
    }
}

Java Lambda语法介绍,第6张

四、Lambda的引用

4.1 概述

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

如下三种主要使用情况 :

  • 对象 :: 实例方法
  • 类 :: 静态方法
  • 类 :: 实例方法

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

4.2 方法的引用

4.2.1 对象::实例方法

代码例子一:

package main.java.com.ningzhaosheng.lambada.demo1.method;

import java.io.PrintStream;
import java.util.function.Consumer;

/**
 * @author ningzhaosheng
 * @date 2024/6/28 10:03:20
 * @description 测试对象::实例方法引用
 */
public class TestObjectAndInstanceMethod {
    public static void main(String[] args) {
        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 Lambada!");
    }
}

Java Lambda语法介绍,第7张

代码例子二:

package main.java.com.ningzhaosheng.lambada.demo1.method;

import main.java.com.ningzhaosheng.lambada.demo1.Employee;

import java.util.function.Supplier;

/**
 * @author ningzhaosheng
 * @date 2024/6/28 10:13:54
 * @description 测试对象::实例方法引用
 */
public class TestObjectAndInstanceMethod1 {

    public static void main(String[] args) {
        Employee em = new Employee();
        em.setAge(20);
        em.setName("张三");
        Supplier<? extends String> supplier = ()->em.getName();
        String str =  supplier.get();
        System.out.println(str);
        Supplier<Integer> supplier1 = em::getAge;
        Integer age = supplier1.get();
        System.out.println(age);
    }
}

Java Lambda语法介绍,第8张

4.2.2 类::静态方法

代码例子:

package main.java.com.ningzhaosheng.lambada.demo1.method;

import java.util.Comparator;

/**
 * @author ningzhaosheng
 * @date 2024/6/28 10:28:20
 * @description 测试类::静态方法引用
 */
public class TestClassAndStaticMethod {
    public static void main(String[] args) {
        Comparator<Integer> comparator = (x,y)->Integer.compare(x,y);
        System.out.println(comparator.compare(10,20));

        Comparator<Integer> comparator1 = Integer::compare;
        System.out.println(comparator1.compare(100,300));
    }
}

Java Lambda语法介绍,第9张

4.2.3 类::实例方法

代码例子:

package main.java.com.ningzhaosheng.lambada.demo1.method;

import java.util.function.BiPredicate;

/**
 * @author ningzhaosheng
 * @date 2024/6/28 10:34:11
 * @description 测试类::实例方法引用
 */
public class TestClassAndInstanceMethod {
    public static void main(String[] args) {
        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"));
    }
}

Java Lambda语法介绍,第10张

4.3 构造器的引用

代码例子:

package main.java.com.ningzhaosheng.lambada.demo1.construct;

import main.java.com.ningzhaosheng.lambada.demo1.Employee;

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author ningzhaosheng
 * @date 2024/6/28 10:44:03
 * @description 测试构造器引用
 */
public class TestConstruct {
    public static void main(String[] args) {
        // 无参构造
        Supplier<Employee> supplier = () -> new Employee();
        System.out.println(supplier.get());

        // 无参构造
        Supplier<Employee> supplier1 = Employee::new;
        System.out.println(supplier1.get());

        // 一个参数构造
        Function<Integer, Employee> function = Employee::new;
        Employee employee = function.apply(1001);
        System.out.println(employee.toString());

        // 两个参数构造
        BiFunction<Integer, String, Employee> biFunction = Employee::new;
        Employee employee1 = biFunction.apply(1001, "张三");
        System.out.println(employee1.toString());
    }

}

Java Lambda语法介绍,第11张

4.4 数组的引用

代码例子:

package main.java.com.ningzhaosheng.lambada.demo1.array;

import java.util.function.Function;

/**
 * @author ningzhaosheng
 * @date 2024/6/28 10:55:26
 * @description 测试数组引用
 */
public class TestArray {
    public static void main(String[] args) {
        Function<Integer,String[]> function = (x)->new String[x];
        String[] strings = function.apply(10);
        System.out.println(strings.length);

        Function<Integer,String[]> function1 = String[]::new;
        String[] strings1 = function1.apply(50);
        System.out.println(strings1.length);
    }
}

Java Lambda语法介绍,第12张

五、Lambda的使用场景

通过使用Lambda表达式,我们可以写出更简洁、易读的代码,提高代码的可维护性和开发效率。下面列举一下它的使用场景。

5.1 简化编程

使用lambda表达式可以简化代码,避免定义一大堆小方法。

5.2 函数式接口

只包含一个抽象方法的接口称为函数式接口。这些接口可以使用lambda表达式。

例如:

Runnable r = () -> System.out.println("Hello, World!");
new Thread(r).start();

5.3 事件处理

在Java GUI编程中,lambda表达式经常用于按钮点击等事件的处理。

例如:

JButton button = new JButton("Click Me");
button.addActionListener(event -> System.out.println("Button clicked!"));

5.4 并行处理

Java 8的流(Stream)库使用lambda表达式来进行并行处理。

例如:

package main.java.com.ningzhaosheng.lambada.demo2;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @author ningzhaosheng
 * @date 2024/7/2 9:52:30
 * @description 测试Java8 lambda stream
 */
public class TestLambdaStream {
    public static void main(String[] args) {

        // 创建一个包含一百万个随机整数的列表
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            numbers.add(ThreadLocalRandom.current().nextInt(199));
        }
        //顺序流的处理
        long startTimeSeq = System.currentTimeMillis();
        double averageSequential = numbers.stream()
                .mapToInt(Integer::intValue)
                .average()
                .getAsDouble();
        long endTimeSeq = System.currentTimeMillis();
        System.out.println("sequential Average:" + averageSequential);

        System.out.println("Time taken (Sequential): " + (endTimeSeq - startTimeSeq) + "ms");

        //并行流的处理
        long startTimePar = System.currentTimeMillis();
        double averageParallel = numbers.parallelStream()
                .mapToInt(Integer::intValue)
                .average()
                .getAsDouble();

        long endTimePar = System.currentTimeMillis();

        System.out.println("parallel Average: " + averageParallel);

        System.out.println("Time taken (Parallel): " + (endTimePar - startTimePar) + "ms");

    }
}

Java Lambda语法介绍,第13张

可以看出,顺序流和并行流得到了相同的平均值,但并行流的处理时间明显少于顺序流。因为并行流能够将任务拆分成多个小任务,并在多个处理器核心上同时执行这些任务。

当然并行流也有缺点:

  • 对于较小的数据集,可能并行流更慢
  • 数据处理本身的开销较大,比如复杂计算、大量IO操作、网络通信等,可能并行流更慢
  • 可能引发线程安全问题

好了,本次内容就分享到这,欢迎关注本博主。如果有帮助到大家,欢迎大家点赞+关注+收藏,有疑问也欢迎大家评论留言!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明原文出处。如若内容造成侵权/违法违规/事实不符,请联系SD编程学习网:675289112@qq.com进行投诉反馈,一经查实,立即删除!