Java基础-8新特性

Lambda 表达式

Lambda 表达式，也可称为闭包。Lambda 表达式是一个匿名函数，我们可以这样理解 Lambda 表达式：Lambda 是一段可以传递的代码（能够做到将代码像数据一样进行传递）。格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

 实例

创建线程 

//不使用lambdanew Thread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}},"thread").start();
//使用lambdanew Thread(() -> {System.out.println(Thread.currentThread().getName());}, "thread").start();

语法

Lambda 表达式在 Java 语言中引入了 “->” 操作符， “->” 操作符被称为 Lambda 表达式的操作符或者箭头操作符，它将 Lambda 表达式分为两部分：

  • 左侧部分指定了 Lambda 表达式需要的所有参

  • 右侧部分指定了 Lambda 体，即 Lambda 表达式要执行的功能

Lambda 表达式本质上是对接口的实现，Lambda 表达式的参数列表本质上对应着接口中方法的参数列表。

语法格式一

无参，无返回值，Lambda 体只有一条语句

Runnable runnable=()-> System.out.println(Thread.currentThread().getName());
new Thread(runnable).start();

语法格式二

需要参数，并且无返回值。Lambda 表达式的参数列表的数据类型可以省略不写，因为 JVM编译器能够通过上下文推断出数据类型，这就是“类型推断”

public class LambdaDemo {interface Operate {void method(int x, int y);}public static void main(String[] args) {//实现Operate接口Operate operate = (x, y) -> System.out.printf("%d\t%d", x, y);operate.method(100,200);}
}
/*
100    200
*/

语法格式三

只需要一个参数时，参数的小括号可以省略

public class LambdaDemo {interface Operate {void method(int x);}public static void main(String[] args) {Operate operate = x -> System.out.printf("%d", x);operate.method(100);}
}
/*
100
*/

语法格式四

需要参数，并且有返回值

public class LambdaDemo {interface Operate {int method(int x, int y);}public static void main(String[] args) {Operate operate = (x, y) -> {System.out.println(x + y);return x + y;};operate.method(100, 200);}
}
/*
300
*/

语法格式五

当 Lambda 体只有一条语句时，return 和大括号可以省

public class LambdaDemo {interface Operate {int method(int x, int y);}public static void main(String[] args) {Operate operate = (x, y) ->  x + y;System.out.println(operate.method(100, 200));}
}

函数式接口

Lambda 表达式需要函数式接口的支持，只包含一个抽象方法的接口，称为函数式接口。

  • 可以通过 Lambda 表达式来创建该接口的对象。

  • 可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

java提供了四大函数式接口：

Consumer 消费型接口

Consumer 接口是消费性接口，无返回值。

@FunctionalInterface
public interface Consumer<T> {void accept(T t);default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}
}

Supplier 供给型接口

Supplier 接口是供给型接口，有返回值。

@FunctionalInterface
public interface Supplier<T> {T get();
}

Function<T,R> 函数式接口

Function 接口是函数型接口，有返回值。

@FunctionalInterface
public interface Function<T, R> {R apply(T t);default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));}default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}static <T> Function<T, T> identity() {return t -> t;}
}

Predicate 断言型接口

Predicate 接口是断言型接口，返回值类型为 boolean。

@FunctionalInterface
public interface Predicate<T> {boolean test(T t);default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);}default Predicate<T> negate() {return (t) -> !test(t);}default Predicate<T> or(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) || other.test(t);}static <T> Predicate<T> isEqual(Object targetRef) {return (null == targetRef)? Objects::isNull: object -> targetRef.equals(object);}
}

方法引用与构造器引用

方法引用

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

  1. 类::静态方法
  2. 类::实例方法
    public static void main(String[] args) {List<Integer> list=new ArrayList<>();list.forEach(item->System.out.println(item));//等价list.forEach(System.out::println);}

构造器引用

格式如下所示： ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法， 与构造器参数列表要与接口中抽象方法的参数列表一致！

    public static void main(String[] args) {Function<Integer, List<Integer>> function = ArrayList::new;List<Integer> list = function.apply(16);Supplier<List<Integer>> supplier = ArrayList::new;List<Integer> integers = supplier.get();}

数组引用

    public static void main(String[] args) {Function<Integer, Integer[]> function = Integer[]::new;//创建大小为16的数组Integer[] list = function.apply(16);}

Optional类

Optional 类是一个容器类，代表一个值存在或不存在，可以避免空指针异常。类常用方法：

  1. Optional.of(T t) : 创建一个 Optional 实例。
  2. Optional.empty() : 创建一个空的 Optional 实例。
  3. Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例。
  4. isPresent() : 判断是否包含值。
  5. orElse(T t) : 如果调用对象包含值，返回该值，否则返回 t。
  6. orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值。
  7. map(Function f): 如果有值对其处理，并返回处理后的 Optional，否则返回 Optional.emp ty()。
  8. flatMap(Function mapper):与 map 类似，要求返回值必须是 Optional。

Stream API

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执 行非常复杂的查找、过滤和映射数据等操作。Stream使用流程如下：

  1. 创建 Stream：一个数据源（如： 集合、数组）， 获取一个流。
  2. 中间操作： 一个中间操作链，对数据源的数据进行处理。
  3. 终止操作(终端操作)： 一个终止操作，执行中间操作链，并产生结果。

创建Stream

获取Stream

     public static void main(String[] args) {List<Integer> list=new ArrayList<>();//获取流list.stream();//获取平行流list.parallelStream();}

由数组创建

    public static void main(String[] args) {Stream<Integer> integerStream = Arrays.stream(new Integer[]{1, 2, -12, 0});IntStream intStream = Arrays.stream(new int[]{1, 2, 3, -1});LongStream longStream = Arrays.stream(new long[]{1L, 2L, 3L, -1L});DoubleStream doubleStream = Arrays.stream(new double[]{1.1, 2.1, 3.1, -1.1});}

由值创建

    public static void main(String[] args) {Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);}

由函数创建

由函数创建流可以创建无限流。

    public static void main(String[] args) {Stream<Integer> stream = Stream.iterate(0, integer -> integer + 1);//创建的是无限流  使用limit方法获取10个List<Integer> collect = stream.limit(10).collect(Collectors.toList());System.out.println(collect);Stream<ArrayList<Object>> generate = Stream.generate(ArrayList::new);List<ArrayList<Object>> collect1 = generate.limit(5).collect(Collectors.toList());System.out.println(collect1);}

中间操作

筛选与切片

    public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 4, 5, 6, 7, 3, 6);//筛选被3整除的数List<Integer> collect = list.stream().filter(item -> Objects.equals(item % 3, 0)).collect(Collectors.toList());System.out.println(collect);//选取前5个List<Integer> collect1 = list.stream().limit(5).collect(Collectors.toList());System.out.println(collect1);//跳过前2个List<Integer> collect2 = list.stream().skip(2).collect(Collectors.toList());System.out.println(collect2);//去重List<Integer> collect3 = list.stream().distinct().collect(Collectors.toList());System.out.println(collect3);}

映射

    public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 4, 5, 6, 7, 3, 6);List<String> collect = list.stream().map(String::valueOf).collect(Collectors.toList());System.out.println(collect);}

排序

    public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 4, 5, 6, 7, 3, 6);List<Integer> collect = list.stream().sorted().collect(Collectors.toList());System.out.println(collect);}

终止操作

查找与匹配

    public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 4, 5, 6, 7, 3, 6);System.out.println(list.stream().allMatch(item -> item > 5));System.out.println(list.stream().anyMatch(item -> item > 5));System.out.println(list.stream().noneMatch(item -> item > 5));Optional<Integer> any = list.stream().findAny();System.out.println(any.orElse(0));Optional<Integer> first = list.stream().findFirst();System.out.println(first.orElse(0));}

统计

    public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 4, 5, 6, 7, 3, 6);System.out.println(list.stream().filter(Objects::isNull).count());Optional<Integer> max = list.stream().max(Integer::compareTo);System.out.println(max.orElse(0));Optional<Integer> min = list.stream().min(Integer::compareTo);System.out.println(min.orElse(0));list.stream().forEach(System.out::println);}

规约

    public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 4, 5, 6, 7, 3, 6);System.out.println(list.stream().reduce(0, Integer::sum));Optional<Integer> reduce = list.stream().reduce(Integer::sum);System.out.println(reduce.orElse(0));}

收集

    public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 4, 5, 6, 7, 3, 6);System.out.println(list.stream().filter(Objects::nonNull).collect(Collectors.toList()));}

接口的默认方法与静态方法

Java 8 中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default t关键字修饰。

  1. 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称 和参数的默认方法会被忽略。
  2. 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有 相同名称和参数列表的方法（不管方法是否是默认方法）， 那么必须覆盖该方法来解 决冲突。

在 Java8 中，接口中允许添加静态方法，使用方式接口名.方法名。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/57098.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【Cadence27】HDL拷贝工程➕Allegro导出DXF和3D文件STP

【Cadence27】HDL拷贝工程➕Allegro导出DXF和3D文件STP

【转载】Cadence Design Entry HDL 使用教程 【Cadence01】Cadence PCB Edit相对延迟与绝对延迟的显示问题 【Cadence02】Allegro引脚焊盘Pin设置为透明 【Cadence03】cadence不小心删掉钢网层怎么办&#xff1f; 【Cadence04】一般情况下Allegro PCB设计时的约束规则设置&a…
阅读更多...
【入门篇】2.8 时钟（三）

【入门篇】2.8 时钟（三）

目录 5.3.1 配置时钟源相关参数：调用函数 HAL_RCC_OscConfig() 5.3.2 配置系统时钟源以及 SYSCLK、AHB、APB1 和 APB2 的分频系数：调用函数HAL_RCC_ClockConfig() 六，STM32F4 时钟使能和配置 6.1 使能时钟 6.2 禁用时钟 5.3.1 配置时钟源相关参数：调用函数 HAL_RCC_Os…
阅读更多...
【力扣 | SQL题 | 每日4题】力扣2308，2324，2346，2372

【力扣 | SQL题 | 每日4题】力扣2308，2324，2346，2372

4 mid&#xff0c;还是比较常规的。 1. 力扣2308&#xff1a;按性别排列表格 1.1 题目&#xff1a; 表: Genders ---------------------- | Column Name | Type | ---------------------- | user_id | int | | gender | varchar | ---------------------- u…
阅读更多...
卸载 Git

卸载 Git

目录 打开 Geek找到 Git右键卸载 Git卸载完成等待扫描注册表点击完成清除Git在本地的配置文件 打开 Geek 找到 Git 右键卸载 Git 卸载完成 等待扫描注册表 点击完成 已经删除完毕 清除Git在本地的配置文件 进入 C:\Users\用户名 删除框起来的配置文件 &#x1f447; 源码资料…
阅读更多...
Map转Map

Map转Map

将一个Map<String,Integer> 转换成Map<String,String> //创建一个创建Map的公共方法 private static <T> Map<String,T> newMap(String key,T val,Object...kv){Map<String,T> ans new HashMap<>(8);ans.put(key,val);for(int i0,size k…
阅读更多...
webpack自定义插件 ChangeScriptSrcPlugin

webpack自定义插件 ChangeScriptSrcPlugin

插件文件 class ChangeScriptSrcPlugin {apply(compiler) {const pluginName "ChangeScriptSrcPlugin";compiler.hooks.compilation.tap(pluginName, (compilation, callback) > {compilation.hooks.htmlWebpackPluginAlterAssetTags.tapAsync(pluginName,(html…
阅读更多...
DES对称加密算法

DES对称加密算法

DES&#xff08;Data Encryption Standard&#xff0c;数据加密标准&#xff09;是一种对称加密算法。 算法概述 加密类型&#xff1a;对称加密&#xff08;同一密钥用于加密和解密&#xff09;。密钥长度&#xff1a;64位&#xff08;8字节&#xff09;&#xff0c;其中有效…
阅读更多...
java--网络编程

java--网络编程

网络的相关概念 网络通信 1.概念:两台设备之间通过网络实现数据传输2.网络通信:将数据通过网络从一台设备传输到另一台设备3.java.net包下提供了一系列的类或接口&#xff0c;供程序员使用&#xff0c;完成网络通信 网络 概念&#xff1a;两台或多台设备通过一定物理设备连接…
阅读更多...
UltraISO（软碟通）制作U盘制作Ubuntu20.04启动盘

UltraISO（软碟通）制作U盘制作Ubuntu20.04启动盘

目录 一、启动盘制作 1、工具准备 2、打开UltraISO后&#xff0c;点击左上角的文件&#xff0c;在打开的下拉项中&#xff0c;选择打开准备好的Ubuntu系统20.04 LTS镜像文件(ubuntu-20.04-desktop-amd64.iso)&#xff1b; 3、然后点击启动->写入硬盘映像 4、在弹出的窗…
阅读更多...
Pollard‘s p-1算法

Pollard‘s p-1算法

概述 光滑数 (Smooth number)&#xff1a;指可以分解为多个小素数乘积的正整数 当p是N 的因数&#xff0c;并且p−1是光滑数&#xff0c;可以考虑使用Pollards p-1算法来分解N 当p是N的因数&#xff0c;并且p1是光滑数&#xff0c;可以考虑使用Williamss p1算法来分解N 这里…
阅读更多...
11.useComponentDidMount

11.useComponentDidMount

在 React 的函数组件中，有时我们需要在组件首次挂载后执行某些操作，这在类组件中通常通过 componentDidMount 生命周期方法来实现。useComponentDidMount 钩子提供了一种简洁的方式来在函数组件中实现相同的功能。这个自定义钩子使得在组件挂载后执行一次性操作变得简单直观。…
阅读更多...
一个简单的Qt Console Application计算练习程序

一个简单的Qt Console Application计算练习程序

初步体验Qt Creator 用途&#xff1a;练习20以内2位数乘法速算的程序 功能1&#xff1a;支持用户设定题目数量 std::cout << "请输入本次练习题目数量&#xff1a;";int numProblems 0;std::string num;std::cin >> num;try {numProblems std::stoi(…
阅读更多...
飞腾X100适配Ubuntu说明

飞腾X100适配Ubuntu说明

【写在前面】 飞腾开发者平台是基于飞腾自身强大的技术基础和开放能力&#xff0c;聚合行业内优秀资源而打造的。该平台覆盖了操作系统、算法、数据库、安全、平台工具、虚拟化、存储、网络、固件等多个前沿技术领域&#xff0c;包含了应用使能套件、软件仓库、软件支持、软件适…
阅读更多...
Docker配置网站环境

Docker配置网站环境

Mysql 先安装mysql 启动并后台运行&#xff1a;run -d 容器名称&#xff1a;--name 设置端口映射&#xff1a;-p 主机端口&#xff1a;容器端口 环境变量&#xff1a;-e 最后指定镜像名称 sudo docker run -d \--name mysql\-p 3306:3306\-e MYSQL_ROOT_PASSWORD123456\…
阅读更多...
单细胞空间转录组RCTD去卷积分析学习和整理

单细胞空间转录组RCTD去卷积分析学习和整理

RCTD(Robust Cell Type Decomposition)&#xff0c;是一种用于将单细胞RNA测序数据中的细胞类型注释转移到空间转录组学数据上的方法。RCTD 通过整合单细胞和空间转录组学数据&#xff0c;能够较为精确地为空间点&#xff08;spots&#xff09;分配细胞类型或细胞类型的混合&am…
阅读更多...
LabVIEW风机滚动轴承监测系统

LabVIEW风机滚动轴承监测系统

矿井主通风机作为矿井中最重要的通风设备&#xff0c;一旦出现故障&#xff0c;不仅会影响矿井内的空气质量&#xff0c;还可能引发安全事故。研究表明&#xff0c;通风机中约30%的故障是由轴承问题引起的。因此&#xff0c;能够实时监控矿井主通风机轴承状态的系统&#xff0c…
阅读更多...
使用枚举来实现策略模式

使用枚举来实现策略模式

使用很多if else的场景 public void save(String type,Object data){if("db".equals(type)){saveInDb(data);}else if("file".equals(type)){saveInFile(data);}else if("oss".equals(type)){saveInOss(data);}}使用枚举来解决 public enum Save…
阅读更多...
CSS网页布局（重塑网页布局）

CSS网页布局（重塑网页布局）

一、实现两列布局 许多网站有一些特点&#xff0c;如页面顶部放置一个大的导航或广告条&#xff0c;右侧是链接或图片&#xff0c;左侧放置主要内容&#xff0c;页面底部放置版权信息等 一般情况&#xff0c;此类网页布局的两列都有固定的宽度&#xff0c;而且从内容上很容易区…
阅读更多...
学习java第九天 简单小项目

学习java第九天 简单小项目

今天简单写了小项目 import java.math.*; import java.util.*; public class Project_array{// data 拿到外面 封装的方法 共享同一个变量// static 静态上下文只能直接访问静态的变量// 一旦加上static 代表当前的变量全局共享一份static Record[] data {new Record("…
阅读更多...
C/C++面试八股

C/C++面试八股

引用&#xff1a; C面经(简洁版)-CSDN博客 正文&#xff1a; 1. const 和 volatile 的区别&#xff1f; 2. const 和 volatile 可以共用么&#xff1f;
阅读更多...
最新文章

Copyright @ 2022~2023