传统的Java接口是一组方法的集合，任何实现者都必须实现所有方法。这意味着库的设计者很难更新接口——这会导致很多实现类无法使用。

Java 8对接口的语法做了很大的改造：

1. 支持提供了实现的静态方法，这让为接口提供一个工具类的做法不再必要，工具方法可以直接放在接口中，例如Java8的Stream包含很多静态方法：
   

   public interface Stream<T> extends BaseStream<T, Stream<T>> {
       public static<T> Builder<T> builder() {
           return new Streams.StreamBuilderImpl<>();
       }
       public static<T> Stream<T> empty() {
           return StreamSupport.stream(Spliterators.<T>emptySpliterator(), false);
       }
   }

2. 支持提供了实现的接口方法：如果实现接口的类不明确提供实现，那么会继承来自接口的实现。这个特性让扩展接口变得很方便，例如Java8为List接口扩展了sort方法：
   

   default void sort(Comparator<? super E> c){
       Collections.sort(this, c);
   }

    为Collection接口扩展了stream方法：

   default Stream<E> stream() {
       return StreamSupport.stream(spliterator(), false);
   }

在先前，使用抽象类来提供缺省接口实现的模式，现在很大程度上可以由接口来代替。但是带有缺省实现的接口和抽象类还是有很大的不同：

1. 类可以实现多个接口，包括带有默认方法的接口；但是类只能继承一个抽象类
2. 抽象类可以具有状态，即实例变量，接口则不能有实例变量

可以用来设计“可选方法（Optional methods）” ，可以有意的让接口继承者不需要实现某些方法，例如在迭代器中，remove就是可选方法：

interface Iterator<T> {
    boolean hasNext();
    T next();
    default void remove() {
        throw new UnsupportedOperationException();
    }
}

默认方法也可以用来实现多重行为继承（Multiple inheritance of behavior）。由于Java允许实现多个接口，因此自然就可以从多个接口的默认方法中继承行为。

Java 8 中一个类可以从父类、接口继承得到签名相同的方法，那么到底哪个生效呢？以下是几个规则：

1. 类优先原则：声明在当前类或者父类中的方法，总是比接口默认方法优先
2. 子接口优先原则：如果两个接口A、B，B继承A，那么B中的默认方法比A的优先级高
3. 如果冲突仍然存在，那么当前类必须覆盖冲突的方法，在其中明确调用某个接口的默认方法 ：
   

   interface IHello{
       default void say(){
       }
   }
   
   interface IWorld{
       default void say(){
       }
   }
   
   class HelloWorld implements IHello, IWorld{
       @Override
       public void say(){
           IWorld.super.say(); //明确调用第二个接口的方法
       }
   }

需要注意的是，Java 8中不会存在钻石继承的问题，根本原因在于接口继承不存在对象拷贝的问题。这个可以对比C++钻石问题去理解，在C++中D继承B、C，后两者由继承自A，就意味着D拷贝了一份B、C的字段和函数，以及两份来自A的字段和函数，这就意味着冲突，到底使用来自B的A还是来自C的A？C++使用特殊的语法来去歧义。

在策略模式中，Strategy（策略，即行为）与Context是组合关系，前者作为后者的属性。所谓参数化，就是把这种组合关系改变为参数传递关系，即通过方法参数来传递策略类。

行为参数化的好处不言而喻，它可以让Context之间进一步解耦，关联关系被取消。不会因为共享变量Strategy导致线程安全性问题，每次调用都可以灵活切换Strategy。

行为参数化这种设计思想当然从Java诞生开始就能够支持，但是在Java8中，这种思想被更多的添加到JDK的API中：

public interface Iterable<T> {
    default void forEach(Consumer<? super T> action);
}
public interface List<E> extends Collection<E> {
    default void sort(Comparator<? super E> c) {
}

Lambda表达式让行为参数化变得简洁：

List<String> strList = new ArrayList<String>();
//使用Lambda表达式：
strList.sort( ( String s1, String s2 ) -> s1.length() - s2.length() );
//使用匿名类
strList.sort( new Comparator<String>() {
    public int compare( String s1, String s2 )
    {
        return s1.length() - s2.length();
    }
} );

Lambda表达式可以理解为可以被作为出入参传递的匿名函数的简便表示形式，很多语言例如C++、Python都支持Lambda表达式，Java 8首次将其引入的Java语言中，Lambda表达式的语法如下：

(Lambda parameters) -> expression

(Lambda parameters) -> {
    statements;
}

Lambda表达式可以用于任何函数式接口的上下文中，包括作为方法参数或者返回值。

所谓函数式接口，是指只有一个抽象方法的接口。Java 8中接口可以有默认实现，有多个方法，但是只有一个没有默认实现的接口，也被认为是函数式接口。

使用注解@FunctionalInterface可以限制一个接口为函数式接口，如果不符合函数式接口的规范，将无法通过编译：

@FunctionalInterface
public interface Functional {
    void operation();
    default void defaultOperation(){}
}

函数式接口的抽象方法的签名潜在的定义了Lambda表达式的结构， 我们称这样的抽象方法为函数描述符（Function Descriptor）。

Java 8 中提供了若干常用的函数式接口：

Lambda的类型（即函数式接口的类型）是根据使用Lambda的上下文来由编译器推断的，上下文期望的Lambda类型被称为目标类型（Target type）。

同一Lambda可能和多个抽象方法签名兼容的函数式接口关联，以一条语句作为其Lambda体的表达式，与返回void 的函数描述符兼容（如果参数类型兼容），例如：

//断言接口要求boolean返回值
Predicate<String> p = s -> list.add(s);
//消费接口要求void返回值，兼容
Consumer<String> b = s -> list.add(s);

编译器可以根据上下文进行类型推断，因此Lambda表达式的编写可以被简化：

//省略Lambda参数的类型声明
Comparator<String> c = ( s1, s2 ) -> s1.length() - s2.length();

类似于匿名类，Lambda可以使用在外部作用范围定义的局部变量，但是这些局部变量必须是final，或者相当于final（没有二次赋值语句）： 

//下面的代码无法通过编译，因为hello被二次赋值
String hello = "Hello";
Runnable r = () -> System.out.println( hello );
hello = "World";

设置“final”限制的缘由是，局部变量是在线程的栈上分配的，那么作为返回值传递的Lambda可能被另外一个线程调用，这个调用可能发生在分配局部变量线程死亡之后，如果允许Lambda任意访问局部变量就会导致非法访问。Java的做法是允许Lambda访问局部变量的拷贝，而不是局部变量本身，final保证了拷贝与局部变量的一致性。 这一限制实质上也使Java不支持真正的闭包。

Java 8引入了方法引用，这允许重用已经定义的方法并传递它们，就像Lambda一样：

Comparator<String> c = java.util.Comparator.comparing( String::length );
//comparing需要的参数是函数式接口：Function<? super T, ? extends U>
//传递的是String::length
//编译器推导过程：(T) -> return R
//第一个参数是实例方法的实例：(String s) -> return R
//调用实例方法：(String s) -> s.length()
//假设实例方法有入参，依次声明：(String s, Object arg0, Object arg1) -> s.length(arg0, arg1)

方法引用本质上是只调用了一个方法的Lambda的缩写。上面的例子等价于：

Comparator<String> c = java.util.Comparator.comparing( ( String s ) -> s.length() );

方法引用的写法有三大类：

1. 对于静态方法的引用，例如

   Integer::parseInt

     
2. 对于某个类型的实例方法的引用，例如

   String.length

    。具体调用针对的对象实例由Lambda的第一个参数来提供，该方法引用等价于

   (String s) -> s.length()

    
3. 对于某个对象的实例方法的引用，例如

   "".length

    。具体调用针对的对象实例由上下文中的变量提供，该方法引用等价于

   () -> "".length()

    

构造器引用类似于静态方法引用，形式为：

Class::new

Function<String, String> c = String::new; //函数引用
c = ( s ) -> new String( s ); //等价的Lambda表达式
c.apply( "Hello" ); //调用

Supplier<Object> o = Object::new;
o = () -> new Object();

Java 8 中引入了很多简化Lambda编写的API：

public interface java.util.Comparator<T> {
    //返回这样的比较器：通过调用被比较对象的方法来抽取Comparable Key，进而根据Key来比较
    public static <T, U> Comparator<T> comparing();
    //反转当前比较器的顺序
    default Comparator<T> reversed();
    //链式的比较器：多重比较
    default Comparator<T> thenComparing(Comparator<? super T> other);
}

public interface Predicate<T> {
    //逻辑否、非、或
    default Predicate<T> and(Predicate<? super T> other);
    default Predicate<T> or(Predicate<? super T> other);
    default Predicate<T> negate();
}

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = f.andThen( g ); //高阶函数：g(f(x))
Function<Integer, Integer> i = f.compose( g ); //高阶函数：f(g(x))
h.apply( 1 );

在Java8中，注解可以写在任何使用类型的地方：

// 声明，允许该注解被用在使用类型的地方、泛型类型参数上
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
public @interface Test {
}

 在类型、泛型类型参数上使用注解的例子：

// 任何类型的前面都可以附加注解（前提是该注解的ElementType允许）
@Encrypted String data;
List<@NonNull String> strings;
graph = (@Immutable Graph) tmpGraph;
Collection<? super @Existing File> c;

类型注解可以用来在编译期进行代码检查，提高代码质量，对运行时没有影响。

Java 8引入了java.util.stream.Stream，它允许声明式的操控集合。Stream能够透明的使用多处理器并行处理。 下面是一个简明的例子：

List<Cat> cat = new ArrayList<>();
List<String> littleCats = cat  //链式调用
		.parallelStream()  //集合接口可以获取Stream，stream()返回串行处理的流
		.filter(c->c.getAge()<2)  //内部迭代
		.sorted(Comparator.comparing(Cat::getWeight))
		.map(Cat::getName)
		.collect(toList());  //直到collect调用之前，不会做任何实际操作

所谓Stream，是指来自一个源（Source）的元素的序列，这些元素支持数据处理操作：

1. 元素序列：Collection也是元素序列，但是Collection关心的是数据，Stream则关心操作
2. 源：可以是Collection、数组、I/O资源
3. 操作：Stream提供类似数据库的操作，例如filter、map、reduce、find、match、sort、limit。这些操作可以串行或者并行的被执行

Stream还支持链式调用，这允许你串起多个操作；Stream支持内部迭代，不需要手工编写迭代代码。

Stream支持两类操作：中间操作、终端操作。前者构建处理管道（Pipeline），后者导致管道被执行。中间操作包括：

终端操作包括：

import static java.util.stream.Collectors.*;

import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamExample
{

    private static List<Cat> prepareData()
    {
        List<Cat> cats = new ArrayList<>();
        cats.add( new Cat( "叮当猫", 19, 4000, "Yellow" ) );
        cats.add( new Cat( "多啦A梦", 38, 5800, "Blue" ) );
        cats.add( new Cat( "蓝猫", 9, 3500, "Blue" ) );
        cats.add( new Cat( "汤姆猫", 58, 2900, "Blue" ) );
        cats.add( new Cat( "凯蒂猫", 31, 1800, "White" ) );
        cats.add( new Cat( "加菲猫", 27, 9600, "Yellow" ) );
        cats.add( new Cat( "甜甜私房猫", 6, 1200, "Grey" ) );
        cats.add( new Cat( "加菲猫", 27, 9600, "Yellow" ) );
        cats.add( new Cat( "加菲猫", 27, 9600, "Yellow" ) );
        return cats;
    }

    public static void main( String[] args ) throws IOException
    {
        List<Cat> cats = prepareData();

        /** 过滤和切片操作  **/
        //使用断言（Predicate）过滤数据
        List<Cat> overweight = cats.stream().filter( cat -> cat.getWeight() > 3000 ).collect( toList() );
        System.out.println( overweight ); //[叮当猫, 多啦A梦, 蓝猫, 加菲猫]
        //筛除重复元素
        List<Cat> distinct = cats.stream().distinct().collect( toList() );
        System.out.println( distinct ); //[叮当猫, 多啦A梦, 蓝猫, 汤姆猫, 凯蒂猫, 加菲猫, 甜甜私房猫]
        //截断Stream
        List<Cat> limit = cats.stream().limit( 3 ).collect( toList() );
        System.out.println( limit ); //[叮当猫, 多啦A梦, 蓝猫]
        //跳过Stream中起始的6个元素
        List<Cat> skip = cats.stream().skip( 6 ).collect( toList() );
        System.out.println( skip ); //[甜甜私房猫, 加菲猫, 加菲猫]

        /** 映射（Mapping）操作 **/
        //映射为颜色
        List<String> colors = cats.stream().map( Cat::getColor ).collect( Collectors.toList() );
        System.out.println( colors ); //[Yellow, Blue, Blue, Blue, White, Yellow, Grey, Yellow, Yellow]
        //扁平化映射：把元素映射为新Stream，然后把这个新Stream中的所有元素纳入当前Stream，并关闭新Stream
        List<Character> nameChars = cats
                .stream().map( Cat::getNameAsChars ) //元素映射为Character[]
                .flatMap( Arrays::stream ) //Character[]被映射为Character，这是1:N的映射方式
                .distinct().collect( toList() );
        System.out.println( nameChars );//[叮, 当, 猫, 多, 啦, A, 梦, 蓝, 汤, 姆, 凯, 蒂, 加, 菲, 甜, 私, 房]
        /** 查找与匹配操作 **/
        //判断流中是否存在匹配断言的元素
        System.out.println( cats.stream().anyMatch( cat -> cat.getColor() == "White" ) ); //true
        //判断是否流中所有元素匹配断言
        System.out.println( cats.stream().allMatch( cat -> cat.getAge() < 100 ) ); //true
        //判断是否流中不存在任何元素匹配断言
        System.out.println( cats.stream().noneMatch( cat -> cat.getAge() > 100 ) ); //true
        //查找任何一个黄猫
        Optional<Cat> yellow = cats.stream().filter( cat -> cat.getColor() == "Yellow" ).findAny();
        System.out.println( yellow.get() ); //叮当猫
        //查找第一个元素
        System.out.println( cats.stream().findFirst().get() ); //叮当猫

        /** 化简（Reducing）操作 **/
        //将两个元素化简为一个元素
        //求和：年龄之和，先映射再化简
        System.out.println( cats.stream().map( Cat::getAge ).reduce( ( a1, a2 ) -> a1 + a2 ).get() ); //242
        //求最值：最老的猫
        System.out.println( cats.stream().reduce( ( c1, c2 ) -> ( c1.getAge() > c2.getAge() ) ? c1 : c2 ).get() );//汤姆猫
        /** 数字流 **/
        //避免基本类型装拆箱的开销
        IntStream primitiveStream = cats.stream().mapToInt( Cat::getAge );
        Stream<Integer> objectStream = primitiveStream.boxed(); //变回装箱类型的流
        OptionalInt max = primitiveStream.reduce( ( i, j ) -> i > j ? i : j );
        max.orElse( 0 );//如果没有最大值，设为0
        /** 构建流 **/
        IntStream.range( 0, 200 );//数字范围的流
        Stream<String> strStream = Stream.of( "Hello", "World" ); //字符串流
        IntStream intStream = Arrays.stream( new int[] { 1, 2, 3 } );//从数组生成流
        //NIO包支持Stream API
        Stream<String> fileLineStream = Files.lines( Paths.get( "~/ReadMe.txt" ), Charset.defaultCharset() );//行流
        Stream<Integer> infinite = Stream.iterate( 0, n -> n + 2 ); //由函数提供的迭代流
        infinite.limit( 100 ).forEach( i -> System.out.println( i ) );
        Stream.generate( Math::random ); //随机生成流
    }
}

化简操作比起逐步迭代的优势在于，它能够很方便的支持并行处理。 由于化简操作限定了依据两个输入导出一个输出，并且输入输出的类型一致，这让JDK能够自由的把巨大的流分配给多个线程进行化简操作。这种Map-Reduce思想在大数据处理框架中很普遍，例如Hadoop。

Collector接口传递给Stream.collect()方法，可以用来构建Stream中元素的摘要信息。Collector也可以用来执行化简操作，对Stream元素进行化简。

Collector接口中的静态工厂方法用于创建预定义的Collector，这些Collector和Stream接口提供的功能有重叠：

List<Cat> cats = StreamExample.prepareData();
//求平均猫龄
cats.stream().collect( averagingInt( Cat::getAge ) );
//收集所有猫为列表，再转为数组
cats.stream().collect( collectingAndThen( toList(), List::toArray ) );
//求猫的总数
cats.stream().collect( counting() );
//按毛色分组，如果需要多级分组，为groupingBy添加第二个参数，类型为Collector
Map<String, List<Cat>> byColor = cats.stream().collect( groupingBy( Cat::getColor ) );
//把名字用逗号连接起来
cats.stream().map( Cat::getName ).collect( joining( "," ) );
//依据猫龄映射，然后取最大值
cats.stream().collect( mapping( Cat::getAge, maxBy( ( a1, a2 ) -> a1 > a2 ? a1 : a2 ) ) );
//依据是否白猫，分区为两个列表
Map<Boolean, List<Cat>> partition = cats.stream().collect( partitioningBy( cat -> cat.getColor() == "White" ) );
//化简，取第一只猫
cats.stream().collect( reducing( ( c1, c2 ) -> c1 ) );
//求总吨位
cats.stream().collect( summingInt( Cat::getWeight ) );

Collector接口的主要方法如下：

/**
 * 收集器接口
 * @param <T> 需要进行化简操作的元素类型，即目标流的元素类型
 * @param <A> 易变的累计器类型（mutable accumulation type），化简的中间结果存放在其中
 * @param <R> 化简操作的结果类型
 */
public interface Collector<T, A, R>
{

    //该函数创建并返回中间结果容器
    Supplier<A> supplier();

    //该函数把一个元素折入结果容器
    BiConsumer<A, T> accumulator();

    //将中间结果进行最后的转换，得到最终结果
    Function<A, R> finisher();

    /**
     * 返回不变的，表示该收集器特征的集合
     * 特征包括：
     * 　　CONCURRENT 表示此收集器支持并发，即accumulator支持多线程并发访问
     * 　　UNORDERED 表示此收集器不会保持元素的顺序
     * 　　IDENTITY_FINISH 表示finisher是“等同的（identity）”函数，可以被省略，意味着可以直接从A造型为R
     */
    Set<Characteristics> characteristics();

    //支持接收两个中间结果，并合并之（折叠并返回其中一个，或者创建新的容器并返回）
    BinaryOperator<A> combiner();

}

一个简单的Collector的实现：

import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import static java.util.stream.Collector.Characteristics.*;

public class AsListCollector<T> implements Collector<T, List<T>, List<T>>
{

    @Override
    public Supplier<List<T>> supplier()
    {
        // 提供中间结果容器
        return ArrayList::new;
    }

    @Override
    public BiConsumer<List<T>, T> accumulator()
    {
        // 把元素折叠到结果容器中
        return List::add;
    }

    @Override
    public BinaryOperator<List<T>> combiner()
    {
        return ( l1, l2 ) -> {
            l1.addAll( l2 );
            return l1;
        };
    }

    @Override
    public Function<List<T>, List<T>> finisher()
    {
        //生成一个总是返回输入的函数
        return Function.identity();
    }

    @Override
    public Set<java.util.stream.Collector.Characteristics> characteristics()
    {
        return Collections.unmodifiableSet( EnumSet.of( IDENTITY_FINISH, CONCURRENT ) );
    }
}

可以把当前Stream转换为等价的并行处理版本：

stream().parallel()

stream().sequential()

stream.parallel()
    .filter(...)
    .sequential()
    .map(...)
    .parallel()  //Stream会并行处理
    .reduce();

并行Stream在内部使用默认的ForkJoinPool，该Pool具有与处理器数量相当的线程。默认ForkJoinPool的线程大小可以被修改：

System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "16");

这是Java 8 添加的新接口，表示可分割的迭代器（Splitable Iterator），它用于支持并行迭代：

public interface Spliterator<T>
{

    //如果仍有剩余元素，执行指定的函数并返回true；否则返回false
    boolean tryAdvance( Consumer<? super T> action );

    //如果当前迭代器可以分区，那么分区出一个新的迭代器，相关元素将不被当前迭代器覆盖
    Spliterator<T> trySplit();

    //返回一个估算的剩余元素大小
    long estimateSize();

    /**
     * 说明此迭代器的特征
     * ORDERED 元素具有定义好的顺序（例如来自List），因此迭代器在遍历、分割时保持顺序
     * DISTINCT 元素具有唯一性
     * SORTED 元素具有预定义的排序顺序
     * SIZED 迭代器的源具有准确的尺寸，因此estimateSize()返回精确值
     * NONNULL 元素不会为空
     * IMMUTABLE 迭代器的源不会变化，这隐含在遍历期间，元素不会被添加、删除或修改
     * CONCURRENT 迭代器的源可以被安全的并发修改，不需要额外的同步保护
     * SUBSIZED 任何分割出的子迭代器具有准确的尺寸
     */
    int characteristics();
}

 Java 8引入的Optional泛型类可以很好的避免一些NullPointerException或者null检查：

Company c = new Company();
c.getCeo().getAddress().getZip();//潜在可能的空指针异常
if ( c.getCeo() != null ) //冗长的空指针判断
{
    Person ceo = c.getCeo();
    if ( ceo.getAddress() != null )
    {
        Address addr = ceo.getAddress();
    }
}
Optional<Person> pnull = Optional.empty(); //持有一个空值
Optional<Person> ceo = Optional.of( new Person() );//持有一个对象，传入null立即抛出NullPointerException
Optional<Person> pnullable = Optional.ofNullable( new Person() );//持有一个对象，可以是null
//使用map函数可以安全的获取到Optional对象的属性，避免异常
Optional<Address> address = pnullable.map( Person::getAddress );

如果想让链式的getter调用安全的返回，需要改造POJO：

class Address
{
    private String zip;
    public String getZip(){
        return zip;
    }
    public void setZip( String zip ){
        this.zip = zip;
    }
}
class Person{
    private Optional<Address> address;
    public Optional<Address> getAddress(){
        return address;
    }
    public void setAddress( Optional<Address> address ){
        this.address = address;
    }

}
class Company{
    private Optional<Person> ceo;
    public Optional<Person> getCeo(){
        return ceo;
    }
    public void setCeo( Optional<Person> ceo ){
        this.ceo = ceo;
    }
}

然后使用map函数：

Optional<Company> c = Optional.empty();
String zip = 
    c.flatMap( Company::getCeo ) //flatMap防止optional容器的嵌套
     .flatMap( Person::getAddress )
     .map( Address::getZip )
     .orElse( "100044" );

/* 日期API */
LocalDate today = LocalDate.now(); //当前日期
LocalDate date = LocalDate.of( 2014, 6, 12 );//2014年6月12日
int year = date.getYear();//2014
Month month = date.getMonth();//JUNE
month.ordinal(); //5
int day = date.getDayOfMonth();//12
DayOfWeek dow = date.getDayOfWeek();//THURSDAY
dow.ordinal(); //3
int len = date.lengthOfMonth();//30
boolean leap = date.isLeapYear();//false
year = date.get( ChronoField.YEAR ); //2014
int mon = date.get( ChronoField.MONTH_OF_YEAR ); //6
int dowInt = date.get( ChronoField.DAY_OF_WEEK );//4
day = date.get( ChronoField.DAY_OF_MONTH );

/* 时间API */
LocalTime time = LocalTime.of( 23, 6, 30 );
int hour = time.getHour();//23
int minute = time.getMinute();//6
int second = time.getSecond();//30

/* 从文本解析日期和时间 */
date = LocalDate.parse( "2014-06-12" );
time = LocalTime.parse( "23:06:30" );

/* 合并使用日期时间 */
LocalDateTime dt1 = LocalDateTime.of( 2014, Month.JUNE, 12, 23, 6, 30 );
LocalDateTime dt2 = LocalDateTime.of( date, time );
LocalDateTime dt3 = date.atTime( 23, 6, 30 );
LocalDateTime dt4 = date.atTime( time );
LocalDateTime dt5 = time.atDate( date );

这是一种新的Future类，它可以手工明确的完成：

CompletableFuture<Integer> intFuture = new CompletableFuture<>();
new Thread( () -> {
    sleep( 3 );
    intFuture.complete( 10 ); //手工完成，该方法只能调用一次，obtrudeValue()方法可以用来修改值
} ).start();
intFuture.get();//阻塞，直到三秒后

CompletableFuture提供了若干静态工厂来创建实例：

//不提供Executor，则默认使用ForkJoinPool.commonPool()
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);
static CompletableFuture<Void> runAsync(Runnable runnable);
static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);

//示例：
Cat cat = new Cat( "叮当猫", 19, 4000, "Yellow" );
CompletableFuture<Integer> ageFuture = CompletableFuture.supplyAsync( cat::getAge );

 CompletableFuture还支持在异步操作完毕后，执行若干操作

Cat cat = new Cat( "叮当猫", 19, 4000, "Yellow" );
CompletableFuture
        .supplyAsync( cat::getAge ) //异步获取猫龄
        .thenApply( String::valueOf )//得到猫龄后，转换为字符串，同步操作
        .thenAccept( System.out::println ); //转换成字符串后，打印之，同步操作

异常处理也被支持：

CompletableFuture
        .supplyAsync( cat::getAge ) //异步获取猫龄
        .exceptionally( ex -> 0 ); //如果获取猫龄出错，返回0

多个异步操作甚至可以被串联起来，thenCompose()方法可以用来构建异步处理管道，完全没有阻塞和等待：

CompletableFuture
        //异步获取猫龄
        .supplyAsync( cat::getAge )
        //异步的把猫龄转换为字符串
        .thenCompose( age -> CompletableFuture.supplyAsync( age::toString ) )
        //再异步的打印猫龄的字符串
        .thenCompose( age -> CompletableFuture.runAsync( () -> System.out.println( age ) ) );

可以让两个Future分别运行，在结果都可用时，执行一个回调：

CompletableFuture
        //异步获取猫龄
        .supplyAsync( cat::getAge )
        .thenCombine( //异步获取猫重
                CompletableFuture.supplyAsync( cat::getWeight ),
                //两个操作都完成后，计算重龄比
                ( age, weight ) -> weight / age );

The post Java8新特性 appeared first on 绿色记忆.

switch ( args[0] ){
    case "Hello":
        break;
    case "World":
        break;
    default:
        break;
}

// try可以附加资源管理的代码，这些资源如果实现AutoCloseable接口，那么会被自动关闭
try (OutputStream out = System.out;InputStream in = System.in){}
catch ( IOException e ){}
finally{}

try{}
catch ( NullPointerException | IllegalArgumentException e ){}

int i255 = 0b11111111;

long lightYear = 9454_254_955_488L;

//钻石操作符，参数化类型会根据上下文推断
List  = new ArrayList<>();
private static List genList(){
    return new ArrayList<>();
}

Fork/Join模式是处理并行编程的经典模式，Java 7将其集成到JDK中，Java7 的Fork/Join框架可以很好的利用多核CPU来完成复杂的计算任务。Fork/Join的思想是，把计算任务分为两个阶段：

1. 分解阶段：把任务分解为多个不相关的小块，分别有多个线程进行计算
2. 合并阶段：计算完成的小块被合并到最终结果中

Map/Reduce本质上是Fork/Join模式的一种变体，但是它主要用于分布式计算领域。

需要注意的是，Java7的Fork/Join框架支持递归的分解和合并，子任务可以继续分解为更细致的任务并在完成后合并，下图形象的说明了递归分解/合并过程：

下面是一个利用Fork/Join求和的例子，该例子中任务会不断分解子任务，直到需要相加的只剩两个数：

public class SumTask extends RecursiveTask<Long>
{
    private static final long serialVersionUID = 1L;

    private SumProblem        problem;

    public SumTask( SumProblem problem )
    {
        this.problem = problem;
    }

    @Override
    protected Long compute()
    {
        if ( problem.numCount() <= 2 )
        {
            //只剩下两个数的话，相加并返回
            return problem.solve();
        }
        else
        {
            //任务分割，把绝大部分计算内容切分出去
            SumProblem subProblem = problem.chop();
            //当然，类似于均分的方式来切分任务也是可以的
            SumTask subTask = new SumTask( subProblem );
            subTask.fork();//让子任务分支出去，即另外调度执行
            Long result = problem.solve(); //当前任务执行主任务
            return result + subTask.join(); //当前任务负责合并结果
            //注意，这里的join不要理解为线程的join，实际上，执行join时，当前任务会被执行线程放弃
        }
    }

}
public class ForkJoinTest
{
    public static void main( String[] args )
    {
        int processerCount = Runtime.getRuntime().availableProcessors();
        //ForkJoinPool负责发现并执行任务生成的子任务
        ForkJoinPool pool = new ForkJoinPool( processerCount );
        ForkJoinTask<Long> task = new SumTask( new SumProblem( 1L, 1000L ) );
        System.out.println( pool.invoke( task ) );
    }
}

Java New I/O是JDK1.4引入的新API，支持异步方式处理输入输出，大大改善了I/O性能。Java 7对NIO进行了很多的增强，此称为NIO.2。

使用Java进行网络编程一文包含了部分NIO2特性在网络编程方面的应用。

NIO.2引入了全新的软件包java.nio.file，下面是一些使用该包的样例代码：

//Path用来定位文件系统中的文件
Path path = FileSystems.getDefault().getPath( "F:/Temp/ReadMe.txt" );
//Files是一个工具类
Files.exists( path );//判断对应Path的文件是否存在
Files.newBufferedReader( path, Charset.forName( "UTF-8" ) ); //打开字符流

/*
 * WatchService可以用来监听特定类型的文件系统事件：
 * ENTRY_CREATE 目录中创建或者重命名（进入）了一个条目
 * ENTRY_DELETE 目录中删除或者重命名（出去）了一个条目
 * ENTRY_MODIFY 目录中的一个条目被修改
 */
path = FileSystems.getDefault().getPath( "F:/Temp/" );
WatchService watcher = FileSystems.getDefault().newWatchService();
WatchKey watchKey = path.register( watcher, StandardWatchEventKinds.ENTRY_DELETE );
for ( ;; )
{
    WatchKey key = watcher.take(); //阻塞，直到有事件发生
    if ( key.equals( watchKey ) )
        for ( WatchEvent<?> e : key.pollEvents() )
        {
            System.out.println( "File deleted: " + e.context() );
        }
    key.reset(); //重置Key以继续接收事件
}

The post Java7新特性 appeared first on 绿色记忆.

泛型，也称为参数化类型，是很多语言支持的编程范式——在定义类型、接口或者方法时将类型作为参数。Java诞生以来最重大的语法改变当属泛型，它是Java5最重要的特性。Java泛型与C++的模板机制在形式上有些类似，但是Java泛型的实现方式——类型擦除导致二者有着根本性的不同。

使用泛型，可以获得以下好处：

1. 在编译期获得更好的类型检查
2. 消除不必要的强制转型代码
3. 允许编程人员实现泛型算法

使用泛型机制设计的类，最常见的是容器类，Java5的集合框架大量使用了泛型机制（类似于C++的STL库）：

public interface Collection<E>{};
public interface Set<E>{};
public interface List<E>{};
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{};
public interface Map<K,V> {}

但是，任何字段、方法参数、方法返回值需要参数化的类型，都可以从泛型机制获益，例如下面这个通用的回调接口： 

interface Callback<P,R>{
    R invoke(P p);
}

所谓泛型类型（ generic type），是指通过类型参数化的类/接口，这种类型的声明语法为：

class ClassName<T1,...Tn>{
    // T1...Tn是将ClassName参数化的类型形参（type parameter），或者叫类型变量（type variables），可以有1-N个
}
// 示例：
class Container<I> {
    private I item;
    void put(I i) {
        item = i;
    }
    I get() {
        return item;
    }
}

类型形参可以在类定义的任何地方引用。类型参数只是一个占位符，它可以表示任意一种非基本（non-primitive ）类型。根据惯例，类型形参使用单个大写字母表示，一般E表示“元素”、K表示“键”、N表示“数字”、T表示“类型”、V表示“值”，等等。

要在代码中使用一个泛型类型，必须进行泛型类型调用（generic type invocation），此时必须把类型形参（type parameter）替换为类型实参（ type argument），后者是真实的Java类型：

Container<Number> cn = new Container<Number>();
// Java 7引入了钻石操作符，可以根据cn的变量类型推倒构造器的type argument：
Container<Number> cn = new Container<>();

作为类型实参的Java类型，其本身也可以是泛型类型：

// 不管嵌套多少层，泛型类型的类型参数都不能是占位符
Container<List<String>> cn = new Container<>();
// 下面的语句非法，E不是可解析的真实类型
Container<List<E>> cn = new Container<>();

所谓原始类型，是指在不指定类型实参的情况下使用泛型，例如：

ArrayList list = new ArrayList()

混合使用泛型、原始类型，会在编译时得到未检查错误信息（Unchecked Error Messages），所谓Unchecked表示编译器无法得到足够的信息来完成类型推断以确保安全性。要禁止此类错误信息，可以使用编译选项

-Xlint:-unchecked

@SuppressWarnings("unchecked")

不但类可以设计为泛型，方法也可以。方法可以使用类声明的泛型形参，亦可自己声明泛型参数，声明自己的泛型参数的方法称为泛型方法（Generic method），例如：

public class Math {
    // 泛型方法，泛型形参列表必须在返回值之前声明：
    public static <RET, ARG0, ARG1> RET plus( ARG0 arg0, ARG1 arg1 ) {
        return (RET) null;
    }
}

调用泛型方法的完整语法如下：

Integer result = Math.<Integer, Double, Double>plus( 1.1, 1.2 );

指定泛型实参列表 不是必须的，通常编译器能够根据上下文推断。编译器的这种能力称为type inference。

Java泛型支持限制可作为泛型实参的类型的范围。例如上面的plus方法，可能仅仅支持数字类型。要声明受限泛型形参，需要使用extends关键字：

public static <RET, ARG0 extends Number, ARG1 extends Number> RET plus( ARG0 arg0, ARG1 arg1 ) {
    return (RET) null;
}

使用受限形参，方法体可以对形参的类型进行假设，这样就可以执行有意义的方法调用了：

public static <T extends Comparable<T>> int countGreaterThan( T[] anArray, T elem ) {
    int count = 0;
    for ( T e : anArray )
        // 调用比较方法，因为T必须是Comparable的子类型
        if ( e.compareTo( elem ) > 0 )
            ++count;
    return count;
} 

可以在限制泛型实参必须是某个类型或者其子类型的同时，限制它必须实现某些接口：

// 多个接口用 & 符号分隔
public static <T extends Entity & Serializable> void save(T t){}

可以在字段、方法形参、变量的声明中使用（不受限的）泛型通配符，使用

?

1. 泛型类中返回参数类型的方法，类型自动变为Object
2. 泛型类中需要参数类型作为入参的方法，将不能接受任何对象

例如泛型类：

public class Value<T> {
    private T t;
    public Value( T t ){
        this.t = t;
    }
    public void set( T t ){
        this.t = t;
    }
    public T get(){
        return t;
    }
}

如果声明参数类型为通配符：

Value<?> value = new Value<Integer>( 1 );
Object o = value.get(); //可以通过编译，你不知道是什么类型，所以我们给你一个根类型
value.set( 1 ); //无法通过编译，不是我们不限制类型，而是你不知道是什么类型

就意味着，你可以从泛型对获取参数类型对象，但是却不能提供了。 

Java 5还支持受限泛型通配符的声明，所谓受限是指，变量/返回值/参数的泛型参数必须满足限制：

1. Type<? extends PType>

    ：上限通配符（Upper Bounded Wildcard），表示变量的类型参数必须是PType或者PType的子类型

2. Type<? super PType>

    ：下限通配符（Lower Bounded Wildcard），表示变量的类型参数必须是PType或者PType的超类型

在设计一个接收泛型入参的接口时，如果你需要向入参提供一个对象，可以使用下限通配符，因为这可以确保你提供的对象可以被接受：

public static void addNumbers( List<? super Integer> list ) {
    // list的实参可以是Integer，或者Number，或者Object，但是必然能容纳int类型
    for ( int i = 1; i <= 10; i++ ) {
        list.add( i );
    }
}

在设计一个接收泛型入参的接口时，如果你需要使用入参提供的对象，可以使用上限通配符，这样你可以假设对象的类型：

public static void process( List<? extends Number> list ) {
    // list的实参可以是Integer，或者Number，或者Double，但是都可以针对其调用Number的接口
    for ( Number n : list ) {
        n.intValue();
    }
}

上面的两条，就是所谓的PECS原则：当泛型对象作为生产者（对外提供对象）时，将其泛型形参声明为上限通配符（extends）；当泛型对象作为消费者时，将其泛型形参声明为下限通配符（super） ，下面的例子有助于进一步理解PECS：

Value<? extends Number> valueExtend = new Value<Integer>( 1 );
//有了这个变量声明，我知道类型参数必然是Number的子类型：
Number num = valueExtend.get();
//但是，具体是Integer，还是Double，我不知道，因此我无法提供参数类型的实例
valueExtend.set( 1 ); //无法编译

Value<? super Number> valueSuper = new Value<Number>( 1 );
//有了这个变量声明，我知道类型参数必然是Number的超类型：
valueSuper.set( new Integer( 1 ) ); //那么，我当然可以提供Number的子类型给你
//但是，我却不知道类型参数的真实类型
Object obj = valueSuper.get(); //所以此变量提供的参数类型未知

class BoundedBuffer<T>
{
    private T[]             items;
}

但是，就像不能实例化参数类型一样，你也不能实例化参数类型的数组：

T t = new T();        //无法通过编译，无法提供数组需要的运行时信息
T[] ts  = new T[10];  //无法通过编译，编译器甚至无法确认T类型有默认构造器

不能实例化的原因是，Java中的数组在运行时必须知道其元素的类型。上述语法无法提供这一类型信息——因为T是什么在编译时根本不知道。因此泛型数组如果需要在泛型内部初始化，必须进行变通：

T[] ts = (T[]) new Object[10];

注意绝大部分的参数化类型信息都在编译期间擦除了，除了继承自泛型类的子类型，可以通过反射得到父类上的真实参数类型：

//它的泛型父类的类型信息String不会被擦除
class StringList extends ArrayList<String> //和C++的模板特化有些类似
{
    private static final long serialVersionUID = 1L;
}

//可以使用下面的代码获得泛型父类的真实参数类型
ParameterizedType type = (ParameterizedType) new StringList().getClass().getGenericSuperclass();
assert ( type.getActualTypeArguments()[0] == String.class );

需要注意泛型是“非协变”的，参数类型不同的泛型变量不能相互转换，即使这些参数类型之间存在继承关系：

//数组是协变的
Object oa[] = new Integer[] {};
//泛型不是，尽管泛型实参Object和Number具有父子类关系。但是List<Object>、List<Number>之类不存在父子类关系
List<Object> ol = new ArrayList<Number>(); //无法编译

使用上限通配符，可以解决非协变特性导致的无法赋值问题：

List<? extends Object> ol = new ArrayList<Number>();  

继承泛型类型时，可以将全部或者部分泛型参数“特化”：

// 完全特化
abstract class StringList implements List<String> {}
// 部分特化
abstract class StringKeyMap<V> implements Map<String,V> {}

注意：上面的例子中，任何StringList是List的子类型，StringKeyMap是Map的子类型。在特化类型参数的同时，你可以获得重写父类逻辑的机会。

注解在Java5中第一次成为可以影响编程方式的语言元素，注解可以为类、字段、方法、甚至注解本身提供元数据信息。注解的出现将很大程度上改变可配置化对XML高度依赖的现状。

声明注解需要使用特殊的类型说明符：

@interface

//某些注解可以用来修饰注解类型本身
@Retention ( RetentionPolicy.RUNTIME )
//提示该注解需要在运行期保留
@Target ( ElementType.METHOD )
//提示该注解只能作用于方法上
@interface AutoExtAjaxResult
{
    //注解中可以声明多个“方法”，用来指示注解实例的属性名
    String value(); //value是一个特殊属性，如果注解只有这一个属性，在实例化注解时，可以不指定属性名
    Class<?> type() default App.class; //注解属性可以提供默认值
}

需要注意的是，注解属性只支持有限的类型：基本类型、字符串、注解、枚举、Class，或者这些类型的一维数组。

要使用（实例化）注解，只需要在目标类/方法/字段的声明前面添加@注解名，并提供必要的参数，所有没有提供默认值的属性都需要提供值：

@AutoExtAjaxResult ( "Avalue" )
public String userInfo()
{
    return null;
}

要在运行时获取某个类/方法/字段上被附加的注解，需要使用反射机制，例如：

App.class.getMethod( "userInfo" ).getAnnotation( AutoExtAjaxResult.class ).value(); // Avalue

数组以及任何实现了

java.lang.Iterable

for ( char c : new char[] { 'H', 'E', 'L', 'L', 'O' } ) {
    System.out.println( c );
}
for ( String str : new ArrayList() ) {
    System.out.println( str );
}

现在基本类型与其包装类型的转换，可以自动进行了：

Number n = 1L;
Double d = 1.1d;
Boolean b = false;
boolean bp = Boolean.TRUE;
double dp = Double.valueOf( 1.1d );
long lp = new Long( 1l );

Java5中，枚举被作为一种特殊的类，可以使用enum关键字来声明，枚举类型不支持创建新实例。

枚举类型和普通类一样可以有字段、方法、构造器等部分，特别的是，枚举实例可以对方法进行覆盖。

public enum Color
{
    RED( "FF0000" ),
    GREEN( "00FF00" ),
    BLUE( "0000FF" )
    {
        //每个枚举值可以覆盖方法
        public String toString()
        {
            return "00F";
        }
    };
    //和普通类一样，枚举可以具有字段、方法、构造器
    private String code;

    private Color( String code )
    {
        this.code = code;
    }

    @Override
    public String toString()
    {
        return code;
    }
}

特殊的语法可以声明方法接受不定长度的参数，变长参数的声明必须位于形参列表的尾部：

public static void main( String[] args )
{
    varargsMethod( 1, 2, "1", "2", "3" );
    varargsMethod0( "1", "2", "3" );
}

private static void varargsMethod0( String... strs )
{
}

private static void varargsMethod( int i, int j, String... strs )
{
}

可以使用import static语法导入某些类中的静态方法，在当前文件中不需要提供这些类的名字就可以直接调用静态方法：

import static java.util.Collections.*;

public static void main( String[] args )
{
    sort( list ); //不需要提供Collections类名
}

这是一个Java5引入的专门用于并发编程的新包，该包主要有以下组件：

1. 支持并发的集合类型，位于java.util.concurrent包
2. 原子操作类，这些原子操作类受益于JVM引入了CAS（Compare-And-Set）机制，位于java.util.concurrent.atomic包
3. 新的同步原语，主要是一些锁类，位于java.util.concurrent.locks包
4. 并发相关工具，例如线程池、信号量等
5. 异步相关类，例如Future、Executor

concurrent中的集合类图如下（深色表示JDK 1.6追加）：

可以看到类很多，因此不一一描述，仅将类名中单词的含义列在下表：

concurrent.atomic包中的原子操作类包括：Boolean、Integer、Long、引用的原子类及其数组类型。

concurrent.locks包引入了一些用于支持锁定的类和接口，改变了Java只能依靠

synchronized

该包主要有三个接口：

synchronized

Condition)

synchronized

java.lang.Object

和异步编程有关的接口主要有四个：

1. Future接口表示一个“在未来某个时间点可用的结果”
2. Callable表示一个可调用对象
3. Executor接口可以用来执行一个Runnable
4. CompletionService则可用来调用Callable并（异步）获得结果

这些类的层次结构如下：

concurrent包包含的其它工具类有：

The post Java5新特性 appeared first on 绿色记忆.