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 类的引入很好的解决空指针异常。
实例如下：
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() );//获取时钟的当前毫秒瞬间
LocalDate和LocalTime类。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的新特性
使用Metaspace（JEP 122）代替持久代（PermGenspace）。在JVM参数方面，使用-XX:MetaSpaceSize和-XX:MaxMetaspaceSize代替原来的-XX:PermSize和-XX:MaxPermSize。
总结：
Java 8使得Java平台前进了一大步。其新的特性何其多，需要在使用中领会其功能。本篇通过案例和解释，对Java 8重要的特性进行了总结和概括，整理的过程，也是一次学习和巩固的过程。作为开发人员，学习永无止境！
参考资料
Oracle Nashorn. A Next-Generation JavaScript Engine for the JVM
