Java基础回顾系列-第三天-Lambda表达式

2024-09-08 15:32
文章标签 java 基础 第三天 系列 表达式 回顾 lambda

本文主要是介绍Java基础回顾系列-第三天-Lambda表达式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Java基础回顾系列-第三天-Lambda表达式

    • Lambda表达式
    • 方法引用
      • 引用静态方法
      • 引用实例化对象的方法
      • 引用特定类型的方法
      • 引用构造方法
    • 内建函数式接口
      • Function基础接口
      • DoubleToIntFunction 类型转换接口
      • Consumer消费型函数式接口
      • Supplier供给型函数式接口
      • Predicate断言型函数式接口
    • Stream API

该篇博文需重点了解：内建函数式接口
该篇博文需重点了解：内建函数式接口
该篇博文需重点了解：内建函数式接口

Lambda表达式

Lambda表达式的主要目的替换只有一个抽象方法的匿名内部类。

一个简单的类：

package javase.util;interface IMessage {void say(String str);
}
public class LambdaTest {public static void main(String[] args) {IMessage message = new IMessage() {@Overridepublic void say(String str) {System.out.println("消息发出:"+ str);}};message.say("你好");}
}

采用Lamdba表达式写法：

package javase.util;@FunctionalInterface
interface IMessage {// 只能有一个方法，这样的方法叫做函数式接口，注解@FunctionalInterface定义在接口上。void say(String str);
}
public class LambdaTest {public static void main(String[] args) {// 针对有参数的情况IMessage message = (str)->{System.out.println("消息发出:"+ str);};message.say("你好");}
}

Lambda方法的条件：符合函数式接口的接口

  • 方法没有参数：()->{语句}
  • 方法有参数：(parm1, parm2,parm...)->{语句}
  • 如果只有一行语句返回：(parm1, parm2,parm...)->语句

示例：有返回值的函数式接口Lambda实现

package javase.util;@FunctionalInterface
interface IMessage {String call();
}
public class LambdaTest {public static void main(String[] args) {IMessage message = ()->{return "你好";};// 简化写法： IMessage message = ()->"你好";System.out.println(message.call());}
}

方法引用

不同的方法描述可以描述同一个方法。弥补了对引用的支持功能。

  • 引用静态方法：类名称 :: 方法名称
  • 引用某个实例化对象的方法：实例化对象 :: 普通方法
  • 引用特定类型的方法：特定类 :: 普通方法
  • 引用构造方法：类名称 :: new

引用静态方法

如引用String.valueOf(int i)方法

package javase.util;// P描述的是参数，R描述的是返回值
@FunctionalInterface
interface IFunction<P,R> {// 转换public R change(P p);
}public class LambdaTest {public static void main(String[] args) {// 引用静态方法IFunction<Integer, String> function = String :: valueOf;String change = function.change(100);System.out.println(change);}
}

利用方法引用这一概念可以为一个方法定义多个名字，但必须满足函数式接口。

引用实例化对象的方法

如引用字符串实例对象.toUpperCase()方法

package javase.util;// R描述的是返回值
@FunctionalInterface
interface IFunction<R> {// 转换public R upper();
}public class LambdaTest {public static void main(String[] args) {// 引用静态方法IFunction<String> function = "Lambda" :: toUpperCase;String upper = function.upper();System.out.println(upper);}
}

引用特定类型的方法

如String.compareTo(String anotherString)

package javase.util;@FunctionalInterface
interface IFunction<P> {// 转换public int compare(P p1, P p2);
}public class LambdaTest {public static void main(String[] args) {// 引用静态方法IFunction<String> function = String :: compareTo;int compare = function.compare("A", "a");// 32System.out.println(compare);}
}

引用构造方法

package javase.util;@FunctionalInterface
interface IFunction<R> {// 转换public R create(String name, int age);
}class Person {private String name;private int age;Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return this.name+"=="+this.age;}
}public class LambdaTest {public static void main(String[] args) {// 引用静态方法IFunction<Person> function = Person :: new;Person person = function.create("张三", 12);System.out.println(person);}
}

内建函数式接口

参见：https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/package-summary.html

接口说明
Interface Function<T,​R>输入参数且返回结果
Interface Consumer<T>输入参数但不返回结果
Interface Supplier<T>提供输入型函数接口，boolean
Interface Predicate<T>断言型接口

注：以上接口泛型T表示传入参数；泛型R表示输出结果(返回值)。

java.util.function开发包提供了功能接口为lambda表达式和方法引用提供目标类型。 每个功能接口都有一个抽象方法，称为该功能接口的功能方法，lambda表达式的参数和返回类型与之匹配或匹配。功能接口可以在多个上下文中提供目标类型，例如赋值上下文，方法调用或强制转换上下文：

     // Assignment contextPredicate<String> p = String::isEmpty;// Method invocation contextstream.filter(e -> e.getSize() > 10)...// Cast contextstream.map((ToIntFunction) e -> e.getSize())...

Function基础接口

@FunctionalInterface
public interface Function<T,​R>
此接口需接收一个值以及返回一个值。
R apply​(T t) // 应用

package javase.util;import java.util.function.Function;public class LambdaTest {public static void main(String[] args) {// 使用String.startsWith(String str) 判断字符串是否以指定字符开头Function<String, Boolean> function = "**Hello" :: startsWith;// 执行Boolean startsWith = function.apply("**");System.out.println(startsWith);}
}

DoubleToIntFunction 类型转换接口

@FunctionalInterface
public interface DoubleToIntFunction

Consumer消费型函数式接口

只能进行数据处理操作，而没有任何返回。
对类型为T的对象应用操作，包含方法：void accept(T t)

package javase.util;import java.util.function.Consumer;
import java.util.function.Function;public class LambdaTest {public static void main(String[] args) {Consumer consumer = System.out :: println;consumer.accept("只输出，无返回");}
}

Supplier供给型函数式接口

返回类型为T的对象，包含方法：T get()

package javase.util;import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;public class LambdaTest {public static void main(String[] args) {Supplier<String> supplier = "LAMBDA" :: toLowerCase;// 转小写String s = supplier.get();// 获取System.out.println(s);}
}

Predicate断言型函数式接口

确定类型为T的对象是否满足某约束，并返回boolean 值。包含方法：boolean test(T t)

package javase.util;import java.util.function.Predicate;public class LambdaTest {public static void main(String[] args) {Predicate<String> predicate = "java" :: equalsIgnoreCase;boolean test = predicate.test("JAVA"); // 断言System.out.println(test);}
}

Stream API

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。

package javase.util;import java.util.*;
import java.util.stream.Stream;/*** Stream API*/
public class JavaAPIDemo {public static void main(String[] args) {// 创建 Stream方式一：通过集合List<String> list = new LinkedList<>();// 返回一个顺序流Stream<String> stream = list.stream();// 返回一个并行流Stream<String> stringStream = list.parallelStream();// 创建 Stream方式二：通过Arrays数组Stream<String> stream1 = Arrays.stream(new String[]{"中", "国", "要", "强", "大"});// 创建 Stream方式三：通过Stream的of()Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);// 创建 Stream方式四：创建无限流（不常用，一般用于生成数据时）// 迭代：产生规律的数据，从0一直累加2一直输出，可使用limit限制记录数Stream<Integer> iterate = Stream.iterate(0, f -> f + 2);// 生成Stream<Double> generate = Stream.generate(Math::random);// 筛选与切片// 从流中过滤某些元素integerStream.filter(e -> e > 2).forEach(System.out::println);// 截断流，使其元素不超过给定数量integerStream.limit(3).forEach(System.out::println);// 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补integerStream.skip(3).forEach(System.out :: println);// 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素integerStream.distinct();// 映射// 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。Arrays.stream(new String[]{"a", "b", "c"}).map(str -> str.toUpperCase()).forEach(System.out :: println);// 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流String[] arr1 = {"a", "b", "c", "d"};String[] arr2 = {"e", "f", "c", "d"};String[] arr3 = {"h", "j", "c", "d"};// Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);// 排序// 产生一个新流，其中按自然顺序排序integerStream.sorted().forEach(System.out :: println);// 产生一个新流，其中按比较器顺序排序integerStream.sorted(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1.compareTo(o2);}});// 等同于如上写法integerStream.sorted((o1, o2) -> o1.compareTo(o2));// 匹配与查找// 检查是否匹配所有元素boolean b = integerStream.allMatch(e -> e > 3);// 检查是否至少匹配一个元素b = integerStream.anyMatch(e -> e > 3);// 检查是否没有匹配所有元素b = integerStream.noneMatch(e -> e > 3);// 返回第一个元素Optional<Integer> first = integerStream.findFirst();// 返回当前流中的任意元素Optional<Integer> any = integerStream.findAny();// 返回流中元素总数long count = integerStream.count();// 返回流中最大值integerStream.max((o1, o2) -> o1.compareTo(o2));// 返回流中最小值integerStream.min((o1, o2) -> o1.compareTo(o2));// 内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)integerStream.forEach(System.out :: println);// 归约// 可以将流中元素反复结合起来，得到一个值。返回 TInteger reduce1 = integerStream.reduce(0, Integer::sum);// 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>Optional<Integer> reduce = integerStream.reduce(Integer::sum);// 收集// 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法// Collectors API//list.collect(Collectors :: toList);}
}

这篇关于Java基础回顾系列-第三天-Lambda表达式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1148489。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2