1.8特性

摘要
Lambda表达式、StreamAPI、方法引用、接口默认方法静态方法、增加可重复注解
CurrentHashMap用CAS算法取代segment，HashMap拉链法链表大于8改为红黑树
元空间取代持久代
http://www.importnew.com/11908.html#methodReferences

stream转list http://javarevisited.blogspot.jp/2015/03/5-ways-to-convert-java-8-stream-to-list.html

1.函数面向对象
public static void main(String[] args) {
//使用匿名内部类，编译后会有A$1.class的存在
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
System.out.print(123);
}
} );
//use lambda expression,no extra class generates.
Thread t2=new Thread(()->{System.out.print(123);});
}
2.自动推测类型
Arrays.asList( “a”, “b”, “d” ).forEach( e -> System.out.println( e ) );
等价于
Arrays.asList( “a”, “b”, “d” ).forEach( ( String e ) -> System.out.println( e ) );
3.使用的成员及局部变量 被隐式转换为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 ) );
4.推测返回值 如果只有一个语句 没必要显示声明return
Arrays.asList( “a”, “b”, “d” ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );
等价于
Arrays.asList( “a”, “b”, “d” ).sort( ( e1, e2 ) -> {
int result = e1.compareTo( e2 );
return result;
} );

@FunctionalInterface注解
语言设计者投入了大量精力来思考如何使现有的函数友好地支持lambda。最终采取的方法是：增加函数式接口的概念。函数式接口就是一个具有一个方法的普通接口。像这样的接口，可以被隐式转换为lambda表达式。java.lang.Runnable与java.util.concurrent.Callable是函数式接口最典型的两个例子。在实际使用过程中，函数式接口是容易出错的：如有某个人在接口定义中增加了另一个方法，这时，这个接口就不再是函数式的了，并且编译过程也会失败。为了克服函数式接口的这种脆弱性并且能够明确声明接口作为函数式接口的意图，Java 8增加了一种特殊的注解@FunctionalInterface（Java 8中所有类库的已有接口都添加了@FunctionalInterface注解）。让我们看一下这种函数式接口的定义：
@FunctionalInterface
public interface Functional {
void method();
}

接口默认方法
默认方法可以包含实现代码，默认方法与抽象方法不同之处在于抽象方法必须要求子类实现，但是默认方法则没有这个要求。
每个接口默认方法必须提供默认的代码实现。
private interface Defaulable {
// Interfaces now allow default methods, the implementer may or
// may not implement (override) them.
default String notRequired() {
return “Default implementation”;
}
}
private static class DefaultableImpl implements Defaulable {
}
private static class OverridableImpl implements Defaulable {
@Override
public String notRequired() {
return “Overridden implementation”;
}
}
默认方法不能被Defaulable.notRequired方式直接调用，要通过实现类的对象调用，
提供了方法多继承功能，如果实现的多个接口有同名方法，实现类需指定用哪个接口的默认方法
public interface A {
default void foo(){
System.out.println(“Calling A.foo()”);
}
}
public interface B {
default void foo(){
System.out.println(“Calling B.foo()”);
}
}
public class Clazz implements A, B {
public void foo(){
A.super.foo();
}
}

接口静态方法
public interface DefaulableFactory {
static Defaulable create(Supplier supplier) {
return supplier.get();
}
}

更容易实现工厂模式

重复注解
@Repeatable
自从Java 5引入了注解机制，这一特性就变得非常流行并且广为使用。然而，使用注解的一个限制是相同的注解在同一位置只能声明一次，不能声明多次。Java 8打破了这条规则，引入了重复注解机制，这样相同的注解可以在同一地方声明多次。

重复注解机制本身必须用@Repeatable注解。事实上，这并不是语言层面上的改变，更多的是编译器的技巧，底层的原理保持不变。让我们看一个快速入门的例子：

package com.javacodegeeks.java8.repeatable.annotations;

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() );
    }
}

}

扩展注解的支持
Java 8扩展了注解的上下文。现在几乎可以为任何东西添加注解：局部变量、泛型类、父类与接口的实现，就连方法的异常也能添加注解。下面演示几个例子：

package com.javacodegeeks.java8.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.Collection;

public class Annotations {
@Retention( RetentionPolicy.RUNTIME )
@Target( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
public @interface NonEmpty {
}

public static class Holder< @NonEmpty T > extends @NonEmpty Object {
    public void method() throws @NonEmpty Exception {           
    }
}

@SuppressWarnings( "unused" )
public static void main(String[] args) {
    final Holder< String > holder = new @NonEmpty Holder< String >();       
    @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();       
}

}

双冒号
方法引用
表达式:
person -> person.getAge();
可以替换成
Person::getAge
表达式
() -> new HashMap<>();

Spliterator
首先先直接给一个答案：Spliterator（splitable iterator可分割迭代器）接口是Java为了并行遍历数据源中的元素而设计的迭代器，这个可以类比最早Java提供的顺序遍历迭代器Iterator，但一个是顺序遍历，一个是并行遍历
从最早Java提供顺序遍历迭代器Iterator时，那个时候还是单核时代，但现在多核时代下，顺序遍历已经不能满足需求了…如何把多个任务分配到不同核上并行执行，才是能最大发挥多核的能力，所以Spliterator应运而生啦
https://segmentfault.com/q/1010000007087438