JAVA8新特性(上)

超、凢脫俗 2021-08-19 13:45 319阅读 0赞

# 1. 简介 #

毫无疑问，[Java 8][]是Java自Java 5（发布于2004年）之后的最重要的版本。这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。

在本文中我们将学习这些新特性，并用实际的例子说明在什么场景下适合使用。

这个教程包含Java开发者经常面对的几类问题：

*  语言
 *  编译器
 *  库
 *  工具
 *  运行时（JVM）

# 2. Java语言的新特性 #

Java 8是Java的一个重大版本，有人认为，虽然这些新特性领Java开发人员十分期待，但同时也需要花不少精力去学习。在这一小节中，我们将介绍Java 8的大部分新特性。

## 2.1 Lambda表达式和函数式接口 ##

Lambda表达式（也称为闭包）是Java 8中最大和最令人期待的语言改变。它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理：[函数式开发者][Link 1]非常熟悉这些概念。

(parameters参数) -> expression表达式或方法体

paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数     ->：可理解为“被用于”的意思

Lambda的设计耗费了很多时间和很大的社区力量，最终找到一种折中的实现方案，可以实现简洁而紧凑的语言结构。

Lambda表达式可以引用类成员和局部变量（会将这些变量隐式得转换成**final**的），例如下列两个代码块的效果完全相同：

String separator = ",";
    Arrays.asList( "a", "b", "d" ).forEach( 
        ( String e ) -> System.out.print( e + separator ) );

和

final String separator = ",";
    Arrays.asList( "a", "b", "d" ).forEach( 
        ( String e ) -> System.out.print( e + separator ) );

匿名传统内部类与使用lambad比较

// 使用 java 7 排序（传统的使用匿名内部类）
        private void sortUsingJava7(List<String> names) {
            Collections.sort(names, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return o1.compareTo(o2);
                }
            });
        }
    
        // 使用 java 8 排序（使用lambad）
        private void sortUsingJava8(List<String> names) {
            Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
    }

**公共定义的函数式接口**

a.功能性接口：Function<T, R>，有输入参数，有返回值，是对接收一个T类型参数，返回R类型的结果的方法的抽象，通过调用apply方法执行内容

需求：给定一个字符串，返回字符串长度

public class Main {
        public static void main(String[] args) {
            String str = "helloworld";
            int length = testFun(str, (s) -> s.length());
            System.out.println(length);
        }
        public static int testFun(String str, Function<String, Integer> fun) {
            // 执行
            Integer length = fun.apply(str);
            return length;
        }
    
    }

实例方法引用

排序后输出

b.消费型接口：Consumer<T>

有输入参数，没返回值

对应的方法类型为接收一个参数，没有返回值

一般来说使用Consumer接口往往伴随着一些期望状态的改变

或者事件的发生，典型的forEach就是使用的Consumer接口

虽然没有任何的返回值，但是向控制台输出结果

Consumer 使用accept对参数执行行为

public class Main {
        public static void main(String[] args) {
            String str = "helloworld";
            testCon(str,(s)->System.out.println(s));
        }
    
        public static void testCon(String str, Consumer<String> con) {
            // 执行
            con.accept(str);
        }
    
    }

c.供给型接口：Supplier<T>，无传入参数，有返回值，该接口对应的方法类型不接受参数，但是提供一个返回值，使用get()方法获得这个返回值

public class Main {
        public static void main(String[] args) {
            String str = "helloworld";
            String resultStr = testSup(()->str);
            System.out.println(resultStr);
        }
    
        public static String testSup(Supplier<String> sup) {
            // 执行
            String s = sup.get();
            return s;
        }
    }

d.断言型接口：Predicate<T>

有传入参数，有返回值Boolean

该接口对应的方法为接收一个参数，返回一个Boolean类型值

多用于判断与过滤，使用test()方法执行这段行为

需求：输入字符串，判断长度是否大于0

public class Main {
        public static void main(String[] args) {
            String str = "helloworld";
            Boolean flg = testSup(str,(s)->str.length()>0);
            if (flg){
                System.out.println("字符串大于0");
            }else {
                System.out.println("字符串小于0");
            }
        }
        public static Boolean testSup(String str,Predicate<String> pre) {
            // 执行
            Boolean b = pre.test(str);
            return b;
        }
    }

### 2.2 lambad表达式优点 ###

a.极大的减少代码冗余，同时可读性也好过冗长的匿名内部类

b.与集合类批处理操作结合，实现内部迭代，并充分利用现代多核CPU进行并行计算。之前集合类的迭代都是外部的，即客户代码。而内部迭代意味着由Java类库来进行迭代，而不是客户代码

流的性能测试：[https://mp.weixin.qq.com/s/-p-N-K\_oY-vGtvBIKUqShA][https_mp.weixin.qq.com_s_-p-N-K_oY-vGtvBIKUqShA]

# 2. Java官方库的新特性 #

Java 8增加了很多新的工具类（date/time类），并扩展了现存的工具类，以支持现代的并发编程、函数式编程等。

## 2.1 Optional ##

Java应用中最常见的bug就是[空值异常][Link 2]。在Java 8之前，[Google Guava][]引入了**Optionals**类来解决**NullPointerException**，从而避免源码被各种**null**检查污染，以便开发者写出更加整洁的代码。Java 8也将**Optional**加入了官方库。

接下来看一点使用**Optional**的例子：可能为空的值或者某个类型的值：

Optional< String > fullName = Optional.ofNullable( null );
    System.out.println( "Full Name is set? " + fullName.isPresent() );        
    System.out.println( "Full Name: " + fullName.orElseGet( () -> "[none]" ) ); 
    System.out.println( fullName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );

如果**Optional**实例持有一个非空值，则**isPresent()**方法返回true，否则返回false；**orElseGet()**方法，**Optional**实例持有null，则可以接受一个lambda表达式生成的默认值；**map()**方法可以将现有的**Opetional**实例的值转换成新的值；**orElse()**方法与**orElseGet()**方法类似，但是在持有null的时候返回传入的默认值。

上述代码的输出结果如下：

Full Name is set? false
    Full Name: [none]
    Hey Stranger!

## 2.2 Streams ##

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
            strings.forEach(s -> System.out.println(s));//全部输出
            List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());//经过过滤后输出
            filtered.forEach(s -> System.out.println(s));

A.流中使用forEach来迭代流中的每个数据

Random random = new Random();
    random.ints().limit(10).forEach(System.out :: println);
    List<String> strings1 = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
    long count = strings1.stream().filter(s -> s.isEmpty()).count();

B.Filter方法用于通过设置的条件过滤出元素（见上面程序）

C.limit 方法用于获取指定数量的流见下面程序（获取10个数）

Random random2 = new Random();
    random2.ints().limit(10).sorted().forEach(System.out::println);

D.sorted 方法用于对流进行排序，见上面程序

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
    Long count2 = strings.parallelStream().filter(string -> string.isEmpty()).count();
    System.out.println("并行（parallel）程序空字符串的数量" + count2);

E.并行处理字符串(与fork/join原理一样，利用多核CPU)

List<String> strings3 = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    List<String> filtered1  = strings3.stream().filter(s -> !s.isEmpty()).collect(Collectors.toList());
    System.out.println("筛选列表: " + filtered1);

//将流中的元素放置到一个列表集合中去。这个列表默认为ArrayList

String mergedString  = strings3.stream().filter(s -> !s.isEmpty()).collect(Collectors.joining(","));
     System.out.println("合并字符串: " + mergedString);

//joining的目的是将流中的元素全部以字符序列的方式连接到一起，可以指定连接符，甚至是结果的前后缀。

## 2.3 Nashorn JavaScript引擎 ##

Java 8提供了新的[Nashorn JavaScript引擎][Nashorn JavaScript]，使得我们可以在JVM上开发和运行JS应用。Nashorn [JavaScript][]引擎是javax.script.ScriptEngine的另一个实现版本，这类Script引擎遵循相同的规则，允许Java和JavaScript交互使用，例子代码如下：

ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName( "JavaScript" );
    System.out.println( engine.getClass().getName() );
    System.out.println( "Result:" + engine.eval( "function f() { return 1; }; f() + 1;" ) );

这个代码的输出结果如下：

jdk.nashorn.api.scripting.NashornScriptEngine
    Result: 2

## 2.4 Base64 ##

[对Base64编码的支持][Base64]已经被加入到Java 8官方库中，这样不需要使用第三方库就可以进行Base64编码，例子代码如下：

package com.javacodegeeks.java8.base64;
    import java.nio.charset.StandardCharsets;
    import java.util.Base64;
    
    public class Base64s {
        public static void main(String[] args) {
            final String text = "Base64 finally in Java 8!";
            final String encoded = Base64
                .getEncoder()
                .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
            System.out.println( encoded );
            final String decoded = new String( 
                Base64.getDecoder().decode( encoded ),
                StandardCharsets.UTF_8 );
            System.out.println( decoded );
        }
    }

这个例子的输出结果如下：

QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ==
    Base64 finally in Java 8!

新的Base64API也支持URL和MINE的编码解码。  
(**Base64.*getUrlEncoder*()** / **Base64.*getUrlDecoder*()**, **Base64.*getMimeEncoder*()** / **Base64.*getMimeDecoder*()**)。

BASE64不是用来加密的，是BASE64编码后的字符串，例如：在上传图片时候就会将图片转成base64，之前用过的freemark生成world文档就是。全部都是由标准键盘上面的常规字符组成，这样编码后的字符串在网关之间传递不会产生[UNICODE][]字符串不能识别或者丢失的现象。你再仔细研究下[EMAIL][]就会发现其实[EMAIL][]就是用base64编码过后再发送的。然后接收的时候再还原。

### 2.5 并行数组 ###

Java8版本新增了很多新的方法，用于支持并行数组处理。最重要的方法是**parallelSort()**，可以显著加快多核机器上的数组排序。下面的例子论证了**parallexXxx**系列的方法：

package com.javacodegeeks.java8.parallel.arrays;
    import java.util.Arrays;
    import java.util.concurrent.ThreadLocalRandom;
    public class ParallelArrays {
        public static void main( String[] args ) {
            long[] arrayOfLong = new long [ 20000 ];        
            Arrays.parallelSetAll( arrayOfLong, 
                index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
            Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
                i -> System.out.print( i + " " ) );//取前10位数
            System.out.println();
            Arrays.parallelSort( arrayOfLong );        
            Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
                i -> System.out.print( i + " " ) );//排序后取前10位数
            System.out.println();
        }
    }

上述这些代码使用**parallelSetAll()**方法生成20000个随机数，然后使用**parallelSort()**方法进行排序。这个程序会输出乱序数组和排序数组的前10个元素。上述例子的代码输出的结果是：

Unsorted: 591217 891976 443951 424479 766825 351964 242997 642839 119108 552378 
    Sorted: 39 220 263 268 325 607 655 678 723 793

# 3. 新的Java工具 #

Java 8提供了一些新的命令行工具，这部分会讲解一些对开发者最有用的工具。

## 3.1 Nashorn引擎：jjs ##

**jjs**是一个基于标准Nashorn引擎的命令行工具，可以接受js源码并执行。例如，我们写一个**func.js**文件，内容如下：

function f() { 
         return 1; 
    }; 
    
    print( f() + 1 );

可以在命令行中执行这个命令：`jjs func.js`，控制台输出结果是：

如果需要了解细节，可以参考[官方文档][Link 3]。

## 3.2 类依赖分析器：jdeps ##

**jdeps**是一个相当棒的命令行工具，它可以展示包层级和类层级的Java类依赖关系，它以**.class**文件、目录或者Jar文件为输入，然后会把依赖关系输出到控制台。

我们可以利用jedps分析下[Spring Framework库][Spring Framework]，为了让结果少一点，仅仅分析一个JAR文件：**org.springframework.core-3.0.5.RELEASE.jar**。

jdeps org.springframework.core-3.0.5.RELEASE.jar

这个命令会输出很多结果，我们仅看下其中的一部分：依赖关系按照包分组，如果在classpath上找不到依赖，则显示"not found".

org.springframework.core-3.0.5.RELEASE.jar -> C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar
       org.springframework.core (org.springframework.core-3.0.5.RELEASE.jar)
          -> java.io                                            
          -> java.lang                                          
          -> java.lang.annotation                               
          -> java.lang.ref                                      
          -> java.lang.reflect                                  
          -> java.util                                          
          -> java.util.concurrent                               
          -> org.apache.commons.logging                         not found
          -> org.springframework.asm                            not found
          -> org.springframework.asm.commons                    not found
       org.springframework.core.annotation (org.springframework.core-3.0.5.RELEASE.jar)
          -> java.lang                                          
          -> java.lang.annotation                               
          -> java.lang.reflect                                  
          -> java.util

**其他补充**

Lambda的设计者们为了让现有的功能与Lambda表达式良好兼容，考虑了很多方法，于是产生了**[函数接口][Link 4]**这个概念。函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。**java.lang.Runnable**和**java.util.concurrent.Callable**是函数式接口的最佳例子。在实践中，函数式接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解**@FunctionalInterface**（Java 库中的所有相关接口都已经带有这个注解了），举个简单的函数式接口的定义：

@FunctionalInterface
    public interface Functional {
        void method();
    }

不过有一点需要注意，[默认方法和静态方法][Link 5]不会破坏函数式接口的定义，因此如下的代码是合法的。

@FunctionalInterface
    public interface FunctionalDefaultMethods {
        void method();
    
        default void defaultMethod() {            
        }        
    }

Lambda表达式作为Java 8的最大卖点，它有潜力吸引更多的开发者加入到JVM平台，并在纯Java编程中使用函数式编程的概念。如果你需要了解更多Lambda表达式的细节，可以参考[官方文档][Link 6]。

## ##

### Date/Time API(JSR 310) ###

Java 8引入了[新的Date-Time API(JSR 310)][Date-Time API_JSR 310]来改进时间、日期的处理。时间和日期的管理一直是最令Java开发者痛苦的问题。**java.util.Date**和后来的**java.util.Calendar**一直没有解决这个问题（甚至令开发者更加迷茫）。

**1、本地化日期时间 API**

public class Main {
    
        public static void main(String[] args) {
            Main java8tester = new Main();
            java8tester.testLocalDateTime();
        }
    
        public void testLocalDateTime(){
    
            // 获取当前的日期时间
            LocalDateTime currentTime = LocalDateTime.now();
            System.out.println("当前时间: " + currentTime);
    
            LocalDate date1 = currentTime.toLocalDate();
            System.out.println("date1: " + date1);
    
            Month month = currentTime.getMonth();
            int day = currentTime.getDayOfMonth();
            int seconds = currentTime.getSecond();
    
            System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
    
            LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
            System.out.println("date2: " + date2);
    
            // 12 december 2014
            LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
            System.out.println("date3: " + date3);
    
            // 22 小时 15 分钟
            LocalTime date4 = LocalTime.of(22, 15);
            System.out.println("date4: " + date4);
    
            // 解析字符串
            LocalTime date5 = LocalTime.parse("20:15:30");
            System.out.println("date5: " + date5);
        }
    }

输出结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTc4OTk4_size_16_color_FFFFFF_t_70][]

**2、使用时区的日期时间API**

public class Main {
    
        public static void main(String[] args) {
            Main java8tester = new Main();
            java8tester.testZonedDateTime();
        }
    
        public void testZonedDateTime(){
    
            // 获取当前时间日期
            ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
            System.out.println("date1: " + date1);
    
            ZoneId id = ZoneId.of("Europe/Paris");
            System.out.println("ZoneId: " + id);
    
            ZoneId currentZone = ZoneId.systemDefault();
            System.out.println("当期时区: " + currentZone);
        }
    }

![20191202154058481.png][]

待分析：

### 方法引用 ###

### 重复注解 ###

[Java 8]: http://www.oracle.com/technetwork/java/javase/8train-relnotes-latest-2153846.html
[Link 1]: http://www.javacodegeeks.com/2014/03/functional-programming-with-java-8-lambda-expressions-monads.html
[https_mp.weixin.qq.com_s_-p-N-K_oY-vGtvBIKUqShA]: https://mp.weixin.qq.com/s/-p-N-K_oY-vGtvBIKUqShA
[Link 2]: http://examples.javacodegeeks.com/java-basics/exceptions/java-lang-nullpointerexception-how-to-handle-null-pointer-exception/
[Google Guava]: http://code.google.com/p/guava-libraries/
[Nashorn JavaScript]: http://www.javacodegeeks.com/2014/02/java-8-compiling-lambda-expressions-in-the-new-nashorn-js-engine.html
[JavaScript]: http://lib.csdn.net/base/javascript
[Base64]: http://www.javacodegeeks.com/2014/04/base64-in-java-8-its-not-too-late-to-join-in-the-fun.html
[UNICODE]: https://www.baidu.com/s?wd=UNICODE&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YLnAPBmhuWuHmkPW-huj6Y0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnHnvn1cLrjRd
[EMAIL]: https://www.baidu.com/s?wd=EMAIL&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YLnAPBmhuWuHmkPW-huj6Y0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnHnvn1cLrjRd
[Link 3]: http://docs.oracle.com/javase/8/docs/technotes/tools/unix/jjs.html
[Spring Framework]: http://blog.csdn.net/yczz/article/details/50896975
[Link 4]: http://www.javacodegeeks.com/2013/03/introduction-to-functional-interfaces-a-concept-recreated-in-java-8.html
[Link 5]: https://www.javacodegeeks.com/2014/05/java-8-features-tutorial.html#Interface_Default
[Link 6]: http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
[Date-Time API_JSR 310]: https://jcp.org/en/jsr/detail?id=310
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTc4OTk4_size_16_color_FFFFFF_t_70]: /images/20210708/5875cbf8a6ac46d5b8907b73cdde19e3.png
[20191202154058481.png]: /images/20210708/f7fba35d3edc478496334f56c47f1f07.png