Java實戰 第2版

第一部分 基礎知識
第1章 Java 8、9、10以及11的變化　2
1.1　為什麼要關心Java的變化　2
1.2　Java怎麼還在變　4
1.2.1　Java在程式設計語言生態系統中的位置　5
1.2.2　流處理　6
1.2.3　用行為參數化把代碼傳遞給方法　7
1.2.4　並行與共用的可變資料　8
1.2.5　Java需要演變　9
1.3　Java中的函數　9
1.3.1　方法和Lambda作為一等值　10
1.3.2　傳遞代碼：一個例子　11
1.3.3　從傳遞方法到Lambda　13
1.4　流　14
1.5　預設方法及Java模組　17
1.6　來自函數式程式設計的其他好思想　19
1.7　小結　20

第2章 通過行為參數化傳遞代碼　22
2.1　應對不斷變化的需求　23
2.1.1　初試牛刀：篩選綠蘋果　23
2.1.2　再展身手：把顏色作為參數　23
2.1.3　第三次嘗試：對你能想到的每個屬性做篩選　24
2.2　行為參數化　25
2.3　對付囉唆　30
2.3.1　匿名類　30
2.3.2　第五次嘗試：使用匿名類　31
2.3.3　第六次嘗試：使用Lambda運算式　32
2.3.4　第七次嘗試：將List類型抽象化　33
2.4　真實的例子　33
2.4.1　用Comparator來排序　33
2.4.2　用Runnable執行代碼塊　34
2.4.3　通過Callable返回結果　35
2.4.4　GUI事件處理　35
2.5　小結　36

第3章 Lambda運算式　37
3.1　Lambda管中窺豹　37
3.2　在哪裡以及如何使用Lambda　40
3.2.1　函數式介面　40
3.2.2　函數描述符　42
3.3　把Lambda付諸實踐：環繞執行模式　44
3.3.1　第 1 步：記得行為參數化　44
3.3.2　第 2 步：使用函數式介面來傳遞行為　45
3.3.3　第 3 步：執行一個行為　45
3.3.4　第 4 步：傳遞Lambda　46
3.4　使用函數式介面　47
3.4.1　Predicate　47
3.4.2　Consumer　47
3.4.3　Function　48
3.5　類型檢查、類型推斷以及限制　52
3.5.1　類型檢查　52
3.5.2　同樣的Lambda，不同的函數式介面　53
3.5.3　類型推斷　55
3.5.4　使用區域變數　56
3.6　方法引用　57
3.6.1　管中窺豹　57
3.6.2　構造函數引用　60
3.7　Lambda和方法引用實戰　62
3.7.1　第 1 步：傳遞代碼　62
3.7.2　第 2 步：使用匿名類　62
3.7.3　第 3 步：使用Lambda運算式　62
3.7.4　第 4 步：使用方法引用　63
3.8　複合Lambda運算式的有用方法　63
3.8.1　比較器複合　64
3.8.2　謂詞複合　64
3.8.3　函數複合　65
3.9　數學中的類似思想　66
3.9.1　積分　66
3.9.2　與Java 8的Lambda聯繫起來　68
3.10　小結　68

第二部分 使用流進行函數式資料處理
第4章 引入流　72
4.1　流是什麼　72
4.2　流簡介　76
4.3　流與集合　78
4.3.1　只能遍歷一次　79
4.3.2　外部反覆運算與內部反覆運算　80
4.4　流操作　82
4.4.1　中間操作　83
4.4.2　終端操作　84
4.4.3　使用流　84
4.5　路線圖　85
4.6　小結　85

第5章 使用流　86
5.1　篩選　87
5.1.1　用謂詞篩選　87
5.1.2　篩選各異的元素　87
5.2　流的切片　88
5.2.1　使用謂詞對流進行切片　88
5.2.2　截短流　90
5.2.3　跳過元素　90
5.3　映射　91
5.3.1　對流中每一個元素應用函數　91
5.3.2　流的扁平化　92
5.4　查找和匹配　95
5.4.1　檢查謂詞是否至少匹配一個元素　95
5.4.2　檢查謂詞是否匹配所有元素　96
5.4.3　查找元素　96
5.4.4　查找第 一個元素　97
5.5　歸約　98
5.5.1　元素求和　98
5.5.2　最大值和最小值　100
5.6　付諸實踐　103
5.6.1　領域：交易員和交易　103
5.6.2　解答　104
5.7　數值流　106
5.7.1　原始類型流特化　107
5.7.2　數值範圍　108
5.7.3　數值流應用：勾股數　108
5.8　構建流　111
5.8.1　由值創建流　111
5.8.2　由可空對象創建流　111
5.8.3　由陣列創建流　112
5.8.4　由檔生成流　112
5.8.5　由函數生成流：創建無限流　113
5.9　概述　116
5.10　小結　116

第6章 用流收集資料　118
6.1　收集器簡介　119
6.1.1　收集器用作高級歸約　119
6.1.2　預定義收集器　120
6.2　歸約和匯總　121
6.2.1　查找流中的最大值和最小值　121
6.2.2　匯總　122
6.2.3　連接字串　123
6.2.4　廣義的歸約匯總　124
6.3　分組　127
6.3.1　操作分組的元素　128
6.3.2　多級分組　130
6.3.3　按子組收集資料　131
6.4　分區　134
6.4.1　分區的優勢　135
6.4.2　將數字按質數和非質數分區　136
6.5　收集器介面　138
6.5.1　理解Collector介面聲明的方法　139
6.5.2　全部融合到一起　143
6.6　開發你自己的收集器以獲得更好的性能　144
6.6.1　僅用質數做除數　145
6.6.2　比較收集器的性能　148
6.7　小結　150

第7章 並行資料處理與性能　151
7.1　並行流　152
7.1.1　將順序流轉換為並行流　52
7.1.2　測量流性能　154
7.1.3　正確使用並行流　158
7.1.4　高效使用並行流　159
7.2　分支/合併框架　161
7.2.1　使用RecursiveTask　161
7.2.2　使用分支/合併框架的最佳做法　164
7.2.3　工作竊取　165
7.3　Spliterator　166
7.3.1　拆分過程　167
7.3.2　實現你自己的Spliterator　168
7.4　小結　173

第三部分　使用流和Lambda進行高效程式設計
第8章 Collection API的增強功能　176
8.1　集合工廠　176
8.1.1　List工廠　177
8.1.2　Set工廠　178
8.1.3　Map工廠　179
8.2　使用List和Set　180
8.2.1　removeIf方法　180
8.2.2　replaceAll方法　181
8.3　使用Map　181
8.3.1　forEach方法　182
8.3.2　排序　182
8.3.3　getOrDefault方法　183
8.3.4　計算模式　183
8.3.5　刪除模式　184
8.3.6　替換模式　185
8.3.7　merge方法　185
8.4　改進的ConcurrentHashMap　187
8.4.1　歸約和搜索　187
8.4.2　計數　188
8.4.3　Set視圖　188
8.5　小結　188

第9章 重構、測試和調試　189
9.1　為改善可讀性和靈活性重構代碼　189
9.1.1　改善代碼的可讀性　190
9.1.2　從匿名類到Lambda運算式的轉換　190
9.1.3　從Lambda運算式到方法引用的轉換　191
9.1.4　從命令式的資料處理切換到Stream　193
9.1.5　增加代碼的靈活性　193
9.2　使用Lambda重構物件導向的設計模式　195
9.2.1　策略模式　196
9.2.2　範本方法　197
9.2.3　觀察者模式　198
9.2.4　責任鏈模式　201
9.2.5　工廠模式　202
9.3　測試Lambda運算式　204
9.3.1　測試可見Lambda函數的行為　204
9.3.2　測試使用Lambda的方法的行為　205
9.3.3　將複雜的Lambda運算式分為不同的方法　205
9.3.4　高階函數的測試　206
9.4　調試　206
9.4.1　查看棧跟蹤　206
9.4.2　使用日誌調試　208
9.5　小結　209

第10章 基於Lambda的領域特定語言　210
10.1　領域特定語言　212
10.1.1　DSL的優點和弊端　212
10.1.2　JVM中已提供的DSL解決方案　214
10.2　現代Java API中的小型DSL　217
10.2.1　把Stream API當成DSL去操作集合　219
10.2.2　將Collectors作為DSL匯總資料　220
10.3　使用Java創建DSL的模式與技巧　221
10.3.1　方法連結　224
10.3.2　使用嵌套函數　226
10.3.3　使用Lambda運算式的函數序列　228
10.3.4　把它們都放到一起　230
10.3.5　在DSL中使用方法引用　232
10.4　Java 8 DSL的實際應用　234
10.4.1　jOOQ　235
10.4.2　Cucumber　236
10.4.3　Spring Integration　238
10.5　小結　239

第四部分　無所不在的Java
第11章 用Optional取代null　242
11.1　如何為缺失的值建模　243
11.1.1　採用防禦式檢查減少NullPointerException　243
11.1.2　null帶來的種種問題　245
11.1.3　其他語言中null的替代品　245
11.2　Optional類入門　246
11.3　應用Optional的幾種模式　248
11.3.1　創建Optional對象　248
11.3.2　使用map從Optional物件中提取和轉換值　248
11.3.3　使用flatMap連結Optional物件　249
11.3.4　操縱由Optional物件構成的Stream　253
11.3.5　預設行為及解引用Optional對象　254
11.3.6　兩個Optional物件的組合　255
11.3.7　使用filter剔除特定的值　257
11.4　使用Optional的實戰示例　258
11.4.1　用Optional 封裝可能為null的值　259
11.4.2　異常與Optional的對比　259
11.4.3　基礎類型的Optional物件，以及為什麼應該避免使用它們　260
11.4.4　把所有內容整合起來　260
11.5　小結　262

第12章 新的日期和時間API　263
12.1　LocalDate、LocalTime、LocalDateTime、Instant、Duration以及Period　264
12.1.1　使用LocalDate和LocalTime　264
12.1.2　合併日期和時間　265
12.1.3　機器的日期和時間格式　266
12.1.4　定義Duration或Period　267
12.2　操縱、解析和格式化日期　268
12.2.1　使用TemporalAdjuster　270
12.2.2　列印輸出及解析日期–時間對象　272
12.3　處理不同的時區和曆法　274
12.3.1　使用時區　274
12.3.2　利用和UTC/格林尼治時間的固定偏差計算時區　275
12.3.3　使用別的日曆系統　276
12.4　小結　277

第13章 默認方法　278
13.1　不斷演進的API　280
13.1.1　初始版本的API　281
13.1.2　第二版API　281
13.2　概述默認方法　283
13.3　預設方法的使用模式　285
13.3.1　可選方法　285
13.3.2　行為的多繼承　286
13.4　解決衝突的規則　289
13.4.1　解決問題的三條規則　289
13.4.2　選擇提供了最具體實現的預設方法的介面　290
13.4.3　衝突及如何顯式地消除歧義　291
13.4.4　菱形繼承問題　293
13.5　小結　294

第14章 Java模組系統　295
14.1　模組化的驅動力：軟體的推理　295
14.1.1　關注點分離　295
14.1.2　信息隱藏　296
14.1.3　Java軟體　296
14.2　為什麼要設計Java模組系統　297
14.2.1　模組化的局限性　297
14.2.2　單體型的JDK　298
14.2.3　與OSGi的比較　299
14.3　Java模組：全域視圖　300
14.4　使用Java模組系統開發應用　301
14.4.1　從頭開始搭建一個應用　302
14.4.2　細細微性和粗細微性的模組化　303
14.4.3　Java模組系統基礎　303
14.5　使用多個模組　304
14.5.1　exports子句　304
14.5.2　requires子句　305
14.5.3　命名　306
14.6　編譯及打包　306
14.7　自動模組　310
14.8　模組聲明及子句　311
14.8.1　requires　311
14.8.2　exports　311
14.8.3　requires的傳遞　311
14.8.4　exports to　312
14.8.5　open和opens　312
14.8.6　uses和provides　313
14.9　通過一個更複雜的例子瞭解更多　313
14.10　小結　314

第五部分　提升Java的併發性
第15章 CompletableFuture及反應式程式設計背後的概念　316
15.1　為支持併發而不斷演進的Java　318
15.1.1　執行緒以及更高層的抽象　319
15.1.2　執行器和執行緒池　320
15.1.3　其他的執行緒抽象：非嵌套方法調用　322
15.1.4　你希望執行緒為你帶來什麼　324
15.2　同步及非同步API　324
15.2.1　Future風格的API　326
15.2.2　反應式風格的API　327
15.2.3　有害的睡眠及其他阻塞式操作　328
15.2.4　實戰驗證　329
15.2.5　如何使用非同步API進行異常處理　330
15.3　“線框–管道”模型　331
15.4　為併發而生的CompletableFuture和結合器　332
15.5　“發佈–訂閱”以及反應式程式設計　335
15.5.1　示例：對兩個流求和　337
15.5.2　背壓　341
15.5.3　一種簡單的真實背壓　341
15.6　反應式系統和反應式程式設計　342
15.7　路線圖　342
15.8　小結　343

第16章 CompletableFuture：組合式非同步程式設計　344
16.1　Future介面　344
16.1.1　Future介面的局限性　346
16.1.2　使用CompletableFuture構建非同步應用　346
16.2　實現非同步API　347
16.2.1　將同步方法轉換為非同步方法　348
16.2.2　錯誤處理　350
16.3　讓你的代碼免受阻塞之苦　352
16.3.1　使用並行流對請求進行平行作業　353
16.3.2　使用CompletableFuture發起非同步請求　353
16.3.3　尋找更好的方案　355
16.3.4　使用定制的執行器　356
16.4　對多個非同步任務進行流水線操作　358
16.4.1　實現折扣服務　358
16.4.2　使用Discount服務　359
16.4.3　構造同步和非同步作業　360
16.4.4　將兩個CompletableFuture物件整合起來，無論它們是否存在依賴　363
16.4.5　對Future和Completable-Future 的回顧　364
16.4.6　高效地使用超時機制　365
16.5　回應CompletableFuture的completion事件　366
16.5.1　對最佳價格查詢器應用的優化　367
16.5.2　付諸實踐　368
16.6　路線圖　369
16.7　小結　369

第17章 反應式程式設計　370
17.1　反應式宣言　371
17.1.1　應用層的反應式程式設計　371
17.1.2　反應式系統　373
17.2　反應式流以及Flow API　373
17.2.1　Flow類　374
17.2.2　創建你的第 一個反應式應用　377
17.2.3　使用Processor轉換資料　381
17.2.4　為什麼Java並未提供Flow API的實現　383
17.3　使用反應式庫RxJava　384
17.3.1　創建和使用Observable　385
17.3.2　轉換及整合多個Observable　392

第六部分　函數式程式設計以及Java未來的演進
第18章 函數式的思考　396
18.1　實現和維護系統　396
18.1.1　共用的可變資料　397
18.1.2　聲明式程式設計　398
18.1.3　為什麼要採用函數式程式設計　399
18.2　什麼是函數式程式設計　399
18.2.1　函數式Java程式設計　400
18.2.2　引用透明性　402
18.2.3　物件導向的程式設計和函數式程式設計的對比　402
18.2.4　函數式程式設計實戰　403
18.3　遞迴和反覆運算　405
18.4　小結　408

第19章 函數式程式設計的技巧　409
19.1　無處不在的函數　409
19.1.1　高階函數　410
19.1.2　柯裡化　411
19.2　持久化資料結構　412
19.2.1　破壞式更新和函數式更新的比較　413
19.2.2　另一個使用Tree的例子　415
19.2.3　採用函數式的方法　416
19.3　Stream的延遲計算　418
19.3.1　自訂的Stream　418
19.3.2　創建你自己的延遲列表　420
19.4　模式匹配　425
19.4.1　訪問者模式　425
19.4.2　用模式匹配力挽狂瀾　426
19.5　雜項　429
19.5.1　緩存或記憶表　429
19.5.2　“返回同樣的物件”意味著什麼　430
19.5.3　結合器　431
19.6　小結　432

第20章 物件導向和函數式程式設計的混合：Java和Scala的比較　433
20.1　Scala簡介　434
20.1.1　你好，啤酒　434
20.1.2　基礎資料結構：List、Set、Map、Tuple、Stream以及Option　436
20.2　函數　440
20.2.1　Scala中的一等函數　441
20.2.2　匿名函數和閉包　442
20.2.3　柯裡化　443
20.3　類和trait　444
20.3.1　更加簡潔的Scala類　445
20.3.2　Scala的trait與Java 8的介面對比　446
20.4　小結　447

第21章 結論以及Java的未來　448
21.1　回顧Java 8的語言特性　448
21.1.1　行為參數化（Lambda以及方法引用）　449
21.1.2　流　449
21.1.3　CompletableFuture　450
21.1.4　Optional　450
21.1.5　Flow API　451
21.1.6　默認方法　451
21.2　Java 9的模組系統　451
21.3　Java 10的區域變數類型推斷　453
21.4　Java的未來　454
21.4.1　聲明處型變　454
21.4.2　模式匹配　454
21.4.3　更加豐富的泛型形式　455
21.4.4　對不變性的更深層支持　457
21.4.5　數值型別　458
21.5　讓Java發展得更快　461
21.6　寫在最後的話　462
附錄A　其他語言特性的更新　463
附錄B　其他類庫的更新　467
附錄C　如何以併發方式在同一個流上執行多種操作　475
附錄D　Lambda運算式和JVM位元組碼　483