—學習于尚硅谷視頻—

寫在前面：

2014年，Oracle發布了Java8新版本。對于Java來說，這顯然是一個具有里程碑意義的版本。

但我在2017年6月這個時候才學習了下Java8，而且Java9也要在今年出來，時間好像推遲了一點，隨便找了篇關于Java9的公眾文章：http://mp.weixin.qq.com/s/3HlAFLxuxGEU8XlLY1wTvw

然后Java10的消息我也看到相關文章：http://mp.weixin.qq.com/s/Ezu9Gfmtva-8MAYXEYuC7w

相關Java8的文章資料：
https://segmentfault.com/a/1190000006985405
http://blog.csdn.net/yczz/article/details/50896975#t2
Java8初體驗（二）Stream語法詳解
Java基礎知識總結之1.8新特性lambda表達式

---

Java 8新特性簡介：

• 速度更快
• 代碼更少（增加了新的語法 Lambda 表達式）
• 強大的 Stream API
• 便于并行
• 最大化減少空指針異常 Optional

其中最為核心的為 Lambda 表達式與Stream API

---

1. Lambda表達式

Q：為什么使用 Lambda 表達式
A：Lambda 是一個匿名函數，我們可以把 Lambda表達式理解為是一段可以傳遞的代碼（將代碼像數據一樣進行傳遞）。可以寫出更簡潔、更靈活的代碼。作為一種更緊湊的代碼風格，使Java的語言表達能力得到了提升。

從匿名內部類到 Lambda 的轉換：

例1：

//匿名內部類 Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("hello world");} }; //Lambda表達式 Runnable r1 = () -> System.out.println("hello Lambda");

例2：

//原來使用匿名內部類作為參數傳遞 TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>(){@Overridepublic int compare(String o1, String o2) {return Integer.compare(o1.length(), o2.length());} }); //Lambda 表達式作為參數傳遞 Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());

Lambda 表達式語法

Lambda 表達式在 Java8 中引入了一個新的語法元素和操作符。這個操作符為 “->” ， 該操作符被稱為 Lambda 操作符或剪頭操作符。它將 Lambda 分為兩個部分：

左側： 指定了 Lambda 表達式需要的所有參數
右側： 指定了 Lambda 體，即 Lambda 表達式要執行的功能。

語法格式一：無參數，無返回值 () -> System.out.println("Hello Lambda!");

語法格式二：有一個參數，并且無返回值(x) -> System.out.println(x);

語法格式三：若只有一個參數，小括號可以省略不寫x -> System.out.println(x);

語法格式四：有兩個以上的參數，有返回值，并且 Lambda 體中有多條語句

Comparator<Integer> com = (x, y) -> {System.out.println("函數式接口");return Integer.compare(x, y); };

語法格式五：若 Lambda 體中只有一條語句，return 和 大括號都可以省略不寫Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

語法格式六： Lambda 表達式的參數列表的數據類型可以省略不寫，因為JVM編譯器通過上下文推斷出，數據類型，即“類型推斷”(Integer x, Integer y) -> Integer.compare(x, y);
注：上述 Lambda 表達式中的參數類型都是由編譯器推斷得出的。 Lambda 表達式中無需指定類型，程序依然可以編譯，這是因為 javac 根據程序的上下文，在后臺推斷出了參數的類型。 Lambda 表達式的類型依賴于上下文環境，是由編譯器推斷出來的。這就是所謂的“類型推斷”。

上聯：左右遇一括號省
下聯：左側推斷類型省
橫批：能省則省

2. 函數式接口

Q：什么是函數式接口？

• 只包含一個抽象方法的接口，稱為函數式接口。
• 你可以通過 Lambda 表達式來創建該接口的對象。（若 Lambda 表達式拋出一個受檢異常，那么該異常需要在目標接口的抽象方法上進行聲明）。
• 我們可以在任意函數式接口上使用 @FunctionalInterface 注解，這樣做可以檢查它是否是一個函數式接口，同時 javadoc 也會包含一條聲明，說明這個接口是一個函數式接口。

自定義函數接口

@FunctionalInterface public interface MyNumber {public dobule getValue(); }//函數式接口中使用泛型 @FunctionalInterface public interface MyFunc<T> {public T getValue(T t); }

作為參數傳遞 Lambda 表達式：

public String toUpperString(MyFunc<String> mf, String str){return mf.getValue(Str); }//作為參數傳遞 Lambda 表達式 String newStr = toUpperString((str) -> str.toUpperCase(), "abcdef"); System.out.println(newStr);

注：作為參數傳遞 Lambda 表達式：為了將 Lambda 表達式作為參數傳遞，接收Lambda 表達式的參數類型必須是與該 Lambda 表達式兼容的函數式接口的類型。

Java 內置四大核心函數式接口

Java8 內置的四大核心函數式接口

Consumer : 消費型接口
void accept(T t);

Supplier<T> : 供給型接口
T get();

Function<T, R> : 函數型接口
R apply(T t);

Predicate<T> : 斷言型接口
boolean test(T t);

斷言型接口：

//Predicate<T> 斷言型接口：@Testpublic void test4(){List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");List<String> strList = filterStr(list, (s) -> s.length() > 3);for (String str : strList) {System.out.println(str);}}//需求：將滿足條件的字符串，放入集合中public List<String> filterStr(List<String> list, Predicate<String> pre){List<String> strList = new ArrayList<>();for (String str : list) {if(pre.test(str)){strList.add(str);}}return strList;}

函數型接口：

//Function<T, R> 函數型接口：@Testpublic void test3(){String newStr = strHandler("\t\t\t 我大尚硅谷威武 ", (str) -> str.trim());System.out.println(newStr);String subStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));System.out.println(subStr);}//需求：用于處理字符串public String strHandler(String str, Function<String, String> fun){return fun.apply(str);}

供給型接口：

//Supplier<T> 供給型接口 :@Testpublic void test2(){List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));for (Integer num : numList) {System.out.println(num);}}//需求：產生指定個數的整數，并放入集合中public List<Integer> getNumList(int num, Supplier<Integer> sup){List<Integer> list = new ArrayList<>();for (int i = 0; i < num; i++) {Integer n = sup.get();list.add(n);}return list;}

消費型接口：

//Consumer<T> 消費型接口 :@Testpublic void test1(){happy(10000, (m) -> System.out.println("你們剛哥喜歡大寶劍，每次消費：" + m + "元"));} public void happy(double money, Consumer<Double> con){con.accept(money);}

其他接口

3. 方法引用與構造器引用

方法引用

若 Lambda 體中的功能，已經有方法提供了實現，可以使用方法引用
（可以將方法引用理解為 Lambda 表達式的另外一種表現形式）
方法引用：使用操作符 “::” 將方法名和對象或類的名字分隔開來。

如下三種主要使用情況：

對象::實例方法

類::靜態方法

類::實例方法

注意：
①方法引用所引用的方法的參數列表與返回值類型，需要與函數式接口中抽象方法的參數列表和返回值類型保持一致！
②若Lambda 的參數列表的第一個參數，是實例方法的調用者，第二個參數(或無參)是實例方法的參數時，格式： ClassName::MethodName

例如：
(x) -> System.out.println(x);
等同于 System.out::println;

BinaryOperator<Double> bo = (x, y) -> Math.pow(x, y);
等同于 BinaryOperator<Double> bo = Math::pow;

compare((x,y) -> x.equals(y), "abcdef", "abcdef");
等同于 compare(String::equals, "abc", "abc");

注意： 當需要引用方法的第一個參數是調用對象，并且第二個參數是需要引用方法的第二個參數(或無參數)時： ClassName::methodName

對象的引用 :: 實例方法名

//對象的引用 :: 實例方法名@Testpublic void test2(){Employee emp = new Employee(101, "張三", 18, 9999.99);Supplier<String> sup = () -> emp.getName();System.out.println(sup.get());System.out.println("----------------------------------");Supplier<String> sup2 = emp::getName;System.out.println(sup2.get());}@Testpublic void test1(){PrintStream ps = System.out;Consumer<String> con = (str) -> ps.println(str);con.accept("Hello World！");System.out.println("--------------------------------");Consumer<String> con2 = ps::println;con2.accept("Hello Java8！");Consumer<String> con3 = System.out::println;}

類名 :: 靜態方法名

@Testpublic void test4(){Comparator<Integer> com = (x, y) -> Integer.compare(x, y);System.out.println("-------------------------------------");Comparator<Integer> com2 = Integer::compare;}@Testpublic void test3(){BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);System.out.println(fun.apply(1.5, 22.2));System.out.println("--------------------------------------------------");BiFunction<Double, Double, Double> fun2 = Math::max;System.out.println(fun2.apply(1.2, 1.5));}

類名 :: 實例方法名

@Testpublic void test5(){BiPredicate<String, String> bp = (x, y) -> x.equals(y);System.out.println(bp.test("abcde", "abcde"));System.out.println("-----------------------------------------");BiPredicate<String, String> bp2 = String::equals;System.out.println(bp2.test("abc", "abc"));System.out.println("-----------------------------------------");Function<Employee, String> fun = (e) -> e.show();System.out.println(fun.apply(new Employee()));System.out.println("-----------------------------------------");Function<Employee, String> fun2 = Employee::show;System.out.println(fun2.apply(new Employee()));}

構造器引用

格式： ClassName::new
與函數式接口相結合，自動與函數式接口中方法兼容。可以把構造器引用賦值給定義的方法，與構造器參數列表要與接口中抽象方法的參數列表一致！

例如：
Function<Integer, MyClass> fun = (n) -> new MyClass(n);
等同于 Function<Integer, MyClass> fun = MyClass::new;

//構造器引用@Testpublic void test7(){Function<String, Employee> fun = Employee::new;BiFunction<String, Integer, Employee> fun2 = Employee::new;}@Testpublic void test6(){Supplier<Employee> sup = () -> new Employee();System.out.println(sup.get());System.out.println("------------------------------------");Supplier<Employee> sup2 = Employee::new;System.out.println(sup2.get());}

數組引用

格式： type[] :: new

Function<Integer, Integer[]> fun = (n) -> new Integer[n];
等同于 Function<Integer, Integer[]> fun = Integer[]::new;

//數組引用@Testpublic void test8(){Function<Integer, String[]> fun = (args) -> new String[args];String[] strs = fun.apply(10);System.out.println(strs.length);System.out.println("--------------------------");Function<Integer, Employee[]> fun2 = Employee[] :: new;Employee[] emps = fun2.apply(20);System.out.println(emps.length);}

4. 強大的 Stream API

了解 Stream

Java8中有兩大最為重要的改變。第一個是 Lambda 表達式；另外一
個則是 Stream API(java.util.stream.*)。
Stream 是 Java8 中處理集合的關鍵抽象概念，它可以指定你希望對集合進行的操作，可以執行非常復雜的查找、過濾和映射數據等操作。使用Stream API 對集合數據進行操作，就類似于使用 SQL 執行的數據庫查詢。也可以使用 Stream API 來并行執行操作。簡而言之，Stream API 提供了一種高效且易于使用的處理數據的方式。

什么是 Stream？

流(Stream) 到底是什么呢？是數據渠道，用于操作數據源（集合、數組等）所生成的元素序列。“集合講的是數據，流講的是計算！ ”

注意：
①Stream 自己不會存儲元素。
②Stream 不會改變源對象。相反，他們會返回一個持有結果的新Stream。
③Stream 操作是延遲執行的。這意味著他們會等到需要結果的時候才執行。

Stream 的操作三個步驟

創建 Stream
一個數據源（如： 集合、數組）， 獲取一個流

中間操作
一個中間操作鏈，對數據源的數據進行處理

終止操作(終端操作)
一個終止操作，執行中間操作鏈，并產生結果

1)創建 Stream

Java8 中的 Collection 接口被擴展，提供了兩個獲取流的方法：
default Stream<E> stream(): 返回一個順序流
default Stream<E> parallelStream() : 返回一個并行流

Java8 中的 Arrays 的靜態方法 stream() 可以獲取數組流：
static <T> Stream<T> stream(T[] array): 返回一個流

重載形式，能夠處理對應基本類型的數組：
public static IntStream stream(int[] array)
public static LongStream stream(long[] array)
public static DoubleStream stream(double[] array)

由值創建流：可以使用靜態方法 Stream.of(), 通過顯示值創建一個流。它可以接收任意數量的參數。
public static<T> Stream<T> of(T... values) : 返回一個流

由函數創建流：創建無限流。可以使用靜態方法 Stream.iterate() 和
Stream.generate(), 創建無限流。

• 迭代
  public static<T> Stream<T> iterate(final T seed, final
  UnaryOperator<T> f)
• 生成
  public static<T> Stream<T> generate(Supplier<T> s) :

2)Stream 的中間操作

多個中間操作可以連接起來形成一個流水線，除非流水線上觸發終止操作，否則中間操作不會執行任何的處理！而在終止操作時一次性全部處理，稱為“惰性求值” 。

篩選與切片：

映射：

/*映射map——接收 Lambda ， 將元素轉換成其他形式或提取信息。接收一個函數作為參數，該函數會被應用到每個元素上，并將其映射成一個新的元素。flatMap——接收一個函數作為參數，將流中的每個值都換成另一個流，然后把所有流連接成一個流 */ @Testpublic void test1(){Stream<String> str = emps.stream().map((e) -> e.getName());System.out.println("-------------------------------------------");List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");Stream<String> stream = strList.stream().map(String::toUpperCase);stream.forEach(System.out::println);Stream<Stream<Character>> stream2 = strList.stream().map(TestStreamAPI1::filterCharacter);stream2.forEach((sm) -> {sm.forEach(System.out::println);});System.out.println("---------------------------------------------");Stream<Character> stream3 = strList.stream().flatMap(TestStreamAPI1::filterCharacter);stream3.forEach(System.out::println);}public static Stream<Character> filterCharacter(String str){List<Character> list = new ArrayList<>();for (Character ch : str.toCharArray()) {list.add(ch);}return list.stream();}

排序：

/*sorted()——自然排序sorted(Comparator com)——定制排序*/@Testpublic void test2(){emps.stream().map(Employee::getName).sorted().forEach(System.out::println);System.out.println("------------------------------------");emps.stream().sorted((x, y) -> {if(x.getAge() == y.getAge()){return x.getName().compareTo(y.getName());}else{return Integer.compare(x.getAge(), y.getAge());}}).forEach(System.out::println);}

3)Stream 的終止操作

終端操作會從流的流水線生成結果。其結果可以是任何不是流的值，例如： List、 Integer，甚至是 void 。

查找與匹配：

/*allMatch——檢查是否匹配所有元素anyMatch——檢查是否至少匹配一個元素noneMatch——檢查是否沒有匹配的元素findFirst——返回第一個元素findAny——返回當前流中的任意元素count——返回流中元素的總個數max——返回流中最大值min——返回流中最小值*/@Testpublic void test1(){boolean bl = emps.stream().allMatch((e) -> e.getStatus().equals(Status.BUSY));System.out.println(bl);boolean bl1 = emps.stream().anyMatch((e) -> e.getStatus().equals(Status.BUSY));System.out.println(bl1);boolean bl2 = emps.stream().noneMatch((e) -> e.getStatus().equals(Status.BUSY));System.out.println(bl2);}@Testpublic void test2(){Optional<Employee> op = emps.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).findFirst();System.out.println(op.get());System.out.println("--------------------------------");Optional<Employee> op2 = emps.parallelStream().filter((e) -> e.getStatus().equals(Status.FREE)).findAny();System.out.println(op2.get());}@Testpublic void test3(){long count = emps.stream().filter((e) -> e.getStatus().equals(Status.FREE)).count();System.out.println(count);Optional<Double> op = emps.stream().map(Employee::getSalary).max(Double::compare);System.out.println(op.get());Optional<Employee> op2 = emps.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));System.out.println(op2.get());}//注意：流進行了終止操作后，不能再次使用@Testpublic void test4(){Stream<Employee> stream = emps.stream().filter((e) -> e.getStatus().equals(Status.FREE));long count = stream.count();stream.map(Employee::getSalary).max(Double::compare);}

歸約：

備注：map 和 reduce 的連接通常稱為 map-reduce 模式，因 Google 用它來進行網絡搜索而出名。

/*歸約reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以將流中元素反復結合起來，得到一個值。*/@Testpublic void test1(){List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);Integer sum = list.stream().reduce(0, (x, y) -> x + y);System.out.println(sum);System.out.println("----------------------------------------");Optional<Double> op = emps.stream().map(Employee::getSalary).reduce(Double::sum);System.out.println(op.get());}//需求：搜索名字中 “六” 出現的次數@Testpublic void test2(){Optional<Integer> sum = emps.stream().map(Employee::getName).flatMap(TestStreamAPI1::filterCharacter).map((ch) -> {if(ch.equals('六'))return 1;else return 0;}).reduce(Integer::sum);System.out.println(sum.get());}

收集：

Collector 接口中方法的實現決定了如何對流執行收集操作(如收集到 List、 Set、 Map)。但是 Collectors 實用類提供了很多靜態方法，可以方便地創建常見收集器實例， 具體方法與實例如下表：

//collect——將流轉換為其他形式。接收一個 Collector接口的實現，用于給Stream中元素做匯總的方法@Testpublic void test3(){List<String> list = emps.stream().map(Employee::getName).collect(Collectors.toList());list.forEach(System.out::println);System.out.println("----------------------------------");Set<String> set = emps.stream().map(Employee::getName).collect(Collectors.toSet());set.forEach(System.out::println);System.out.println("----------------------------------");HashSet<String> hs = emps.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));hs.forEach(System.out::println);}@Testpublic void test4(){Optional<Double> max = emps.stream().map(Employee::getSalary).collect(Collectors.maxBy(Double::compare));System.out.println(max.get());Optional<Employee> op = emps.stream().collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));System.out.println(op.get());Double sum = emps.stream().collect(Collectors.summingDouble(Employee::getSalary));System.out.println(sum);Double avg = emps.stream().collect(Collectors.averagingDouble(Employee::getSalary));System.out.println(avg);Long count = emps.stream().collect(Collectors.counting());System.out.println(count);System.out.println("--------------------------------------------");DoubleSummaryStatistics dss = emps.stream().collect(Collectors.summarizingDouble(Employee::getSalary));System.out.println(dss.getMax());}//分組@Testpublic void test5(){Map<Status, List<Employee>> map = emps.stream().collect(Collectors.groupingBy(Employee::getStatus));System.out.println(map);}//多級分組@Testpublic void test6(){Map<Status, Map<String, List<Employee>>> map = emps.stream().collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {if(e.getAge() >= 60)return "老年";else if(e.getAge() >= 35)return "中年";elsereturn "成年";})));System.out.println(map);}//分區@Testpublic void test7(){Map<Boolean, List<Employee>> map = emps.stream().collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000));System.out.println(map);}//@Testpublic void test8(){String str = emps.stream().map(Employee::getName).collect(Collectors.joining("," , "----", "----"));System.out.println(str);}@Testpublic void test9(){Optional<Double> sum = emps.stream().map(Employee::getSalary).collect(Collectors.reducing(Double::sum));System.out.println(sum.get());}

并行流與串行流

并行流就是把一個內容分成多個數據塊，并用不同的線程分別處理每個數據塊的流。

Java 8 中將并行進行了優化，我們可以很容易的對數據進行并行操作。 Stream API 可以聲明性地通過 parallel() 與 sequential() 在并行流與順序流之間進行切換。

了解 Fork/Join 框架

Fork/Join 框架： 就是在必要的情況下，將一個大任務，進行拆分(fork)成若干個小任務（拆到不可再拆時），再將一個個的小任務運算的結果進行 join 匯總。

Fork/Join 框架與傳統線程池的區別
采用 “工作竊取”模式（work-stealing）：當執行新的任務時它可以將其拆分分成更小的任務執行，并將小任務加到線程隊列中，然后再從一個隨機線程的隊列中偷一個并把它放在自己的隊列中。

相對于一般的線程池實現,fork/join框架的優勢體現在對其中包含的任務的處理方式上.在一般的線程池中,如果一個線程正在執行的任務由于某些原因無法繼續運行,那么該線程會處于等待狀態.而在fork/join框架實現中,如果某個子問題由于等待另外一個子問題的完成而無法繼續運行.那么處理該子問題的線程會主動尋找其他尚未運行的子問題來執行.這種方式減少了線程的等待時間,提高了性能。

import java.util.concurrent.RecursiveTask;public class ForkJoinCalculate extends RecursiveTask<Long>{/*** */private static final long serialVersionUID = 13475679780L;private long start;private long end;private static final long THRESHOLD = 10000L; //臨界值public ForkJoinCalculate(long start, long end) {this.start = start;this.end = end;}@Overrideprotected Long compute() {long length = end - start;if(length <= THRESHOLD){long sum = 0;for (long i = start; i <= end; i++) {sum += i;}return sum;}else{long middle = (start + end) / 2;ForkJoinCalculate left = new ForkJoinCalculate(start, middle);left.fork(); //拆分，并將該子任務壓入線程隊列ForkJoinCalculate right = new ForkJoinCalculate(middle+1, end);right.fork();return left.join() + right.join();}} }

5. 新時間日期 API

使用 LocalDate、 LocalTime、 LocalDateTime

LocalDate、 LocalTime、 LocalDateTime 類的實例是不可變的對象，分別表示使用 ISO-8601日歷系統的日期、時間、日期和時間。它們提供
了簡單的日期或時間，并不包含當前的時間信息。也不包含與時區相關的信息。

注： ISO-8601日歷系統是國際標準化組織制定的現代公民的日期和時間的表示法。

Instant 時間戳
用于“時間戳”的運算。它是以Unix元年(傳統的設定為UTC時區1970年1月1日午夜時分)開始所經歷的描述進行運算。

Duration 和 Period
Duration:用于計算兩個“時間”間隔。

Period:用于計算兩個“日期”間隔。

日期的操縱
TemporalAdjuster : 時間校正器。有時我們可能需要獲取例如：將日期調整到“下個周日”等操作。
TemporalAdjusters : 該類通過靜態方法提供了大量的常用 TemporalAdjuster 的實現。
例如獲取下個周日：

LocalDate nextSunday = LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.SUNDAY));

解析與格式化
java.time.format.DateTimeFormatter 類：該類提供了三種格式化方法：

• 預定義的標準格式
• 語言環境相關的格式
• 自定義的格式

時區的處理
Java8 中加入了對時區的支持，帶時區的時間為分別為：ZonedDate、 ZonedTime、ZonedDateTime

其中每個時區都對應著 ID，地區ID都為 “{區域}/{城市}”的格式
例如 ： Asia/Shanghai 等

ZoneId：該類中包含了所有的時區信息
getAvailableZoneIds() : 可以獲取所有時區時區信息
of(id) : 用指定的時區信息獲取 ZoneId 對象

與傳統日期處理的轉換

public class TestLocalDateTime {//6.ZonedDate、ZonedTime、ZonedDateTime ： 帶時區的時間或日期@Testpublic void test7(){LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));System.out.println(ldt);ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Pacific"));System.out.println(zdt);}@Testpublic void test6(){Set<String> set = ZoneId.getAvailableZoneIds();set.forEach(System.out::println);}//5. DateTimeFormatter : 解析和格式化日期或時間@Testpublic void test5(){ // DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE;DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");LocalDateTime ldt = LocalDateTime.now();String strDate = ldt.format(dtf);System.out.println(strDate);LocalDateTime newLdt = ldt.parse(strDate, dtf);System.out.println(newLdt);}//4. TemporalAdjuster : 時間校正器@Testpublic void test4(){LocalDateTime ldt = LocalDateTime.now();System.out.println(ldt);LocalDateTime ldt2 = ldt.withDayOfMonth(10);System.out.println(ldt2);LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));System.out.println(ldt3);//自定義：下一個工作日LocalDateTime ldt5 = ldt.with((l) -> {LocalDateTime ldt4 = (LocalDateTime) l;DayOfWeek dow = ldt4.getDayOfWeek();if(dow.equals(DayOfWeek.FRIDAY)){return ldt4.plusDays(3);}else if(dow.equals(DayOfWeek.SATURDAY)){return ldt4.plusDays(2);}else{return ldt4.plusDays(1);}});System.out.println(ldt5);}//3.//Duration : 用于計算兩個“時間”間隔//Period : 用于計算兩個“日期”間隔@Testpublic void test3(){Instant ins1 = Instant.now();System.out.println("--------------------");try {Thread.sleep(1000);} catch (InterruptedException e) {}Instant ins2 = Instant.now();System.out.println("所耗費時間為：" + Duration.between(ins1, ins2));System.out.println("----------------------------------");LocalDate ld1 = LocalDate.now();LocalDate ld2 = LocalDate.of(2011, 1, 1);Period pe = Period.between(ld2, ld1);System.out.println(pe.getYears());System.out.println(pe.getMonths());System.out.println(pe.getDays());}//2. Instant : 時間戳。 （使用 Unix 元年 1970年1月1日 00:00:00 所經歷的毫秒值）@Testpublic void test2(){Instant ins = Instant.now(); //默認使用 UTC 時區System.out.println(ins);OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8));System.out.println(odt);System.out.println(ins.getNano());Instant ins2 = Instant.ofEpochSecond(5);System.out.println(ins2);}//1. LocalDate、LocalTime、LocalDateTime@Testpublic void test1(){LocalDateTime ldt = LocalDateTime.now();System.out.println(ldt);LocalDateTime ld2 = LocalDateTime.of(2016, 11, 21, 10, 10, 10);System.out.println(ld2);LocalDateTime ldt3 = ld2.plusYears(20);System.out.println(ldt3);LocalDateTime ldt4 = ld2.minusMonths(2);System.out.println(ldt4);System.out.println(ldt.getYear());System.out.println(ldt.getMonthValue());System.out.println(ldt.getDayOfMonth());System.out.println(ldt.getHour());System.out.println(ldt.getMinute());System.out.println(ldt.getSecond());} }

6. 接口中的默認方法與靜態方法

接口中的默認方法

Java 8中允許接口中包含具有具體實現的方法，該方法稱為“默認方法”，默認方法使用 default 關鍵字修飾。

例如：

interface MyFun<T>{T func(int a);default String getName(){return "hello java8!";} }

接口默認方法的” 類優先” 原則
若一個接口中定義了一個默認方法，而另外一個父類或接口中又定義了一個同名的方法時：
1. 選擇父類中的方法。如果一個父類提供了具體的實現，那么接口中具有相同名稱和參數的默認方法會被忽略。
2. 接口沖突。如果一個父接口提供一個默認方法，而另一個接口也提供了一個具有相同名稱和參數列表的方法（不管方法是否是默認方法）， 那么必須覆蓋該方法來解決沖突。

代碼演示：

interface MyFunc{default String getName(){return "hello java8!";} }interface Named{default String getName(){return "hello world!";} }class MyClass implements MyFunc, Named{@Overridepublic String getName() {// TODO Auto-generated method stubreturn Named.super.getName();//如果覆蓋MyFunc接口方法，則為MyFunc.super.getName();} }

接口中的靜態方法

Java8 中，接口中允許添加靜態方法。

例如：

interface Named{public Integer myFun();default String getName(){return "hello world!";}static void show(){System.out.println("hello Lambda!");} } public class TestDefaultInterface {public static void main(String[] args) {SubClass sc = new SubClass();System.out.println(sc.getName());MyInterface.show();} }

7. 其他新特性

Optional 類

Optional<T> 類(java.util.Optional) 是一個容器類，代表一個值存在或不存在，原來用 null 表示一個值不存在，現在 Optional 可以更好的表達這個概念。并且可以避免空指針異常。

常用方法：
Optional.of(T t) : 創建一個 Optional 實例
Optional.empty() : 創建一個空的 Optional 實例
Optional.ofNullable(T t):若 t 不為 null,創建 Optional 實例,否則創建空實例
isPresent() : 判斷是否包含值
orElse(T t) : 如果調用對象包含值，返回該值，否則返回t
orElseGet(Supplier s) :如果調用對象包含值，返回該值，否則返回 s 獲取的值
map(Function f): 如果有值對其處理，并返回處理后的Optional，否則返回 Optional.empty()
flatMap(Function mapper):與 map 類似，要求返回值必須是Optional

Man類：

public class Man {private Godness god;public Man() {}public Man(Godness god) {this.god = god;}public Godness getGod() {return god;}public void setGod(Godness god) {this.god = god;}@Overridepublic String toString() {return "Man [god=" + god + "]";} }

Godness類：

public class Godness {private String name;public Godness() {}public Godness(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Godness [name=" + name + "]";} }

NewMan類：

//注意：Optional 不能被序列化 public class NewMan {private Optional<Godness> godness = Optional.empty();private Godness god;public Optional<Godness> getGod(){return Optional.of(god);}public NewMan() {}public NewMan(Optional<Godness> godness) {this.godness = godness;}public Optional<Godness> getGodness() {return godness;}public void setGodness(Optional<Godness> godness) {this.godness = godness;}@Overridepublic String toString() {return "NewMan [godness=" + godness + "]";} }

測試：

/** 一、Optional 容器類：用于盡量避免空指針異常* Optional.of(T t) : 創建一個 Optional 實例* Optional.empty() : 創建一個空的 Optional 實例* Optional.ofNullable(T t):若 t 不為 null,創建 Optional 實例,否則創建空實例* isPresent() : 判斷是否包含值* orElse(T t) : 如果調用對象包含值，返回該值，否則返回t* orElseGet(Supplier s) :如果調用對象包含值，返回該值，否則返回 s 獲取的值* map(Function f): 如果有值對其處理，并返回處理后的Optional，否則返回 Optional.empty()* flatMap(Function mapper):與 map 類似，要求返回值必須是Optional*/ public class TestOptional {@Testpublic void test4(){Optional<Employee> op = Optional.of(new Employee(101, "張三", 18, 9999.99));Optional<String> op2 = op.map(Employee::getName);System.out.println(op2.get());Optional<String> op3 = op.flatMap((e) -> Optional.of(e.getName()));System.out.println(op3.get());}@Testpublic void test3(){Optional<Employee> op = Optional.ofNullable(new Employee());if(op.isPresent()){System.out.println(op.get());}Employee emp = op.orElse(new Employee("張三"));System.out.println(emp);Employee emp2 = op.orElseGet(() -> new Employee());System.out.println(emp2);}@Testpublic void test2(){/*Optional<Employee> op = Optional.ofNullable(null);System.out.println(op.get());*/// Optional<Employee> op = Optional.empty(); // System.out.println(op.get());}@Testpublic void test1(){Optional<Employee> op = Optional.of(new Employee());Employee emp = op.get();System.out.println(emp);}@Testpublic void test5(){Man man = new Man();String name = getGodnessName(man);System.out.println(name);}//需求：獲取一個男人心中女神的名字public String getGodnessName(Man man){if(man != null){Godness g = man.getGod();if(g != null){return g.getName();}}return "蒼老師";}//運用 Optional 的實體類@Testpublic void test6(){Optional<Godness> godness = Optional.ofNullable(new Godness("林志玲"));Optional<NewMan> op = Optional.ofNullable(new NewMan(godness));String name = getGodnessName2(op);System.out.println(name);}public String getGodnessName2(Optional<NewMan> man){return man.orElse(new NewMan()).getGodness().orElse(new Godness("蒼老師")).getName();} }

重復注解與類型注解

Java 8對注解處理提供了兩點改進：可重復的注解及可用于類型的注解。

總結

以上是生活随笔為你收集整理的Java8学习笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。