對于Java開發(fā)者來說豁护，Java8的版本顯然是一個具有里程碑意義的版本蝴光，蘊含了許多令人激動的新特性径簿，如果能利用好這些新特性勿决，能夠大大提升我們的開發(fā)效率乒躺。Java8的函數(shù)式編程能夠大大減少代碼量和便于維護，同時低缩，還有一些跟并發(fā)相關(guān)的功能嘉冒。開發(fā)中常用到的新特性如下：

接口的默認方法和靜態(tài)方法

函數(shù)式接口FunctionInterface與lambda表達式

方法引用

Stream

Optional

Date/time API的改進

其他改進

<span id="1"></span>

1. 接口的默認方法和靜態(tài)方法

在Java8之前，接口中只能包含抽象方法咆繁。那么這有什么樣弊端呢讳推？比如，想再Collection接口中添加一個spliterator抽象方法玩般，那么也就意味著之前所有實現(xiàn)Collection接口的實現(xiàn)類银觅，都要重新實現(xiàn)spliterator這個方法才行。而接口的默認方法就是為了解決接口的修改與接口實現(xiàn)類不兼容的問題坏为，作為代碼向前兼容的一個方法究驴。

那么如何在接口中定義一個默認方法呢？來看下JDK中Collection中如何定義spliterator方法的：

default Spliterator<E> spliterator() {
    return Spliterators.spliterator(this, 0);
}

可以看到定義接口的默認方法是通過default關(guān)鍵字匀伏。因此洒忧，在Java8中接口能夠包含抽象方法外還能夠包含若干個默認方法（即有完整邏輯的實例方法）。

public interface IAnimal {
    default void breath(){
        System.out.println("breath!");
    };
}


public class DefaultMethodTest implements IAnimal {
    public static void main(String[] args) {
        DefaultMethodTest defaultMethod = new DefaultMethodTest();
        defaultMethod.breath();
    }

}


輸出結(jié)果為：breath!

可以看出IAnimal接口中有由default定義的默認方法后够颠，那么其實現(xiàn)類DefaultMethodTest也同樣能夠擁有實例方法breath熙侍。但是如果一個類繼承多個接口，多個接口中有相同的方法就會產(chǎn)生沖突該如何解決履磨？實際上默認方法的改進核行，使得java類能夠擁有類似多繼承的能力，即一個對象實例蹬耘，將擁有多個接口的實例方法芝雪，自然而然也會存在方法重復沖突的問題。

下面來看一個例子：

public interface IDonkey{
    default void run() {
        System.out.println("IDonkey run");
    }
}

public interface IHorse {

    default void run(){
        System.out.println("Horse run");
    }

}

public class DefaultMethodTest implements IDonkey,IHorse {
    public static void main(String[] args) {
        DefaultMethodTest defaultMethod = new DefaultMethodTest();
        defaultMethod.breath();
    }



}

定義兩個接口：IDonkey和IHorse综苔，這兩個接口中都有相同的run方法惩系。DefaultMethodTest實現(xiàn)了這兩個接口位岔，由于這兩個接口有相同的方法，因此就會產(chǎn)生沖突堡牡，不知道以哪個接口中的run方法為準抒抬，編譯會出錯：inherits unrelated defaults for run.....

解決方法

針對由默認方法引起的方法沖突問題，只有通過重寫沖突方法晤柄，并方法綁定的方式擦剑，指定以哪個接口中的默認方法為準。

public class DefaultMethodTest implements IAnimal,IDonkey,IHorse {
    public static void main(String[] args) {
        DefaultMethodTest defaultMethod = new DefaultMethodTest();
        defaultMethod.run();
    }

    @Override
    public void run() {
        IHorse.super.run();
    }
}

DefaultMethodTest重寫了run方法芥颈，并通過 IHorse.super.run();指定以IHorse中的run方法為準惠勒。

靜態(tài)方法

在Java8中還有一個特性就是，接口中還可以聲明靜態(tài)方法爬坑，如下例：

public interface IAnimal {
    default void breath(){
        System.out.println("breath!");
    }
    static void run(){}
}

<span id="2"></span>

2.函數(shù)式接口FunctionInterface與lambda表達式

函數(shù)式接口

Java8最大的變化是引入了函數(shù)式思想纠屋，也就是說函數(shù)可以作為另一個函數(shù)的參數(shù)。函數(shù)式接口盾计，要求接口中有且僅有一個抽象方法售担，因此經(jīng)常使用的Runnable，Callable接口就是典型的函數(shù)式接口署辉∽迕可以使用@FunctionalInterface注解，聲明一個接口是函數(shù)式接口哭尝。如果一個接口滿足函數(shù)式接口的定義骑素，會默認轉(zhuǎn)換成函數(shù)式接口。但是刚夺，最好是使用@FunctionalInterface注解顯式聲明献丑。這是因為函數(shù)式接口比較脆弱，如果開發(fā)人員無意間新增了其他方法侠姑，就破壞了函數(shù)式接口的要求创橄，如果使用注解@FunctionalInterface，開發(fā)人員就會知道當前接口是函數(shù)式接口莽红，就不會無意間破壞該接口妥畏。下面舉一個例子：

@java.lang.FunctionalInterface
public interface FunctionalInterface {
    void handle();
}

該接口只有一個抽象方法，并且使用注解顯式聲明安吁。但是醉蚁，函數(shù)式接口要求只有一個抽象方法卻可以擁有若干個默認方法的（實例方法），比如下例：

@java.lang.FunctionalInterface
public interface FunctionalInterface {
    void handle();

    default void run() {
        System.out.println("run");
    }
}

該接口中鬼店，除了有抽象方法handle外网棍，還有默認方法（實例方法）run。另外妇智，任何被Object實現(xiàn)的方法都不能當做是抽象方法滥玷。

lambda表達式

lambda表達式是函數(shù)式編程的核心氏身，lambda表達式即匿名函數(shù)，是一段沒有函數(shù)名的函數(shù)體惑畴，可以作為參數(shù)直接傳遞給相關(guān)的調(diào)用者蛋欣。lambda表達式極大的增加了Java語言的表達能力。lambda的語法結(jié)構(gòu)為：

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

• 可選類型聲明：不需要聲明參數(shù)類型如贷，編譯器可以統(tǒng)一識別參數(shù)值陷虎。

• 可選的參數(shù)圓括號：一個參數(shù)無需定義圓括號，但多個參數(shù)需要定義圓括號杠袱。

• 可選的大括號：如果主體包含了一個語句尚猿，就不需要使用大括號。

• 可選的返回關(guān)鍵字：如果主體只有一個表達式返回值則編譯器會自動返回值霞掺，大括號需要指定明表達式返回了一個數(shù)值谊路。

完整示例為（摘自菜鳥）

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 類型聲明
      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;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        
      // 不用括號
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括號
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");
      greetService2.sayMessage("Google");
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

另外讹躯，lambda還可以訪問外部局部變量菩彬，如下例所示：

int adder = 5;
Arrays.asList(1, 2, 3, 4, 5).forEach(e -> System.out.println(e + adder));

實際上在lambda中訪問類的成員變量或者局部變量時，會隱式轉(zhuǎn)換成final類型變量潮梯，所以上例實際上等價于：

final int adder = 5;
Arrays.asList(1, 2, 3, 4, 5).forEach(e -> System.out.println(e + adder));

<span id="3"></span>

3. 方法引用

方法引用是為了進一步簡化lambda表達式骗灶，通過類名或者實例名與方法名的組合來直接訪問到類或者實例已經(jīng)存在的方法或者構(gòu)造方法。方法引用使用::來定義秉馏，::的前半部分表示類名或者實例名耙旦，后半部分表示方法名，如果是構(gòu)造方法就使用NEW來表示萝究。

方法引用在Java8中使用方式相當靈活免都，總的來說，一共有以下幾種形式：

• 靜態(tài)方法引用：ClassName::methodName;
• 實例上的實例方法引用：instanceName::methodName;
• 超類上的實例方法引用：supper::methodName;
• 類的實例方法引用：ClassName:methodName;
• 構(gòu)造方法引用Class:new;
• 數(shù)組構(gòu)造方法引用::TypeName[]::new

下面來看一個例子：

public class MethodReferenceTest {

    public static void main(String[] args) {
        ArrayList<Car> cars = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Car car = Car.create(Car::new);
            cars.add(car);
        }
        cars.forEach(Car::showCar);

    }

    @FunctionalInterface
    interface Factory<T> {
        T create();
    }

    static class Car {
        public void showCar() {
            System.out.println(this.toString());
        }

        public static Car create(Factory<Car> factory) {
            return factory.create();
        }
    }
}


輸出結(jié)果：

learn.MethodReferenceTest$Car@769c9116
learn.MethodReferenceTest$Car@6aceb1a5
learn.MethodReferenceTest$Car@2d6d8735
learn.MethodReferenceTest$Car@ba4d54
learn.MethodReferenceTest$Car@12bc6874

在上面的例子中使用了Car::new帆竹，即通過構(gòu)造方法的方法引用的方式進一步簡化了lambda的表達式绕娘，Car::showCar，即表示實例方法引用栽连。

<span id="4"></span>

4. Stream

Java8中有一種新的數(shù)據(jù)處理方式险领，那就是流Stream，結(jié)合lambda表達式能夠更加簡潔高效的處理數(shù)據(jù)秒紧。Stream使用一種類似于SQL語句從數(shù)據(jù)庫查詢數(shù)據(jù)的直觀方式绢陌，對數(shù)據(jù)進行如篩選、排序以及聚合等多種操作熔恢。

4.1 什么是流Stream

Stream是一個來自數(shù)據(jù)源的元素隊列并支持聚合操作脐湾，更像是一個更高版本的Iterator,原始版本的Iterator，只能一個個遍歷元素并完成相應操作叙淌。而使用Stream沥割，只需要指定什么操作耗啦，如“過濾長度大于10的字符串”等操作，Stream會內(nèi)部遍歷并完成指定操作机杜。

Stream中的元素在管道中經(jīng)過中間操作（intermediate operation）的處理后帜讲，最后由最終操作（terminal operation）得到最終的結(jié)果。

• 數(shù)據(jù)源：是Stream的來源椒拗，可以是集合似将、數(shù)組、I/O channel等轉(zhuǎn)換而成的Stream蚀苛；
• 基本操作：類似于SQL語句一樣的操作在验，比如filter,map,reduce,find,match,sort等操作。

當我們操作一個流時堵未，實際上會包含這樣的執(zhí)行過程：

獲取數(shù)據(jù)源-->轉(zhuǎn)換成Stream-->執(zhí)行操作腋舌，返回一個新的Stream-->再以新的Stream繼續(xù)執(zhí)行操作--->直至最后操作輸出最終結(jié)果。

4.2 生成Stream的方式

生成Stream的方式主要有這樣幾種：

1. 從接口Collection中和Arrays：

   • Collection.stream();
   • Collection.parallelStream(); //相較于串行流渗蟹，并行流能夠大大提升執(zhí)行效率
   • Arrays.stream(T array);

2. Stream中的靜態(tài)方法：

   • Stream.of()块饺；
   • generate(Supplier<T> s);
   • iterate(T seed, UnaryOperator<T> f);
   • empty();

3. 其他方法

   • Random.ints()
   • BitSet.stream()
   • Pattern.splitAsStream(java.lang.CharSequence)
   • JarFile.stream()
   • BufferedReader.lines()

下面對前面常見的兩種方式給出示例：

public class StreamTest {


    public static void main(String[] args) {
        //1.使用Collection中的方法和Arrays
        String[] strArr = new String[]{"a", "b", "c"};
        List<String> list = Arrays.asList(strArr);
        Stream<String> stream = list.stream();
        Stream<String> stream1 = Arrays.stream(strArr);

        //2. 使用Stream中提供的靜態(tài)方法
        Stream<String> stream2 = Stream.of(strArr);
        Stream<Double> stream3 = Stream.generate(Math::random);
        Stream<Object> stream4 = Stream.empty();
        Stream.iterate(1, i -> i++);

    }
}   

4.3 Stream的操作

常見的Stream操作有這樣幾種：

1. Intermediate（中間操作）:中間操作是指對流中數(shù)據(jù)元素做出相應轉(zhuǎn)換或操作后依然返回為一個流Stream，仍然可以供下一次流操作使用雌芽。常用的有：map (mapToInt, flatMap 等)授艰、 filter、 distinct世落、 sorted淮腾、 peek、 limit屉佳、 skip谷朝。
2. Termial（結(jié)束操作）：是指最終對Stream做出聚合操作，輸出結(jié)果武花。

中間操作

filter：對Stream中元素進行過濾

過濾元素為空的字符串：

long count = stream.filter(str -> str.isEmpty()).count();

map：對Stream中元素按照指定規(guī)則映射成另一個元素

將每一個元素都添加字符串“_map”

stream.map(str -> str + "_map").forEach(System.out::println);

map方法是一對一的關(guān)系圆凰，將stream中的每一個元素按照映射規(guī)則成另外一個元素，而如果是一對多的關(guān)系的話就需要使用flatmap方法髓堪。

concat：對流進行合并操作

concat方法將兩個Stream連接在一起送朱，合成一個Stream。若兩個輸入的Stream都時排序的干旁，則新Stream也是排序的驶沼；若輸入的Stream中任何一個是并行的，則新的Stream也是并行的争群；若關(guān)閉新的Stream時回怜，原兩個輸入的Stream都將執(zhí)行關(guān)閉處理。

Stream.concat(Stream.of(1, 2, 3), Stream.of(4, 5, 6)).
    forEach(System.out::println);

distinct：對流進行去重操作

去除流中重復的元素

Stream<String> stream = Stream.of("a", "a", "b", "c");
        stream.distinct().forEach(System.out::println);

輸出結(jié)果：
a
b
c

limit：限制流中元素的個數(shù)

截取流中前兩個元素：

Stream<String> stream = Stream.of("a", "a", "b", "c");
        stream.limit(2).forEach(System.out::println);

輸出結(jié)果：
a
a

skip：跳過流中前幾個元素

丟掉流中前兩個元素：

Stream<String> stream = Stream.of("a", "a", "b", "c");
        stream.skip(2).forEach(System.out::println);
輸出結(jié)果：
b
c

peek：對流中每一個元素依次進行操作，類似于forEach操作

JDK中給出的例子：

Stream.of("one", "two", "three", "four")
            .filter(e -> e.length() > 3)
            .peek(e -> System.out.println("Filtered value: " + e))
            .map(String::toUpperCase)
            .peek(e -> System.out.println("Mapped value: " + e))
            .collect(Collectors.toList());
輸出結(jié)果：
Filtered value: three
Mapped value: THREE
Filtered value: four
Mapped value: FOUR

sorted：對流中元素進行排序玉雾，可以通過sorted(Comparator<? super T> comparator)自定義比較規(guī)則

Stream<Integer> stream = Stream.of(3, 2, 1);
        stream.sorted(Integer::compareTo).forEach(System.out::println);
輸出結(jié)果：
1
2
3

match：檢查流中元素是否匹配指定的匹配規(guī)則

Stream 有三個 match 方法翔试，從語義上說：

• allMatch：Stream 中全部元素符合傳入的 predicate，返回 true复旬；
• anyMatch：Stream 中只要有一個元素符合傳入的 predicate垦缅，返回 true；
• noneMatch：Stream 中沒有一個元素符合傳入的 predicate驹碍，返回 true壁涎。

如檢查Stream中每個元素是否都大于5：

Stream<Integer> stream = Stream.of(3, 2, 1);
boolean match = stream.allMatch(integer -> integer > 5);
System.out.println(match);
輸出結(jié)果：
false

結(jié)束操作

Collectors中常見歸約方法總結(jié)

重構(gòu)和定制收集器Collectors

count：統(tǒng)計Stream中元素的個數(shù)

long count = stream.filter(str -> str.isEmpty()).count();

max/min：找出流中最大或者最小的元素

Stream<Integer> stream = Stream.of(3, 2, 1);
    System.out.println(stream.max(Integer::compareTo).get());

輸出結(jié)果：
3

forEach

forEach方法前面已經(jīng)用了好多次，其用于遍歷Stream中的所元素志秃，避免了使用for循環(huán)怔球，讓代碼更簡潔，邏輯更清晰浮还。

示例：

Stream.of(5, 4, 3, 2, 1)
    .sorted()
    .forEach(System.out::println);
    // 打印結(jié)果
    // 1竟坛，2，3,4,5

reduce

Stream中的Reduce講解

<span id="5"></span>

5. Optional

為了解決空指針異常钧舌，在Java8之前需要使用if-else這樣的語句去防止空指針異常担汤，而在Java8就可以使用Optional來解決。Optional可以理解成一個數(shù)據(jù)容器延刘，甚至可以封裝null漫试，并且如果值存在調(diào)用isPresent()方法會返回true六敬。為了能夠理解Optional碘赖。先來看一個例子：

public class OptionalTest {


    private String getUserName(User user) {
        return user.getUserName();
    }

    class User {
        private String userName;

        public User(String userName) {
            this.userName = userName;
        }

        public String getUserName() {
            return userName;
        }
    }
}

事實上，getUserName方法對輸入?yún)?shù)并沒有進行判斷是否為null外构，因此普泡，該方法是不安全的。如果在Java8之前审编，要避免可能存在的空指針異常的話就需要使用if-else進行邏輯處理撼班，getUserName會改變?nèi)缦拢?/p>

private String getUserName(User user) {
    if (user != null) {
        return user.getUserName();
    }
    return null;
}

這是十分繁瑣的一段代碼。而如果使用Optional則會要精簡很多：

private String getUserName(User user) {
    Optional<User> userOptional = Optional.ofNullable(user);
    return userOptional.map(User::getUserName).orElse(null);
}

Java8之前的if-else的邏輯判斷垒酬，這是一種命令式編程的方式砰嘁，而使用Optional更像是一種函數(shù)式編程，關(guān)注于最后的結(jié)果勘究，而中間的處理過程交給JDK內(nèi)部實現(xiàn)矮湘。

到現(xiàn)在，可以直觀的知道Optional對避免空指針異常很有效口糕，下面缅阳，對Optional的API進行歸納：

創(chuàng)建Optional

1. Optional.empty():通過靜態(tài)工廠方法Optional.empty，創(chuàng)建一個空的Optional對象景描；
2. Optional<T> of(T value):如果value為null的話十办，立即拋出NullPointerException秀撇；
3. Optional<T> ofNullable(T value)：使用靜態(tài)工廠方法Optional.ofNullable，你可以創(chuàng)建一個允許null值的Optional對象向族。

實例代碼：

//創(chuàng)建Optional
Optional<Object> optional = Optional.empty();
Optional<Object> optional1 = Optional.ofNullable(null);
Optional<String> optional2 = Optional.of(null);

常用方法

1.  boolean equals(Object obj)：判斷其他對象是否等于 Optional呵燕；
2. Optional<T> filter(Predicate<? super <T> predicate)：如果值存在，并且這個值匹配給定的 predicate件相，返回一個Optional用以描述這個值虏等，否則返回一個空的Optional；
3. <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)：如果值存在适肠，返回基于Optional包含的映射方法的值霍衫，否則返回一個空的Optional；
4. T get()：如果在這個Optional中包含這個值侯养，返回值敦跌，否則拋出異常：NoSuchElementException；
5. int hashCode()：返回存在值的哈希碼逛揩，如果值不存在 返回 0柠傍；
6. void ifPresent(Consumer<? super T> consumer)：如果值存在則使用該值調(diào)用 consumer , 否則不做任何事情；
7. boolean isPresent()：如果值存在則方法會返回true辩稽，否則返回 false惧笛；
8. <U>Optional<U> map(Function<? super T,? extends U> mapper)：如果存在該值，提供的映射方法逞泄，如果返回非null患整，返回一個Optional描述結(jié)果；
9. T orElse(T other)：如果存在該值喷众，返回值各谚， 否則返回 other；
10. T orElseGet(Supplier<? extends T> other)：如果存在該值到千，返回值昌渤， 否則觸發(fā) other，并返回 other 調(diào)用的結(jié)果憔四；
11. <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果存在該值膀息，返回包含的值，否則拋出由 Supplier 繼承的異常了赵；
12. String toString()：返回一個Optional的非空字符串潜支，用來調(diào)試

<span id="6"></span>

6. Date/time API的改進

在Java8之前的版本中，日期時間API存在很多的問題斟览，比如：

• 線程安全問題：java.util.Date是非線程安全的毁腿，所有的日期類都是可變的；
• 設計很差：在java.util和java.sql的包中都有日期類，此外已烤，用于格式化和解析的類在java.text包中也有定義鸠窗。而每個包將其合并在一起，也是不合理的胯究；
• 時區(qū)處理麻煩：日期類不提供國際化稍计，沒有時區(qū)支持，因此Java中引入了java.util.Calendar和Java.util.TimeZone類裕循；

針對這些問題臣嚣，Java8重新設計了日期時間相關(guān)的API，Java 8通過發(fā)布新的Date-Time API (JSR 310)來進一步加強對日期與時間的處理剥哑。在java.util.time包中常用的幾個類有：

• 它通過指定一個時區(qū)硅则，然后就可以獲取到當前的時刻，日期與時間株婴。Clock可以替換System.currentTimeMillis()與TimeZone.getDefault()
• Instant:一個instant對象表示時間軸上的一個時間點怎虫，Instant.now()方法會返回當前的瞬時點（格林威治時間）；
• Duration:用于表示兩個瞬時點相差的時間量困介；
• LocalDate:一個帶有年份大审，月份和天數(shù)的日期，可以使用靜態(tài)方法now或者of方法進行創(chuàng)建座哩；
• LocalTime:表示一天中的某個時間徒扶，同樣可以使用now和of進行創(chuàng)建；
• LocalDateTime：兼有日期和時間根穷；
• ZonedDateTime：通過設置時間的id來創(chuàng)建一個帶時區(qū)的時間姜骡；
• DateTimeFormatter：日期格式化類，提供了多種預定義的標準格式缠诅；

示例代碼如下：

public class TimeTest {
    public static void main(String[] args) {
        Clock clock = Clock.systemUTC();
        Instant instant = clock.instant();
        System.out.println(instant.toString());

        LocalDate localDate = LocalDate.now();
        System.out.println(localDate.toString());

        LocalTime localTime = LocalTime.now();
        System.out.println(localTime.toString());

        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime.toString());

        ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
        System.out.println(zonedDateTime.toString());
    }
}
輸出結(jié)果為：
2018-04-14T12:50:27.437Z
2018-04-14
20:50:27.646
2018-04-14T20:50:27.646
2018-04-14T20:50:27.647+08:00[Asia/Shanghai]

<span id="7"></span>

7. 其他改進

Java8還在其他細節(jié)上也做出了改變溶浴，歸納如下：

1. 之前的版本乍迄，注解在同一個位置只能聲明一次管引，而Java8版本中提供@Repeatable注解，來實現(xiàn)可重復注解闯两；
2. String類中提供了join方法來完成字符串的拼接褥伴；
3. 在Arrays上提供了并行化處理數(shù)組的方式，比如利用Arrays類中的parallelSort可完成并行排序漾狼；
4. 在Java8中在并發(fā)應用層面上也是下足了功夫：（1）提供功能更強大的Future：CompletableFuture重慢；（2）StampedLock可用來替代ReadWriteLock；（3）性能更優(yōu)的原子類：：LongAdder,LongAccumulator以及DoubleAdder和DoubleAccumulator逊躁；
5. 編譯器新增一些特性以及提供一些新的Java工具

參考資料

Stream的參考資料：

Stream API講解

Stream講解系列文章

對Stream的講解很細致

Java8新特性之Stream API

Optional的參考資料：

Optional的API講解很詳細

對Optional部分的講解還不錯似踱，值得參考

Java8新特性的介紹：

Java8新特性指南，很好的資料

跟上 Java 8 – 你忽略了的新特性

Java8新特性學習系列教程