文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

JAVA 8 新特性实用总JAVA 8 新特性实用总结

2024-12-03 10:48

关注

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

[[382914]]

新特性概述

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

你会使用遍历循环?

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

  1. // 建立测试集合 
  2. List list = Arrays.asList(12234556); 
  3.  
  4. // 基础循环 
  5. System.out.println("----------------------------1 基础循环"); 
  6. for (int i = 0; i < list.size(); i++) { 
  7.     System.out.println(list.get(i)); 
  8.  
  9. // 语法糖方式 
  10. System.out.println("----------------------------2 迭代器语法糖"); 
  11. for (Integer i : list) { 
  12.     System.out.println(i); 
  13.  
  14. // lambda 表达式简写 
  15. System.out.println("----------------------------3 lambda"); 
  16. list.forEach(item -> System.out.println(item)); 
  17.  
  18. // 使用lambda 方法引用 
  19. System.out.println("----------------------------4 lambda"); 
  20. list.forEach(System.out::println); 

 

  1. // 以下为编译后语法糖的代码 
  2. Iterator var4 = list.iterator(); 
  3.  
  4. while(var4.hasNext()) { 
  5.     Integer i = (Integer)var4.next(); 
  6.     System.out.println(i); 

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

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

forEach

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

  1. default void forEach(Consumersuper T> action) { 
  2.     Objects.requireNonNull(action); 
  3.     for (T t : this) { 
  4.         action.accept(t); 
  5.     } 

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

Consumer

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

  1. @FunctionalInterface 
  2. public interface Consumer { 
  3.     void accept(T t); 

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

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

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

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

  1. // 无返回的处理 
  2. Consumer custom = (str) -> System.out.println("first" + str); 
  3. Consumer desc = custom.andThen((str) -> System.out.println("second" + str)); 
  4.  
  5. desc.accept("hello"); 
  6. -------------------------- 
  7. firsthello 
  8. secondhello 

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

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

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

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

default

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

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

  1. default Consumer andThen(Consumersuper T> after) { 
  2.     Objects.requireNonNull(after); 
  3.     return (T t) -> { accept(t); after.accept(t); }; 

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

方法引用

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

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

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

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

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

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

  1. public void println(Object x) { 
  2.     String s = String.valueOf(x); 
  3.     synchronized (this) { 
  4.         print(s); 
  5.         newLine(); 
  6.     } 

优雅判空

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

  1. Person person = new Person("test"1); 
  2. if (person != null) { 
  3.     if (person.getName() != null) { 
  4.         System.out.println("123" + person.getName()); 
  5.     } else { 
  6.         // do something 
  7.     } 
  8. else { 
  9.     // do something 

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

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

Function

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

首先发现 map 接受一个 Function mapper ,具体如何使用Function

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

Optional

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

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

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

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

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

Stream

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

filter

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

  1. List list = Arrays.asList(12334556); 
  2. // 筛选偶数 
  3. long num = list.stream().filter(item -> item % 2 == 0).count(); // 3 

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

这里的 filter 接受一个 filter(Predicate predicate)

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

Predicate

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

  1. @FunctionalInterface 
  2. public interface Predicate { 
  3.  
  4.     boolean test(T t); 

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

  1. // 断言字符串长度大于0 
  2. Predicate stringEmpty = (str) -> str.length() > 0
  3. Predicate startHello = (str) -> str.startsWith("hello"); 
  4.  
  5. System.out.println("test 空字符=" + stringEmpty.test("")); 
  6. System.out.println("test hello=" + stringEmpty.test("hello")); 
  7.  
  8. // and 合并两个检验接口,同时满足即可 or 只要有一个满足即可 
  9. System.out.println("test and hello world=" + stringEmpty.and(startHello).test("hello world")); 
  10. System.out.println("test or world=" + stringEmpty.or(startHello).test("world")); 
  11. ---------------------- 
  12. test 空字符=false 
  13. test hello=true 
  14. test and hello world=true 
  15. test or world=true 

map

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

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

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

map 接受一个 map(Function mapper) 我们上面已经讨论过这个了。

sorted

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

  1. List sortedList = Arrays.asList("acc""dee""zdd""wee""abb""ccd"); 
  2.  
  3. // 默认排序,字典顺序,第一个字母相同,则比较第二个 
  4. List sorted = sortedList.stream().sorted().collect(Collectors.toList()); 
  5. System.out.println(sorted); 
  6.  
  7. // 自定义实现,只比较第一个字符 
  8. List sorted2 = sortedList.stream().sorted((str1, str2) -> str1.charAt(1) - str2.charAt(1)).collect(Collectors.toList()); 
  9. System.out.println(sorted2); 
  10. --------------------------- 
  11. [abb, acc, ccd, dee, wee, zdd] 
  12. // 可以发现自定义的排序没有比较第二个字母 
  13. [acc, abb, ccd, dee, wee, zdd] 

我们发现 sorted 接受一个 Comparator comparator

Comparator

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

  1. @FunctionalInterface 
  2. public interface Comparator { 
  3.  
  4.     int compare(T o1, T o2); 

 

  1. Comparator comparator = (str1, str2) -> str1.charAt(0) - str2.charAt(0); 
  2.  
  3. // 自定义比较第一位字母 
  4. int a = comparator.compare("abb""acc"); 
  5. System.out.println(a); 
  6.  
  7. // 再次比较,如果第一个返回0,则直接返回结果,否则进行二次比较 
  8. int b = comparator.thenComparing((str1, str2) -> str1.charAt(1) - str2.charAt(1)).compare("abb""acc"); 
  9. System.out.println(b); 
  10.  
  11. ------------------------------ 
  12. 0 
  13. -1 

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

allMatch/anyMatch

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

  1. List sortedList = Arrays.asList("acc""dee""zdd""wee""abb""ccd"); 
  2.  
  3. // 所有的元素都断言通过,就返回true,否则false 
  4. boolean startWithA = sortedList.stream().allMatch(str -> str.startsWith("a")); 
  5. System.out.println(startWithA); 
  6.  
  7. // 只要有一个满足就返回true 
  8. boolean hasA = sortedList.stream().anyMatch(str -> str.startsWith("a")); 
  9. System.out.println(hasA); 
  10. ------------------------ 
  11. false 
  12. true 

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

其他

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

自定义函数式接口

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

  1. @FunctionalInterface 
  2. public interface FunctionInterface { 
  3.  
  4.     R cover(A t); 

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

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

 

来源:博客园内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯