jdk8新特性

Enhancements in Java SE 8

• Lambda Expressions enable you to encapsulate(封装) a single unit of behavior and pass it to other code. You can use a lambda expressions if you want a certain(某个) action performed on each element of a collection, when a process is completed, or when a process encounters（遭遇) an error. Lambda expressions are supported by the following features:
  
  

  • Method References are compact(紧凑的), easy-to-read lambda expressions for methods that already have a name.
    
    
  • Default Methods enable you to add new functionality to the interfaces of your libraries and ensure binary compatibility with code written for older versions of those interfaces. They are interface methods that have an implementation and the default keyword at the beginning of the method signature(签名). In addition, you can define static methods in interfaces.
    
    
  • New and Enhanced APIs That Take Advantage of(利用) Lambda Expressions and Streams in Java SE 8 describe new and enhanced classes that take advantage of lambda expressions and streams.
    
    

• Improved Type Inference - The Java compiler takes advantage of target typing to infer the type parameters of a generic method invocation. The target type of an expression is the data type that the Java compiler expects depending on where the expression appears. For example, you can use an assignment statement's target type for type inference in Java SE 7. However, in Java SE 8, you can use the target type for type inference in more contexts. The most prominent example is using a method invocation's target types to infer the data types of its arguments.
  
  

  Consider the following example:

  List stringList = new ArrayList<>();
  stringList.add("A");
  stringList.addAll(Arrays.asList());

  Disregarding generics for the moment, the method addAll expects a Collection instance as its argument, and the method Arrays.asList returns a List instance. This works because List is a subtype of Collection.
  
  Now considering generics, the target type of addAll is Collection<? extends String>, and Arrays.asList returns a List instance. In this example, the Java SE 8 compiler can infer that the value of the type variable T is String. The compiler infers this from the target type Collection<? extends String>.

  Compilers from Java SE 7 and earlier do not accept this code because they do not use target typing to infer types for method call arguments. For example, the Java SE 7 compiler generates an error message similar to the following:

  error: no suitable method found for addAll(List