Java8新特性总结


Nothing is imposible for a willing heart.

Java 8 (又称为 jdk 1.8)已经发布很久了,这是一次重要的版本升级。对于它涵盖的新的特性,包含语言、编译器、库、工具和JVM等方面。最近对其进行了学习,总结了Java8的大部分新特性,希望对初学者有所帮助。

一、Java语言新特性:

1、lambda语言

Lambda表达式(也称为闭包)是Java 8中最大的语言改变。

Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

lambda 表达式的语法格式如下:

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

以下是lambda表达式的重要特征:

可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。

可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。

可选的大括号:如果主体包含了一个语句,就不需要使用大括号。

可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值。

实例如下:

// 类型声明

MathOperation addition = (int a, int b) -> a + b;

// 不用类型声明

MathOperation subtraction = (a, b) -> a - b;

// 大括号中的返回语句

MathOperation multiplication = (int a, int b) -> { return a * b; };

// 没有大括号及返回语句

MathOperation division = (int a, int b) -> a / b;

// 不用括号

GreetingService greetService1 = message ->

System.out.println("Hello " + message);

// 用括号

GreetingService greetService2 = (message) ->

System.out.println("hello" + message);

变量作用域:lambda 表达式只能引用 final 或 final 局部变量,这就是说不能在 lambda 内部修改定义在域外的变量,否则会编译错误。


如果你需要了解更多Lambda表达式的细节,可以参考官方文档

2、函数式接口

Lambda的设计者们为了让现有的功能与Lambda表达式良好兼容,考虑了很多方法,于是产生了函数接口这个概念。

函数式接口(Functional Interface)就是一个具有一个方法的普通接口

函数式接口可以被隐式转换为lambda表达式。

函数式接口可以现有的函数友好地支持 lambda。

JDK 1.8之前已有的函数式接口:

java.lang.Runnable

java.util.concurrent.Callable

java.security.PrivilegedAction

java.util.Comparator

java.io.FileFilter

JDK 1.8 新增加的函数接口:

java.util.function

在实践中,函数式接口非常脆弱:只要某个开发者在该接口中添加一个函数,则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性,并显式说明某个接口是函数式接口,Java 8 提供了一个特殊的注解@FunctionalInterface

@FunctionalInterface

public interface Functional{

void method();

}

需要注意,默认方法和静态方法不会破坏函数式接口的定义,因此如下的代码是合法的。

@FunctionalInterface

public interface DefaultMethods{

void method();

default void defaultMethod(){              

     }      

  }

3、默认方法和静态方法

Java 8使用两个新概念扩展了接口的含义:默认方法和静态方法。

简单说,默认方法就是接口可以有实现方法,而且不需要实现类去实现其方法。

我们只需在方法名前面加个default关键字即可实现默认方法。

为什么要有这个特性?

首先,之前的接口是个双刃剑,好处是面向抽象而不是面向具体编程,缺陷是,当需要修改接口时候,需要修改全部实现该接口的类。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

private interface DefaulableFactory{

// Interfaces now allow static methods

static Defaulable create(Supplier< Defaulable > supplier){returnsupplier.get();    }}

下面的代码片段整合了默认方法和静态方法的使用场景:

public static void main( String[] args ){  

  Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new);   

 System.out.println( defaulable.notRequired() );    

defaulable = DefaulableFactory.create( OverridableImpl::new);    

System.out.println( defaulable.notRequired() );}

这段代码的输出结果如下:

Defaultimplementation

Overridden implementation

由于JVM上的默认方法的实现在字节码层面提供了支持,因此效率非常高。默认方法允许在不打破现有继承体系的基础上改进接口。该特性在官方库中的应用是:给java.util.Collection接口添加新方法,如stream()parallelStream()forEach()removeIf()等等。

尽管默认方法有这么多好处,但在实际开发中应该谨慎使用:在复杂的继承体系中,默认方法可能引起歧义和编译错误。如果你想了解更多细节,可以参考官方文档

4、方法引用

方法引用通过方法的名字来指向一个方法。

方法引用使用一对冒号(::)

方法引用使得开发者可以直接引用现存的方法、Java类的构造方法或者实例对象。方法引用和Lambda表达式配合使用,使语言的构造更紧凑简洁。

public static class Car {

public static Car create( final Supplier< Car > supplier ) {

return supplier.get();

}

public static void collide( final Car car ) {

System.out.println( "Collided " + car.toString() );

}

public void follow( final Car another ) {

System.out.println( "Following the " + another.toString() );

}

public void repair() {

System.out.println( "Repaired " + this.toString() );

}

}

第一种方法引用的类型是构造器引用,语法是Class::new,或者更一般的形式:Class::new。注意:这个构造器没有参数。

finalCar car = Car.create( Car::new );

finalList< Car > cars = Arrays.asList( car );

第二种方法引用的类型是静态方法引用,语法是Class::static_method。注意:这个方法接受一个Car类型的参数。

cars.forEach(Car::collide );

第三种方法引用的类型是某个类的成员方法的引用,语法是Class::method,注意,这个方法没有定义入参:

cars.forEach(Car::repair );

第四种方法引用的类型是某个实例对象的成员方法的引用,语法是instance::method。注意:这个方法接受一个Car类型的参数:

finalCar police = Car.create( Car::new );

cars.forEach( police::follow );

如果想了解和学习更详细的内容,可以参考官方文档

5、重复注解@Repeatable

注解有一个很大的限制是:在同一个地方不能多次使用同一个注解。Java 8打破了这个限制,引入了重复注解的概念,允许在同一个地方多次使用同一个注解。

package java8Test;

import java.lang.annotation.ElementType;

import java.lang.annotation.Repeatable;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

public class RepeatingAnnotations {

@Target( ElementType.TYPE )

@Retention( RetentionPolicy.RUNTIME )

public @interface Filters {

Filter[] value();

}

@Target( ElementType.TYPE )

@Retention( RetentionPolicy.RUNTIME )

@Repeatable( Filters.class )

public @interface Filter {

String value();

};

@Filter( "filter1" )

@Filter( "filter2" )

public interface Filterable {

}

public static void main(String[] args) {

for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {

System.out.println( filter.value() );

     }

  }

}

这里的Filter类使用@Repeatable(Filters.class)注解修饰,而Filters是存放Filter注解的容器,编译器尽量对开发者屏蔽这些细节。这样,Filterable接口可以用两个Filter注解注释(这里并没有提到任何关于Filters的信息)。

另外,反射API提供了一个新的方法:getAnnotationsByType(),可以返回某个类型的重复注解,例如Filterable.class.getAnnoation(Filters.class)将返回两个Filter实例,输出到控制台的内容如下所示:

filter1

filter2

如果你希望了解更多内容,可以参考官方文档

二、Java官方库新特性:

1、Optional类

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。

Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常

注意:这些方法是从java.lang.Object类继承来的。

实例如下:

public class OptionalTest {

public static void main(String[] args) {

// TODO Auto-generated method stub

OptionalTest o=new OptionalTest();

Integer value1=null;

Integer value2 = new Integer(10);

// Optional.ofNullable - 允许传递为 null 参数      

Optionala = Optional.ofNullable(value1);            

  // Optional.of - 如果传递的参数是 null,抛出异常 NullPointerException     

 Optionalb = Optional.of(value2);      

System.out.println(o.sum(a,b)); 

  }      

 public Integer sum(Optionala, Optionalb){

// Optional.isPresent - 判断值是否存在

System.out.println("第一个参数值存在: " + a.isPresent());

System.out.println("第二个参数值存在: " + b.isPresent());

// Optional.orElse - 如果值存在,返回它,否则返回默认值

Integer value1 = a.orElse(new Integer(0));

System.out.println(value1);//0

//Optional.get - 获取值,值需要存在

Integer value2 = b.get();

return value1 + value2;

  }

}

如果想了解更多的细节,请参考官方文档

2、Stream

Java 8 API添加了一个新的抽象称为流Stream,将生成环境的函数式编程引入了Java库中。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提供Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。

元素流在管道中经过中间操作(intermediate operation)的处理,最后由最终操作(terminal operation)得到前面处理的结果。

+-----------------------------------++--------++-----------++-----------++-------+

| stream of elements+-----> | filter+-> | sorted+-> | map+-> |collect |

+-----------------------------------++--------++-----------++-----------++-------+

forEach:

Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数:

Random random=new Random();

random.ints().limit(10).forEach(System.out::println);

map:

map 方法用于映射每个元素到对应的结果,以下代码片段使用 map 输出了元素对应的平方数:

List numbers=Arrays.asList(3,2,2,3,7,3,5);

//获取对应的平方数

List squaresList=numbers.stream().map(i->i*i).distinct().collect(Collectors.toList());

filter:

filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串:

List strings=Arrays.asList("abc","","bc","efg","abcd","","jkl");

//获取空字符串的数量

int count=strings.stream().filter(string->string.isEmpty()).count();

limit:

limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据:

Random random=new Random();

random.ints().limit(10).forEach(System.out::println);

sorted:

sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序:

Random random=new Random();

random.ints().limit(10).sorted().forEach(System.out::println);

并行(parallel)程序

parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量:

Liststrings=Arrays.asList("abc","","bc","efg","abcd","","jkl");

//获取空字符串的数量

int count=strings.parallelStream().filter(string->string.isEmpty()).count();

我们可以很容易的在顺序运行和并行直接切换。

Collectors

Collectors 类实现了很多归约操作,例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串:

List strings=Arrays.asList("abc","","bc","efg","abcd","","jkl");

List filtered=strings.stream().filter(string-> !string.isEmpty()).collect(Collectors.toList());

System.out.println("筛选列表:"+filtered);

String mergedString=strings.stream().filter(string-> !string.isEmpty()).collect(Collectors.joining(","));

System.out.println("合并字符串:"+mergedString);

统计

另外,一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上,它们可以用来产生类似如下的统计结果。

List numbers=Arrays.asList(3,2,2,3,7,3,5);

IntSummaryStatistics stats=integers.stream().mapToInt((x)->x).summaryStatistics();

System.out.println("列表中最大的数 :"+stats.getMax());

System.out.println("列表中最小的数 :"+stats.getMin());

System.out.println("所有数之和 :"+stats.getSum());

System.out.println("平均数 :"+stats.getAverage());

还需要记住一些steams(点此更多细节

3、Date/Time API(JSR 310)

Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。

在旧版的 Java 中,日期时间 API 存在诸多问题,其中有:

非线程安全− java.util.Date 是非线程安全的,所有的日期类都是可变的,这是Java日期类最大的问题之一。

设计很差− Java的日期/时间类的定义并不一致,在java.util和java.sql的包中都有日期类。

时区处理麻烦− 日期类并不提供国际化,没有时区支持。

Java 8 在新的java.time包,包含了所有关于日期、时间、时区、Instant(跟日期类似但是精确到纳秒)、duration(持续时间)和时钟操作的类。

Clock类使用时区来返回当前的纳秒时间和日期。Clock可以替代System.currentTimeMillis()TimeZone.getDefault()

// Get the system clock as UTC offsetfina

l Clock clock = Clock.systemUTC();

System.out.println( clock.instant() );//获取时钟的当前时刻,在得到的时间+8就是北京时间。

System.out.println( clock.millis() );//获取时钟的当前毫秒瞬间

LocalDateLocalTime类。LocalDate仅仅包含ISO-8601日历系统中的日期部分;LocalTime则仅仅包含该日历系统中的时间部分。这两个类的对象都可以使用Clock对象构建得到。

LocalDateTime类包含了LocalDate和LocalTime的信息,但是不包含ISO-8601日历系统中的时区信息。

// 获取当前的日期时间

LocalDateTime currentTime = LocalDateTime.now();

如果需要特定时区的data/time信息,则可以使用ZoneDateTime,它保存有ISO-8601日期系统的日期和时间,而且有时区信息。

// 获取当前时间日期

ZonedDateTime date1 = ZonedDateTime.parse("2017-5-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);

Duration类,它持有的时间精确到秒和纳秒。这使得我们可以很容易得计算两个日期之间的不同,例子代码如下:

LocalDateTime from=LocalDateTime.of(2016,month.JANUARY,15,0,0,0);

LocalDateTime to=LocalDateTime.of(2017,month.MAY,9,11,30,0);

final Duration duration = Duration.between( from, to );

System.out.println( "Duration in days: " + duration.toDays() );

System.out.println( "Duration in hours: " + duration.toHours() );

了解更多细节,可以参考官方文档

4、Nashorn JavaScript引擎

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

ScriptEngineManager manager =newScriptEngineManager();

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

5、Base64

在Java 8中,Base64编码已经成为Java类库的标准。

Java 8 内置了 Base64 编码的编码器和解码器。

Base64工具类提供了一套静态方法获取下面三种BASE64编解码器:

基本:输出被映射到一组字符A-Za-z0-9+/,编码不添加任何行标,输出的解码仅支持A-Za-z0-9+/。

URL:输出映射到一组字符A-Za-z0-9+_,输出是URL和文件。

MIME:输出隐射到MIME友好格式。输出每行不超过76字符,并且使用'\r'并跟随'\n'作为分割。编码输出最后没有行分  割。

实例如下:

public class Base64Test {

public static void main(String[] args) {

final String text = "Base64  in Java 8!";

final String encoded = Base64.getEncoder().encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );

System.out.println( “===en =====”+encoded );

final String decoded = new String(Base64.getDecoder().decode( encoded ),StandardCharsets.UTF_8 );

System.out.println( “===de =====”+decoded );

  }

}

三、新的工具:

1、Nashorn引擎:jjs

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

function f(){

print("Hello World!");

}

可以在命令行中执行这个命令:jjs hello.js,控制台输出结果是:

Hello World!

如果需要了解细节,可以参考官方文档

2、类依赖分析器:jdeps

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

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

jdepsorg.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

更多的细节可以参考官方文档

四、JVM的新特性

使用MetaspaceJEP 122)代替持久代(PermGenspace)。在JVM参数方面,使用-XX:MetaSpaceSize-XX:MaxMetaspaceSize代替原来的-XX:PermSize-XX:MaxPermSize

总结:

Java 8使得Java平台前进了一大步。其新的特性何其多,需要在使用中领会其功能。本篇通过案例和解释,对Java 8重要的特性进行了总结和概括,整理的过程,也是一次学习和巩固的过程。作为开发人员,学习永无止境!

参考资料

What’s New in JDK 8

Java 8 Tutorial

Oracle Nashorn. A Next-Generation JavaScript Engine for the JVM

推荐阅读更多精彩内容