JAVA 8 新特性实用总结

作为一个工作两年多的 程序猿,虽然一开始就使用 jdk1.8 作为学习和使用的版本,随着技术的迭代,现有的 JDK 版本从两年前到现在,已经飞速发展到了 JDK 15 。真的感觉有点学不动了,更新速度太快了,不过相比于现有系统以及国内趋势。大多公司还是采用最基础的 1.8 作为线上环境来使用。也是没有任何问题的,不过我们真的 会使用 JAVA8 吗?

https://www.oracle.com/java/technologies/java-se-glance.html

新特性概述

本小结主要从 Lambda 表达式入手,由浅入深,按照实用性作为排行,逐步讲解新特性带给开发人员的快乐,如何更好的简化代码,优化可读性。这才是我们学习总结这一小节的一个目的。

你会使用遍历循环?

从最基础的循环开始,循环无非是我们刚学习的时候就需要接触 for 这个最基本的循环结构,而且在后面的工作总都会大量使用的一个结构,如何更好的简化它呢?

// 建立测试集合
List<Integer> list = Arrays.asList(1, 2, 2, 3, 4, 5, 5, 6); // 基础循环
System.out.println("----------------------------1 基础循环");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
} // 语法糖方式
System.out.println("----------------------------2 迭代器语法糖");
for (Integer i : list) {
System.out.println(i);
} // lambda 表达式简写
System.out.println("----------------------------3 lambda");
list.forEach(item -> System.out.println(item)); // 使用lambda 方法引用
System.out.println("----------------------------4 lambda");
list.forEach(System.out::println);
// 以下为编译后语法糖的代码
Iterator var4 = list.iterator(); while(var4.hasNext()) {
Integer i = (Integer)var4.next();
System.out.println(i);
}

从上面的代码我们可以看出,随着 lambda 方式的引入,代码变得越来越简化,而且更加容易读懂,写的东西也越来越少,

  1. 第一种方式则是我们常规的操作方式,一般适用于需要 下标 逻辑的业务中。
  2. 第二种则是迭代器语法糖,对于开发者而言写起来便捷,不过对于代码的编译而言,编译后的代码任是迭代器的方式,只不过语法简单了。
  3. lambda 则是一种函数式的表达方式,item 作为我们循环的参数,而箭头后则是我们需要执行的代码块,一句代码完全不必使用 {}
  4. lambda 方法引用 则是一种全新的方式,引用 二字经常被我们使用,一般在对象的引用处有表达的含义,简而言之就是 一个值可以从一个地方引用过来使用 ,但是现在,方法完全可以被看做一个 一样,也可以随意拿过来使用~

forEach

可能朋友们就会有疑惑,为什么 forEach 的地方就可以使用 lambda 表达式呢,其他地方怎么不行?我们来看看源码

default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}

我们发现 Consumer 是一个接口,内部仍然使用 for语法糖 形式来执行集合,调用了 accept 方法。

Consumer

消费者接口,适用于入参处理,无返回值

@FunctionalInterface
public interface Consumer<T> {
void accept(T t);

发现这个接口和其他接口唯一的不同点就是 @FunctionalInterface

其实这个注解就是来告诉编译器,这个接口下的 accept 方法可以使用函数式写法来描述。有了这个注解的定义,我们就可以愉快的使用函数式lambda 表达式了。

消费者接口 作为JDK 自带的函数式接口,所处于 java.util.function 包下,并且支持链式操作,

接受一个指定的泛型,内部处理后,无返回值

// 无返回的处理
Consumer<String> custom = (str) -> System.out.println("first" + str);
Consumer<String> desc = custom.andThen((str) -> System.out.println("second" + str)); desc.accept("hello");
--------------------------
firsthello
secondhello

稍稍总结一下lambda 的基础语法:

(参数)-> 一行执行代码

(参数)-> {多行执行代码}

单个参数完全可以省略参数的括号。

default

默认实现,子类无需重写接口定义的关键词

上面的Consumer使用中,我们发现,有一个默认实现的接口,顺便来说明一下

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

default 提供默认的实现方式,实现类无需重写这个方法的定义,而可以直接使用。

方法引用

把方法也可以作为值一样来引用使用。

// 使用lambda 方法引用
System.out.println("----------------------------4 lambda");
list.forEach(System.out::println);

博主这里的理解是:引用的方法需要与定义处: default void forEach(Consumer<? super T> action)

所需要的lambda 表达式具有相同的入参个数与返回类型,才可以引用。

例如:Consumer 接口接受的lambda 形式为:item -> System.out.println(item)

而我们引用的System.out::println 刚好具备这样的形式。

public void println(Object x) {
String s = String.valueOf(x);
synchronized (this) {
print(s);
newLine();
}
}

优雅判空

我们都知道,JAVA 里面最讨厌的一个异常就是NPE=NullPointerException 空指针异常,为了避免空指针异常,我们经常不少使用if 作为判断,这样的判断多了就容易让人看着恼火。例如如下代码:

Person person = new Person("test", 1);
if (person != null) {
if (person.getName() != null) {
System.out.println("123" + person.getName());
} else {
// do something
}
} else {
// do something
}

假设我们有一个person 对象,首先判断它是否为空,如果不为空,则取值,而后再获取 name 成员变量,不为空则拼接打印。这样两层判断的逻辑在代码里经常会见到,学习了 Optional 以后,我们的以上逻辑就可以修改为如下:

// 最佳实践
Optional.ofNullable(person).map(p -> p.getName()).map(string -> string.concat("123")).ifPresent(System.out::println);

Function

入参并返回一个指定类型,可以理解为转换。

首先发现 map 接受一个 Function<? super T, ? extends U> mapper ,具体如何使用Function

@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
// 链式转换
Function<String,Integer> stringToInteger = Integer::valueOf;
// andThen 将前一个处理的返回值作为后一个处理的入参
Function<String,String> integerToString = stringToInteger.andThen(Integer::toHexString); String hex = integerToString.apply("123");
System.out.println(hex);// 7b

Optional

优雅判断空,并且执行对应操作

Optional 对于 NPE 有着很好的解决方式,可以解决我们多重if 的优化,不仅美观,而且非常优雅。

// 如果person 为null 则触发异常
Optional.of(person);
// 如果person1 为 null 则返回empty
Optional.ofNullable(person1);

以上是创建实例的两种方式,一般常用第二种,第一种如果有 null 的情况则会触发 NPE 到头来还是没有处理掉这个异常,所以不建议使用。

private Optional() {
this.value = null;
}
isPresent(): 如果不为空则返回true。
get(): 获取当前包含的值,若是value=null 则抛出NPE
orElse(T other): 如果当前实例包含值为null,则返回other;
ifPresent(Consumer<? super T> consumer): 若当前实例不为空,则执行这个消费者consumer,否则返回EMPTY

Stream

stream 作为 JAVA8 最核心的内容,融汇贯通的掌握其精髓,对开发者而言,无非是一把打开新世界大门的钥匙。从宏观的角度来讲,一个语言处理最多的就是数据的集合,比如 List<?>

filter

过滤器,过滤出你想要的集合元素。

List<Integer> list = Arrays.asList(1, 2, 3, 3, 4, 5, 5, 6);
// 筛选偶数
long num = list.stream().filter(item -> item % 2 == 0).count(); // 3

这里通过简单的筛选,筛选的条件是偶数,并且最终统计它的个数。

这里的 filter 接受一个 filter(Predicate<? super T> predicate)

count 简而言之了,就是统计前方表达式所产生的新集合个数。

Predicate

断言,也是一个函数式接口,可以使用lambda 表达式。

@FunctionalInterface
public interface Predicate<T> { boolean test(T t);

Predicate 主要实现其 test 接口,通过逻辑执行,返回一个 boolean 来判断当前元素是否可用。

// 断言字符串长度大于0
Predicate<String> stringEmpty = (str) -> str.length() > 0;
Predicate<String> startHello = (str) -> str.startsWith("hello"); System.out.println("test 空字符=" + stringEmpty.test(""));
System.out.println("test hello=" + stringEmpty.test("hello")); // and 合并两个检验接口,同时满足即可 or 只要有一个满足即可
System.out.println("test and hello world=" + stringEmpty.and(startHello).test("hello world"));
System.out.println("test or world=" + stringEmpty.or(startHello).test("world"));
----------------------
test 空字符=false
test hello=true
test and hello world=true
test or world=true

map

map 可以理解为映射,处理每个元素,并且返回任何类型。支持链式map,

上层map的返回值作为下层map的参数值。

List<Person> people = Arrays.asList(new Person("hello", 1), new Person("world", 2));
// 将每一个元素的name 组装成一个新的集合。
List<String> names = people.stream().map(item -> item.getName()).collect(Collectors.toList());
System.out.println(names); // 多重map处理
List<String> concat = people.stream().map(item -> item.getName()).map(name -> name.concat("-concat")).collect(Collectors.toList());
System.out.println(concat);
-------------------
[hello, world]
[hello-concat, world-concat]

map 接受一个 map(Function<? super T, ? extends R> mapper) 我们上面已经讨论过这个了。

sorted

对元素进行排序,可以使用默认,也可以自定义排序规则。

List<String> sortedList = Arrays.asList("acc", "dee", "zdd", "wee", "abb", "ccd");

// 默认排序,字典顺序,第一个字母相同,则比较第二个
List<String> sorted = sortedList.stream().sorted().collect(Collectors.toList());
System.out.println(sorted); // 自定义实现,只比较第一个字符
List<String> sorted2 = sortedList.stream().sorted((str1, str2) -> str1.charAt(1) - str2.charAt(1)).collect(Collectors.toList());
System.out.println(sorted2);
---------------------------
[abb, acc, ccd, dee, wee, zdd]
// 可以发现自定义的排序没有比较第二个字母
[acc, abb, ccd, dee, wee, zdd]

我们发现 sorted 接受一个 Comparator<? super T> comparator

Comparator

比较器,也是函数式接口,不必多说,自然可以使用lambda

@FunctionalInterface
public interface Comparator<T> { int compare(T o1, T o2);
Comparator<String> comparator = (str1, str2) -> str1.charAt(0) - str2.charAt(0);

// 自定义比较第一位字母
int a = comparator.compare("abb", "acc");
System.out.println(a); // 再次比较,如果第一个返回0,则直接返回结果,否则进行二次比较
int b = comparator.thenComparing((str1, str2) -> str1.charAt(1) - str2.charAt(1)).compare("abb", "acc");
System.out.println(b); ------------------------------
0
-1

比较器返回一个int 值,这个int 则表示两个元素的排列顺序,按照 ASCII表 指示的值大小,如果两个元素的差值a-b>0 则 a在前,b在后

allMatch/anyMatch

同样,Match 用来处理当前序列中,全部满足、或者部分满足,返回一个布尔值

List<String> sortedList = Arrays.asList("acc", "dee", "zdd", "wee", "abb", "ccd");

// 所有的元素都断言通过,就返回true,否则false
boolean startWithA = sortedList.stream().allMatch(str -> str.startsWith("a"));
System.out.println(startWithA); // 只要有一个满足就返回true
boolean hasA = sortedList.stream().anyMatch(str -> str.startsWith("a"));
System.out.println(hasA);
------------------------
false
true

以上就是 stream 常用的一些总结,总结了一些非常常用的,未总结到的内容下期补充。

其他

这里提一下局部变量final 语义。

自定义函数式接口

模仿以上的任意一个函数接口,我们可以写出这样的一个转换接口,将指定类型转换为指定类型

@FunctionalInterface
public interface FunctionInterface<A, R> { R cover(A t);
}

通过自定义函数接口,我们可以写出如下代码,来进行转换,不过涉及到一些参数的改变。

// num 局部变量如果在lambda 中使用,则隐式含有final 语义
final int num = 1;
FunctionInterface<String, Integer> function4 = (val) -> Integer.valueOf(val + num);
Integer result4 = function4.cover("12");
// num = 2; // 这里不能改变,修改则不能通过编译

以上内容均为博主自我学习中常用的一些总结,难免涉及不全面,还请包涵!

Git

https://gitee.com/mrc1999/java-guide

参考内容

https://snailclimb.gitee.io/javaguide/#/

欢迎关注

JAVA 8 新特性实用总JAVA 8 新特性实用总结结的更多相关文章

  1. Java 8新特性探究(一) JEP126特性lambda表达式和默认方法

    Lambda语法 函数式接口 函数式接口(functional interface 也叫功能性接口,其实是同一个东西).简单来说,函数式接口是只包含一个方法的接口.比如Java标准库中的java.la ...

  2. 【转】Java 8新特性(四):新的时间和日期API

    Java 8另一个新增的重要特性就是引入了新的时间和日期API,它们被包含在java.time包中.借助新的时间和日期API可以以更简洁的方法处理时间和日期. 在介绍本篇文章内容之前,我们先来讨论Ja ...

  3. Java 8新特性(四):新的时间和日期API

    Java 8另一个新增的重要特性就是引入了新的时间和日期API,它们被包含在java.time包中.借助新的时间和日期API可以以更简洁的方法处理时间和日期. 在介绍本篇文章内容之前,我们先来讨论Ja ...

  4. java基础(1)-比较jdk5,jdk6,jdk7的新特性

    jdk8已经出来好长时间了,这里自己学习时简单总结的jdk5,jdk6和jdk7的新特性:本文提纲: 一.jdk5的新特性 二.jdk6的新特性 三.jdk7的新特性 一.jdk5的新特性 首先简单介 ...

  5. Java 11 正式发布,这 8 个逆天新特性教你写出更牛逼的代码

    美国时间 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本. 为什么说是长期版本,看下面的官方发布的支持路线图表. 可以看出 Java 8 扩 ...

  6. 3分钟看完Java 8——史上最强Java 8新特性总结之第四篇 其他新特性

    目录 · 默认方法和静态方法 · 初步理解 · 应用模式 · 优先级问题 · Optional · CompletableFuture · 基本用法 · CompletableFuture与Strea ...

  7. Java 11正式发布,这几个逆天新特性教你写出更牛逼的代码

    就在前段时间,Oracle 官方宣布 Java 11 (18.9 LTS) 正式发布,可在生产环境中使用! 这无疑对我们来说是一大好的消息.作为一名java开发者来说,虽然又要去学习和了解java11 ...

  8. Atitit.swift 的新特性 以及与java的对比 改进方向attilax 总结

    Atitit.swift 的新特性 以及与java的对比 改进方向attilax 总结 1. defer关键字1 2. try!形式存在的“不失败”机制3 3. Guard 4 4. swift的新语 ...

  9. Java JDK 1.7 和 JDK 1.8 新特性

    0 引言 本文主要介绍 Java JDK 中 1.7 和 1.8 的新特性. 1 JDK 1.7 新特性 1. switch可以接受String类型: public class Switch { pu ...

随机推荐

  1. 网络编程(socket简介)

    socket简介 Python 提供了两个基本的 socket 模块. 第一个是 Socket,它提供了标准的 BSD Sockets API. 第二个是 SocketServer, 它提供了服务器中 ...

  2. Redis4.0.1的安装及哨兵模式的配置

    https://blog.csdn.net/u014182745/article/details/76294146

  3. 面试官:请讲一下Redis主从复制的功能及实现原理

    摘要:Redis在主从模式下会有许多问题需要考虑,这里写了一些关于redis在多服务器下的一些问题分析和总结. Redis单节点存在单点故障问题,为了解决单点问题,一般都需要对redis配置从节点,然 ...

  4. .net core 和 WPF 开发升讯威在线客服与营销系统:实现对 IE8 的完全完美支持 【干货】

    本系列文章详细介绍使用 .net core 和 WPF 开发 升讯威在线客服与营销系统 的过程.本产品已经成熟稳定并投入商用. 在线演示环境:https://kf.shengxunwei.com 注意 ...

  5. [ZJOI2007]仓库建设(斜率dp优化)

    前言 纪念一下我做的第二道斜率优化$dp$题,终于自己能把代码敲出来了,然而有很智障的$bug$,把$i$写成$q[i]$,找了半天QAQ.然后写$dp$公式并优化的能力稍微强了一点(自我感觉良好), ...

  6. hdu 6822 Paperfolding 规律+排列组合+逆元

    题意: 给你一片纸,你可以对它进行四种操作,分别是向上.向下.向左.向右对折.把对折之后的纸片横向剪开,再纵向剪开(十字架剪开) 问你你能剪出来的纸片的期望个数 题解(参考:https://blog. ...

  7. Educational DP Contest H - Grid 1 (DP)

    题意:有一个\(n\)X\(m\)的图,"#"表示障碍物,"."表示道路,只能向右或向下走,问从左上角走到右下角的方案数. 题解:这题可以用bfs来搞,但dp更 ...

  8. SpringBoot引入openfeign 报错:spring-cloud-starter-openfeign:unknown

    现象: 1.maven报错:Cannot resolve org.springframework.cloud:spring-cloud-starter-openfeign:unknown 解决: 在h ...

  9. codeforces 8C(非原创)

    C. Looking for Order time limit per test 4 seconds memory limit per test 512 megabytes input standar ...

  10. codefoeces 864B

    B. Polycarp and Letters time limit per test 2 seconds memory limit per test 256 megabytes input stan ...