JAVA 8 新特性实用总结
作为一个工作两年多的 老 程序猿，虽然一开始就使用 jdk1.8 作为学习和使用的版本，随着技术的迭代，现有的 JDK 版本从两年前到目前，已经飞速发展到了 JDK 15 。真的感觉有点学不动了，更新速度太快了，不过相比于现有系统以及国内趋势。大多公司还是采用最基础的 1.8 作为线上环境来使用。也是没有任何问题的，不过我们真的 会使用 JAVA8 吗？
https://www.oracle.com/java/technologies/java-se-glance.html
新特性概述
本小结主要从 Lambda 表达式入手，由浅入深，按照实用性作为排行，逐步讲解新特性带给开发人员的快乐，如何更好的简化代码，优化可读性。这才是我们学习总结这一小节的一个目的。
你会使用遍历循环？
从最基础的循环开始，循环无非是我们刚学习的时候就需要接触 for 这个最基本的循环结构，而且在后面的工作中都会大量使用的一个结构，如何更好的简化它呢？
// 建立测试集合Listlist= Arrays.asList(1,2,2,3,4,5,5,6);// 基础循环System.out.println(“—————————-1 基础循环”);for(int i =0; i 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 方式的引入，代码变得越来越简化，而且更加容易读懂，写的东西也越来越少，
第一种方式则是我们常规的操作方式，一般适用于需要 下标 逻辑的业务中。
第二种则是迭代器语法糖，对于开发者而言写起来便捷，不过对于代码的编译而言，编译后的代码仍是迭代器的方式，只不过语法简单了。
lambda 则是一种函数式的表达方式，item 作为我们循环的参数，而箭头后则是我们需要执行的代码块，一句代码完全不必使用 {}
lambda 方法引用 则是一种全新的方式， 引用 二字常常被我们使用，一般在对象的引用处有表达的含义，简而言之就是 一个值可以从一个地方引用过来使用 ，但是目前，方法完全可以被看做一个 值 一样，也可以随意拿过来使用~
forEach
可能朋友们就会有疑惑，为什么 forEach 的地方就可以使用 lambda 表达式呢，其他地方怎么不行？我们来看看源码
defaultvoidforEach(Consumer action){ Objects.requireNonNull(action);for(T t :this) { action.accept(t); }}
我们发现 Consumer 是一个接口，内部依旧使用 for语法糖 形式来执行集合，调用了 accept 方法。
Consumer
消费者接口，适用于入参处理，无返回值
@FunctionalInterfacepublicinterfaceConsumer{voidaccept(T t);
发现这个接口和其他接口唯一的不同点就是 @FunctionalInterface
实则这个注解就是来告知编译器，这个接口下的 accept 方法可以使用函数式写法来描述。有了这个注解的定义，我们就可以愉快地使用函数式lambda 表达式了。
消费者接口 作为JDK 自带的函数式接口，所处于 java.util.function 包下，并且支持链式操作，
接受一个指定的泛型，内部处理后，无返回值
// 无返回的处理Consumer custom = (str) -> System.out.println(“first”+str);Consumer desc = custom.andThen((str) -> System.out.println(“second”+str));desc.accept(“hello”);————————–firsthellosecondhello
稍稍总结一下lambda 的基础语法：
（参数）-> 一行执行代码
（参数）-> {多行执行代码}
单个参数完全可以省略参数的括号。
default
默认实现，子类无需重写接口定义的关键词
上面的Consumer使用中，我们发现，有一个默认实现的接口，顺便来说明一下
defaultConsumerandThen(Consumer 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 刚好具备这样的形式。
publicvoidprintln(Objectx) {Strings =String.valueOf(x); synchronized (this) { print(s); newLine(); }}
优雅判空
我们都知道，JAVA 里面最讨厌的一个异常就是 NPE=NullPointerException 空指针异常，为了避免空指针异常，我们常常不少使用 if 作为判断，这样的判断多了就容易让人看着恼火。例如如下代码：
Person person =newPerson(“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
@FunctionalInterfacepublicinterfaceFunction{Rapply(T t);
// 链式转换Function stringToInteger = Integer::valueOf;// andThen 将前一个处理的返回值作为后一个处理的入参Function integerToString = stringToInteger.andThen(Integer::toHexString);Stringhex = integerToString.apply(“123”);System.out.println(hex);// 7b
Optional
优雅判断空，并且执行对应操作
Optional 对于 NPE 有着很好的解决方式，可以解决我们多重if 的优化，不仅美观，而且超级优雅。
// 如果person 为null 则触发异常Optional.of(person);// 如果person1 为 null 则返回emptyOptional.ofNullable(person1);
以上是创建实例的两种方式，一般常用第二种，第一种如果有 null 的情况则会触发 NPE 到头来还是没有处理掉这个异常，所以不提议使用。
privateOptional(){this.value=null;}
isPresent(): 如果不为空则返回true。get(): 获取当前包含的值，若是value=null则抛出NPEorElse(T other): 如果当前实例包含值为null,则返回other; ifPresent(Consumer consumer): 若当前实例不为空，则执行这个消费者consumer,否则返回EMPTY
Stream
stream 作为 JAVA8 最核心的内容，融汇贯通地掌握其精髓，对开发者而言，无非是一把打开新世界大门的钥匙。从宏观的角度来讲，一个语言处理最多的就是数据的集合，列如 List<?>
filter
过滤器，过滤出你想要的集合元素。
List<Integer>list=Arrays.asList(1,2,3,3,4,5,5,6);//筛选偶数longnum=list.stream().filter(item->item%2==0).count();//3
这里通过简单的筛选，筛选的条件是偶数，并且最终统计它的个数。
这里的 filter 接受一个 filter(Predicate<? super T> predicate)
count 简而言之了，就是统计前方表达式所产生的新集合个数。
Predicate
断言，也是一个函数式接口，可以使用lambda 表达式。
@FunctionalInterfacepublicinterfacePredicate{booleantest(T t);
Predicate 主要实现其 test 接口，通过逻辑执行，返回一个 boolean 来判断当前元素是否可用。
// 断言字符串长度大于0 Predicate stringEmpty = (str) -> str.length() > 0; Predicate 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空字符=falsetesthello=truetestand hello world=truetestor world=true
map
map 可以理解为映射，处理每个元素，并且返回任何类型。支持链式map,
上层map的返回值作为下层map的参数值。
List people = Arrays.asList(new Person(“hello”,1), new Person(“world”,2)); // 将每一个元素的name 组装成一个新的集合。 List names = people.stream().map(item -> item.getName()).collect(Collectors.toList()); System.out.println(names); // 多重map处理 Listconcat= 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 sortedList = Arrays.asList(“acc”,”dee”,”zdd”,”wee”,”abb”,”ccd”);// 默认排序，字典顺序，第一个字母一样，则比较第二个List sorted = sortedList.stream().sorted().collect(Collectors.toList());System.out.println(sorted);// 自定义实现，只比较第一个字符List 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
@FunctionalInterfacepublicinterfaceComparator{intcompare(T o1, T o2);
Comparator 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 sortedList = Arrays.asList(“acc”,”dee”,”zdd”,”wee”,”abb”,”ccd”);// 所有的元素都断言通过，就返回true,否则falseboolean startWithA = sortedList.stream().allMatch(str->str.startsWith(“a”));System.out.println(startWithA);// 只要有一个满足就返回trueboolean hasA = sortedList.stream().anyMatch(str->str.startsWith(“a”));System.out.println(hasA);————————falsetrue
以上就是 stream 常用的一些总结，总结了一些超级常用的，未总结到的内容下期补充。
其他
这里提一下局部变量final 语义。
自定义函数式接口
模仿以上的任意一个函数接口，我们可以写出这样的一个转换接口，将指定类型转换为指定类型
@FunctionalInterfacepublicinterfaceFunctionInterface{Rcover(A t);}
通过自定义函数接口，我们可以写出如下代码，来进行转换，不过涉及到一些参数的改变。
//num 局部变量如果在lambda 中使用，则隐式含有final 语义 final int num =1; FunctionInterface function4 =(val)->Integer.valueOf(val + num); Integer result4 = function4.cover(“12”);//num =2;//这里不能改变，修改则不能通过编译
暂无评论内容