javalambdathis

A. 如何在android mole中使用java 8的新特性，比如Lambda

概述

lambda和Stream表達式是java8引入的新特性，要理解lambda表達式，其中最重要的概念就是函數式介面（functional interface），而在Android中有很多這種介面，如點擊事件OnclickListener等。簡單來說，函數式介面是只包含一個抽象方法的介面。比如Java標准庫中的java.lang.Runnable和java.util.Comparator都是典型的函數式介面。

來看一下lanbda語法，以java.util.Comparator介面為例

使用Rxjava的朋友，肯定對這種語法很熟悉。lanbda更多特性參照
Java 8 Tutorial

retrolambda

在android 中磨人是不支持java8的，那麼該如何使用呢，在android中我們必須藉助一個插件retrolambda@[Github]，該插件將Java8中的lambda表達式特性兼容到java 5。
引入步驟

download and install java8

在project的build.gradle中加入

classpath 'me.tatarka:gradle-retrolambda:3.2.0'11

完整代碼：

buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:1.2.3'
classpath 'me.tatarka:gradle-retrolambda:3.2.0'
}
}

allprojects {
repositories {
jcenter()
}
}

在mole的build.gradle中使用插件

apply plugin: 'me.tatarka.retrolambda'11

在android節點下加入環境支持

android｛
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
｝123456123456

完整代碼：

apply plugin: 'com.android.application'
apply plugin: 'me.tatarka.retrolambda'
android {
compileSdkVersion 22
buildToolsVersion "22.0.1"

defaultConfig {
applicationId "com.bobomee.android.lambda.sample"
minSdkVersion 15
targetSdkVersion 22
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}

dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'com.android.support:appcompat-v7:22.2.0'

}

Stream

同時Stream API讓我們對於集合的操作也變得十分的簡潔

Stream.of(/* array | list | set | map | anything based on Iterator/Iterable interface */)
.filter(..)
.map(..)
...
.sorted()
.forEach(..);
Stream.of(value1, value2, value3)...
Stream.ofRange(0, 10)...1234567812345678

具體可參考：Lightweight-Stream-API@[Github]
Java 8 Stream on Android

測試

imageView.post(()-> Toast.makeText(this,"lambda-test",Toast.LENGTH_LONG).show()); 11

這里模擬了Runnable介面，如果打出toast，則說明引入成功了，否則clean或者同步一下工程即可。

B. jdk1.8 新增了哪些功能

一、lambda含義
lambda表示數學符號「λ」，計算機領域中λ代表「λ演算」，表達了計算機中最基本的概念：「調用」和「置換」。在很多動態語言和C#中都有相應的lambda語法，這類語法都為了簡化代碼，提高運行效率。

二、lambda 項目的背景，參考這里。
無論是面向對象語言還是函數式語言，基本數值都可以被動態的封裝入程序動作：面向對象語言通過「方法」，函數式語言通過「函數。
介於「方法」和「函數」的定義有很多種，補充下IBM知識庫的解釋：
在面向對象語言中，方法不是一階值（First-class value），在函數式語言中，函數是一階值。在函數式語言中，函數可以作為另一個函數的返回值或參數，還可以作為一個變數的值，函數可以嵌套定義，而在面向對象語言中的的「方法」做不到這點。
Java可以說是面向對象語言的代表，如果要調用其方法，需要先創建對象。不過Java對象都是「重量級」的，實例化具體的類的對象，需要經過定義和申明兩個階段。比如定義方法，並給內部欄位賦初始值。但是一個對象只包含一個方法的情況很多，比如實現API中的「回調介面」功能的類，在swing中有介面：

Java代碼

<span><span><span style="">public interface ActionListener {

void actionPerformed(ActionEvent e);

}</span></span></span>

現有的實現方式大多是：

Java代碼

<span><span><span style="">button.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

ui.dazzle(e.getModifiers());

}

});</span></span></span>

很多現有的類庫都基於這種設計實現，所以對於代碼被明確定義運行在單獨線程的API來說，匿名內部類尤為重要。這些匿名內部類只存在於創建它的線程中。但是在並行計算領域，CPU的製造商著力發展多核技術來提升CPU的功能，這么做幾乎無法依靠多核的優勢來提升其性能。

鑒於回調函數和其他功能式語法的關系越來越密切，所以必須建立盡可能的輕量級的數據模型（從編碼角度而言，性能方面下文再說）。對於這點來說匿名內部類的缺點如下：
1. 語法相對復雜。
2. 在調用內部類的上下文中，指引和this的指代容易混淆。
3. 類載入和實例創建語法不可避免。
4. 不能引用外部的非final對象。
5. 不能抽象化控制流程

針對這些問題，lambda項目致力於
1. 消除問題1和問題2，通過引入更簡單的表達式和局部變數的定義規則。
2. 迴避問題3，定義更靈活更友善的語法。這里只是迴避，類載入和實例化本身不可避免。下文會解釋。
3. 改善問題4，允許用戶使用最終有效的局部變數。

不過lambda項目目前並不能解決所有關於內部類的問題。問題4和問題5沒有完全解決，這計劃在將類版本中繼續改善。對於性能方面，原文也沒有提，不過後面有些補充。

三、lambda用法
通過上文可以了解到，lambda語法是針對「回調介面」和「匿名內部類」作出的改進，所以lambda的語法目前僅對於部分介面，這些介面的特點是只含一個抽象方法，在lambda項目中，早期稱為SAM類型(SAM = single abstract method 即單一抽象方法)。在最新的文檔中(即這個版本)，它們有了新名字，叫函數介面（functional interface)，比如：

1 java.lang.Runnable

2 java.util.concurrent.Callable

3 java.security.PrivilegedAction

4 java.util.Comparator

5 java.io.FileFilter

6 java.nio.file.PathMatcher

7 java.lang.reflect.InvocationHandler

8 java.beans.PropertyChangeListener

9 java.awt.event.ActionListener

10 javax.swing.event.ChangeListener

lambda的語法包括三部分

1、參數列表

2、箭頭符號"->"

3、代碼塊。

其中代碼塊很像一個方法體，return語句將控制權交還給匿名方法(anonymous method，即lambda表達式)的調用者；break和continue不能出現在函數體的頂部，不過可以出現在內部的循環里；如果代碼塊得出最終結果，那麼每一個控制路徑(control path) 必須都有返回或拋出異常。
如果代碼塊只有簡單一行，可以省略return關鍵字和「{}」符號(以下所寫的例子都是基於JDK 1.8 lambda預覽版)，比如：

Java代碼

<span><span><span style="">public class LambdaTest {

public static void main(String... args) {

//這里有{}和return 以及 ;

Runnable r = () -> { System.out.println("hello world"); };

//這里不需要{}和return

java.util.Comparator<String> c = (String s1, String s2) -> s2.length()-s1.length();

r.run();

System.out.println(c.compare("s1", "12323"));

}

}</span></span></span>

輸出為：
hello world
3

除了這些現有介面，我們還可以自定義函數介面：

Java代碼

<span><span><span style="">public class LambdaTest {

interface lambdaInterface {

public void me(String str);

}

public static void main(String... args) {

lambdaInterface li = (String s)->{System.out.println(s);};

li.me("hello world!");

}

}</span></span></span>
輸出為：

hello world!

新的lambda方法從語法上的確是簡化了很多。和lambda第一次發布的語法相比也優雅很多。

四、lambda代碼塊的位元組碼

看完了語法的確很簡單，那麼lambda是怎麼實現的，就得從位元組碼考察了。這里和匿名內部類做個對比，編譯如下代碼：

Java代碼

<span><span><span style="">public class LambdaTest {

lambdaInterface li1 = ()->{System.out.println(this);};

lambdaInterface li2 = new lambdaInterface(){

public void me(){

System.out.println(this);

}

};

public static void main(String... args) {

LambdaTest lt = new LambdaTest();

lt.li1.me();

lt.li2.me();

}

}

interface lambdaInterface {

public void me();

}</span></span></span>
編譯後有會有四個文件：

LambdaTest.class
LambdaTest$1.class
LambdaTest$2.class
lambdaInterface.class

它的的輸出結果為：
LambdaTest@200bde
LambdaTest$1@1eb41d6
結果很明顯地顯示，lambda代碼塊和內部類的this的指引是不一樣的。lambda代碼塊輸出的是調用者的this，即lambdaTest.class的實例。匿名內部類輸出的是自己lambdaTest$1.class的實例。

先看看lambdaTest.class的位元組碼：

Txt代碼

<span><span><span style="">public class LambdaTest {

lambdaInterface li1;

lambdaInterface li2;

public LambdaTest();

Code:

0: aload_0

1: invokespecial #1 // Method java/lang/Object."<init>":()V

4: aload_0

5: new #2 // class LambdaTest$2

8: p

9: aload_0

10: aload_0

11: invokespecial #3 // Method LambdaTest$2."<init>":(LLambdaTest;LLambdaTest;)V

14: putfield #4 // Field li1:LlambdaInterface;

17: aload_0

18: new #5 // class LambdaTest$1

21: p

22: aload_0

23: invokespecial #6 // Method LambdaTest$1."<init>":(LLambdaTest;)V

26: putfield #7 // Field li2:LlambdaInterface;

29: return

public static void main(java.lang.String...);

Code:

0: new #8 // class LambdaTest

3: p

4: invokespecial #9 // Method "<init>":()V

7: astore_1

8: aload_1

9: getfield #4 // Field li1:LlambdaInterface;

12: invokeinterface #10, 1 // InterfaceMethod lambdaInterface.me:()V

17: aload_1

18: getfield #7 // Field li2:LlambdaInterface;

21: invokeinterface #10, 1 // InterfaceMethod lambdaInterface.me:()V

26: return

}</span></span></span>

從這里可以看出，lambda代碼塊和匿名內部類的調用方法是一樣的，都是先創建一個方法，然後創建其句柄，這兩個句柄分別對應lambdaTest$2.class和lambdaTest$1.class。
其中匿名內部類對應LambdaTest$1，它的位元組碼為：

Txt代碼

<span><span><span style="">class LambdaTest$1 implements lambdaInterface {

final LambdaTest this$0;

LambdaTest$1(LambdaTest);

Code:

0: aload_0

1: aload_1

2: putfield #1 // Field this$0:LLambdaTest;

5: aload_0

6: invokespecial #2 // Method java/lang/Object."<init>":()V

9: return

public void me();

Code:

0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;

3: aload_0

4: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V

7: return

}</span></span></span>

lambda代碼塊對應LambdaTest$2，它的位元組碼為：

Txt代碼

<span><span><span style="">class LambdaTest$2 implements lambdaInterface {

LambdaTest encl$0;

final LambdaTest this$0;

LambdaTest$2(LambdaTest, LambdaTest);

Code:

0: aload_0

1: aload_1

2: putfield #1 // Field this$0:LLambdaTest;

5: aload_0

6: invokespecial #2 // Method java/lang/Object."<init>":()V

9: aload_0

10: aload_2

11: putfield #3 // Field encl$0:LLambdaTest;

14: return

public void me();

Code:

0: getstatic #4 // Field java/lang/System.out:Ljava/io/PrintStream;

3: aload_0

4: getfield #3 // Field encl$0:LLambdaTest;

7: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V

10: return

}

</span></span></span>
從它們的位元組碼可以很明顯的看出，lambda代碼塊的位元組碼在初始化時多了putfield指令，在me()運行時，有getfield指令。從解釋Field encl$0:LLambdaTest;中可以知道這步驟就是LambdaTest實例引用的入棧和出棧，所以lambda的代碼塊的this的引用是其調用者LambdaTest.class，這里和匿名內部類不一樣。相比較而言，lambda代碼塊對this的引用更精準。

至此lambda項目的前兩個目標已經完成。即簡化語法，和明確對象指引。

五、lamdab的性能

在JDK1.7中，引入了虛擬機新指令，invokedynamic（有點函數指針的味道），將用於支持lambda項目，具體可以參考Rémi Forax 的博客。

但是目前javap指令還不能直生成帶有invokedynamic指令的位元組碼，不過可以通過別的工具來實現，可以參考周志明的文章。這里引用引用周志明的說明，簡單的解釋如下（詳細的請看他的文章）：

每一處含有invokedynamic指令的位置都被稱作「動態調用點（Dynamic Call Site）」，這條指令的第一個參數不再是代表方法符號引用的CONSTANT_Methodref_info常量，而是變為JDK 7新加入的CONSTANT_InvokeDynamic_info常量，從這個新常量中可以得到3項信息：引導方法（Bootstrap Method，此方法存放在新增的BootstrapMethods屬性中）、方法類型（MethodType）和名稱。引導方法是有固定的參數，並且返回值是java.lang.invoke.CallSite對象，這個代表真正要執行的目標方法調用。根據CONSTANT_InvokeDynamic_info常量中提供的信息，虛擬機可以找到並且執行引導方法，從而獲得一個CallSite對象，最終調用要執行的目標方法上。

換句話說就是在虛擬機內部加入了類似C的函數指針功能。從以上的例子中可以看出，目前lambda的代碼塊是按照匿名內部類的方式進行工作的，即：內部類+方法句柄，那麼虛擬機工作的第一步是載入內部類，再調用對應方法，如果使用過於平頻繁，那麼內部類的new動作開銷就比較大了。在invokedynamic指令的幫助下，可以直接調用lambda所對應的方法，而不用創建內部類，這樣就避免了「內部類」所帶來的載入等問題。目前從lambda的話題庫來看是這么解釋invokedynamic如何工作和優勢的。
在lamdba項目的說明中已經明確表示，在預覽版中將lamdba代碼塊編譯成內部類的形式是暫時的。最終將採用invokedynamic指令來實現，即提升性能的部分最終是invokedynamic指令對函數介面的支持行能力來提升。

C. android如何使用lambda表達式

在Java8之前，Java並不支持Lambda表達式，而Android目前最新也才支持到Java7特性，所以在Android中使用Lambda表達式需要進行一些處理，將Lambda表達式編譯成Android可以「理解」的方式。
Retrolambda是一個能夠讓我們在Java7中使用Lambda的工具，再通過gradle-retrolambda插件，在gradle編譯過程中將會：
將Java8中的 javac編譯 Java8的代碼；
將產生的Java8的位元組碼轉換為Java6的位元組碼；
重新打包class。
build.gradle配置文件如下：
buildscript {
repositories {
mavenCentral()
maven {
url "https://oss.sonatype.org/content/repositories/snapshots"
}
}
dependencies {
classpath 'me.tatarka:gradle-retrolambda:1.2.+'
}
}
// Required because retrolambda is on maven central
repositories {
mavenCentral()
}
apply plugin: 'android'
apply plugin: 'retrolambda'
也可以添加如下設置：
retrolambda {
jdk System.getenv("JAVA8_HOME")
javaVersion JavaVersion.VERSION_1_6
}
android {
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
從此以後，
strings.map(new Func1<String, Integer>() {
@Override
public Integer call(String s) {
return s.length();
}
});
可以寫作：
strings.map((String s) -> {
return s.length();
});
至於詳細的bytecode轉換過程，有興趣的同志們可以自己研究研究。

D. Java 8的新特性lambda表達式是否比匿名內部類具有更好的可讀性

對於大多數剛剛接觸jdk8的同學來說，應該都會認為lambda表達式其實就是匿名內部類的語法糖(包括我自己，在剛剛接觸的時候，也是這樣認為的)，但實際上二者還是存在不少差異，其中最主要的兩點就是標識性和作用域。

首先，內部類在創建表達式時，會確保創建一個擁有唯一標識的新對象，而對於lambda，其計算結果（其實就是一個映射的過程）可能有也可能沒有唯一標識，這取決於具體實現。
其次，內部類的聲明會創建出一個新的命名作用域，在這個作用域中，this與super指向內部類本身的當前實例；但是lambda恰恰相反，它不會引入任何新的命名環境，這樣就避免了內部類名稱查找的復雜性，名稱查找會導致很多問題，比如想要調用外圍實例的方法時卻錯誤的調用了內部類實例的Object方法。

E. 為什麼 Kotlin 調用 java 時可以使用 Lambda

1. Kotlin 中的 Lambda 表達式

如果你已經開始使用 Koltin， 或者對它有過一些了解的話，那麼一定對這種寫法並不陌生了：

// 代碼一：Kotlin 代碼view.setOnClickListener{
println("click")
}1234

它跟下面這段 Java 代碼是等價的：

// 代碼二：java 代碼view.setOnClickListener(new View.OnClickListener() { @Override
public void onClick(View v) {
System.out.println("click");
}
});1234567

和 Java8 一樣，Kotlin 是支持 Lambda 表達式的，如代碼一所示，就是 Lambda 的一個具體應用。

可見，使用 lambda 減少了很多冗餘，使代碼寫起來更簡潔優雅，讀起來也更順暢自然了。

但是，你有沒有想過，為什麼 Kotlin 可以這樣寫，這里為什麼可以使用 lambda ？

2. 為什麼可以這么寫？

在 Kotlin 中，一個 Lambda 就是一個匿名函數。

代碼一其實是對下面代碼三的簡寫：

// 代碼三：Kotlin 代碼view.setOnClickListener({
v -> println("click")
})1234

之所以簡寫成代碼一的樣子，是基於這兩點特性：

• 如果 lambda 是一個函數的唯一參數，那麼調用這個函數時可以省略圓括弧

• 如果 lambda 所表示的匿名函數只有一個參數，那麼可以省略它的聲明以及->符號（默認會用it來給省略的參數名命名）

OK，從代碼三的結構中，能夠更清晰的看出，這里的 view.setOnClickListener 函數是接收了一個 lambda 作為參數。而在 Kotlin 中，什麼樣的函數才能把lambda（也即另一個函數）作為參數呢？
—— 對，就是高階函數。

什麼是高階函數？

高階函數是將函數用作參數或返回值的函數。

這是 Kotlin 和 Java 的區別之一，java 中並沒有高階函數的支持（java8是有高階函數的）。當我們在 java 中需要用到類似的概念時，通常的做法是傳遞一個匿名類作為參數，然後實現其中的某些抽象方法 —— 就比如上面的代碼二。

事實上，如果在 Android Studio 中，從 Kotlin 的代碼查看 view.setOnClickListener 函數的定義，就會發現，看到的函數簽名就是一個高階函數的定義：





o(╯□╰)o

這種情況比較吊軌，但是還有有可能會出現的。這時候，如果在 Kotlin 中直接使用代碼一類似的方式，就會報錯了：

• // 代碼六：kotlin中調用，這段代碼是編譯不過的TestSAM().setSam {


• println("dodo")


• }1234



會提示這里歧義，編譯器不知道這個 Lambda 代表是 SamType1 跟 SamType2 中的哪一個介面。

解決的辦法就是手動標明 Lambda 需要代替的介面類型，有兩種方式可以來標明：

• // 代碼七： 歧義消除// 方式一TestSAM().setSam (SamType1 { println("dodo") })


• // 方式二TestSAM().setSam ({ println("dodo") } as SamType1)12345



當然，也還有一種方法是不再使用 SAM 轉換的機制，而是直接使用一個 SamType1 的實例作為參數：

• // 代碼八： 使用一個實現介面的匿名類作為參數TestSAM().setSam(object : TestSAM.SamType1 { override fun doSomething(value: Int) {


• println("dodo")


• }


• })123456



這種方法當然也是可以的，只是跟 lambda 相比起來，就顯得不那麼優雅了（優雅很重要！！！）。

5. SAM 轉換的限制

SAM 轉換的限制主要有兩點 ：

5.1 只支持 java

即只適用與 Kotlin 中對 java 的調用，而不支持對 Kotlin 的調用

官方的解釋是 Kotlin 本身已經有了函數類型和高階函數等支持，所以不需要了再去轉換了。

如果你想使用類似的需要用 lambda 做參數的操作，應該自己去定義需要指定函數類型的高階函數。

5.2 只支持介面，不支持抽象類。

這個官方沒有多做解釋。

我想大概是為了避免混亂吧，畢竟如果支持抽象類的話，需要做強轉的地方就太多了。而且抽象類本身是允許有很多邏輯代碼在內部的，直接簡寫成一個 Lambda 的話，如果出了問題去定位錯誤的難度也加大了很多。

6. 總結

OK，講完了。
總結起來就是SAM 轉換就是 kotlin 在調用 java 代碼時能使用 Lambda 的原因。了解了其原理，能夠讓我們在寫代碼更自如，在偶爾出問題的時候也能更好更快地解決。

F. java課程分享初學者怎樣學習JAVA

Java入門是很簡單的，但是學習的前提是是否感興趣，能不能吃苦。有句話說的對「吃得苦中苦方為人上人」。和我們學習英語一樣，你努力了，不可能一點都不會，學習Java也同意是如此。java課程http://www.kmbdqn.com/認為努力才會有收獲！

初學者怎樣學習JAVA：

1．首先你要學習使用一些較為基礎的操作：如熟練使用一種 IDE、熟悉 Linux 開發環境和 bash shell等等；

2.從學習代碼規范上說：面向對象的知識、JAVA語法、JSP、HTML、JS及CSS、WebServer、開發工具以及熟悉至少一種框架，都是必不可少的學習內容。

了解了需要學習的知識點後，更重要的是該如何學習。

Java入門基礎

基礎語法：1 HelloWorld、2 常量、3 變數、4 數據類型、5 運算符、6 方法、7 流程式控制制語句、8 IDEA使用、9 數組

面向對象：1 類、2 對象、3 封裝、繼承、多態、4 構造器、5super、this、6 介面、抽象類、7 許可權修飾符、8 內部類、9 Random、ArrayList、String、Arrays、Math

常用API：1 Date、2 DateFormat、3 Calendar、4 System、5 StringBuilder

集合API1 Collection、2 泛型、3 List、4 Set、5 Collections、6 Map、7 HashMap

異常：1 異常體系、2 異常分類、3 聲明拋出捕獲異常、4 自定義異常

多線程：1 線程概念、2 線程同步、3 Lock、4 線程生命周期、5 線程池

Lambda表達式：1 函數式思想概述、2 Lambda標准格式、3 Lambda語法與注意事項

IO流：1 文件、2 位元組流、字元流、3 轉換流、高效流

G. jdk1.7和jdk1.8區別

在JDK1.7的新特性方面主要有下面幾方面的增強：
1.jdk7語法上
1.1二進制變數的表示,支持將整數類型用二進制來表示，用0b開頭。
1.2 Switch語句支持string類型
1.3 Try-with-resource語句
注意：實現java.lang.AutoCloseable介面的資源都可以放到try中，跟final裡面的關閉資源類似； 按照聲明逆序關閉資源 ;Try塊拋出的異常通過Throwable.getSuppressed獲取
1.4 Catch多個異常 說明：Catch異常類型為final； 生成Bytecode 會比多個catch小； Rethrow時保持異常類型
1.5 數字類型的下劃線表示 更友好的表示方式，不過要注意下劃線添加的一些標准
1.6 泛型實例的創建可以通過類型推斷來簡化 可以去掉後面new部分的泛型類型，只用<>就可以了
1.7在可變參數方法中傳遞非具體化參數,改進編譯警告和錯誤
1.8 信息更豐富的回溯追蹤 就是上面try中try語句和裡面的語句同時拋出異常時，異常棧的信息
2. NIO2的一些新特性
1.java.nio.file 和java.nio.file.attribute包 支持更詳細屬性，比如許可權，所有者
2. symbolic and hard links支持
3. Path訪問文件系統，Files支持各種文件操作
4.高效的訪問metadata信息
5.遞歸查找文件樹，文件擴展搜索
6.文件系統修改通知機制
7.File類操作API兼容
8.文件隨機訪問增強 mapping a region,locl a region,絕對位置讀取
9. AIO Reactor（基於事件）和Proactor
2.1IO and New IO 監聽文件系統變化通知
通過FileSystems.getDefault().newWatchService()獲取watchService，然後將需要監聽的path目錄注冊到這個watchservice中，對於這個目錄的文件修改，新增，刪除等實踐可以配置，然後就自動能監聽到響應的事件。
2.2 IO and New IO遍歷文件樹 ，通過繼承SimpleFileVisitor類，實現事件遍歷目錄樹的操作，然後通過Files.walkFileTree(listDir, opts, Integer.MAX_VALUE, walk);這個API來遍歷目錄樹
2.3 AIO非同步IO 文件和網路 非同步IO在java
NIO2實現了，都是用AsynchronousFileChannel，AsynchronousSocketChanne等實現，關於同步阻塞IO，同步非阻塞IO，非同步阻塞IO和非同步非阻塞IO。Java NIO2中就實現了操作系統的非同步非阻塞IO。
3. JDBC 4.1
3.1.可以使用try-with-resources自動關閉Connection, ResultSet, 和 Statement資源對象
3.2. RowSet 1.1：引入RowSetFactory介面和RowSetProvider類，可以創建JDBC driver支持的各種 row sets，這里的rowset實現其實就是將sql語句上的一些操作轉為方法的操作，封裝了一些功能。
3.3. JDBC-ODBC驅動會在jdk8中刪除
4. 並發工具增強
4.1.fork-join
最大的增強，充分利用多核特性，將大問題分解成各個子問題，由多個cpu可以同時解決多個子問題，最後合並結果，繼承RecursiveTask，實現compute方法，然後調用fork計算，最後用join合並結果。
4.2.ThreadLocalRandon 並發下隨機數生成類，保證並發下的隨機數生成的線程安全，實際上就是使用threadlocal
4.3. phaser 類似cyclebarrier和countdownlatch，不過可以動態添加資源減少資源
5. Networking增強

新增URLClassLoader close方法，可以及時關閉資源，後續重新載入class文件時不會導致資源被佔用或者無法釋放問題
URLClassLoader.newInstance(new URL[]{}).close();
新增Sockets Direct Protocol
繞過操作系統的數據拷貝，將數據從一台機器的內存數據通過網路直接傳輸到另外一台機器的內存中
6. Multithreaded Custom Class Loaders
解決並發下載入class可能導致的死鎖問題，這個是jdk1.6的一些新版本就解決了，jdk7也做了一些優化。有興趣可以仔細從官方文檔詳細了解

JDK1.8的新特性
一、介面的默認方法
Java 8允許我們給介面添加一個非抽象的方法實現，只需要使用 default關鍵字即可，這個特徵又叫做擴展方法。
二、Lambda 表達式
在Java 8 中你就沒必要使用這種傳統的匿名對象的方式了，Java 8提供了更簡潔的語法，lambda表達式：
Collections.sort(names, (String a, String b) -> {

return b.compareTo(a);

});
三、函數式介面
Lambda表達式是如何在java的類型系統中表示的呢？每一個lambda表達式都對應一個類型，通常是介面類型。而「函數式介面」是指僅僅只包含一個抽象方法的介面，每一個該類型的lambda表達式都會被匹配到這個抽象方法。因為 默認方法 不算抽象方法，所以你也可以給你的函數式介面添加默認方法。
四、方法與構造函數引用
Java 8 允許你使用 :: 關鍵字來傳遞方法或者構造函數引用，上面的代碼展示了如何引用一個靜態方法，我們也可以引用一個對象的方法：
converter = something::startsWith;

String converted = converter.convert("Java");

System.out.println(converted);
五、Lambda 作用域
在lambda表達式中訪問外層作用域和老版本的匿名對象中的方式很相似。你可以直接訪問標記了final的外層局部變數，或者實例的欄位以及靜態變數。
六、訪問局部變數
可以直接在lambda表達式中訪問外層的局部變數：
七、訪問對象欄位與靜態變數
和本地變數不同的是，lambda內部對於實例的欄位以及靜態變數是即可讀又可寫。該行為和匿名對象是一致的：
八、訪問介面的默認方法
JDK 1.8 API包含了很多內建的函數式介面，在老Java中常用到的比如Comparator或者Runnable介面，這些介面都增加了@FunctionalInterface註解以便能用在lambda上。
Java 8 API同樣還提供了很多全新的函數式介面來讓工作更加方便，有一些介面是來自Google Guava庫里的，即便你對這些很熟悉了，還是有必要看看這些是如何擴展到lambda上使用的。

H. java中lambda表達式怎樣實現一個多方法的介面呢

並不是所有介面都可以使用Lambda表達式，只有函數式介面可以。
按照Java8函數式介面的定義，其只能有一個抽象方法，否則就不是函數時介面，就無法用Lambda表達式。
可以使用@FunctionalInterface標注函數式介面，在編譯時提前發現錯誤。

I. Java的學習內容有哪些學完後好找工作嗎

這里給你分享一套java學習路線圖：
一、JavaSE基礎階段
面向對象編程(基礎)
面向對象編程(進階)
異常機制
Java常用類
數據結構和演算法
集合(容器)
IO流
多線程
網路編程
集合提升訓練
多線程提升訓練
二、資料庫階段
MySQL基礎
MySQL 查詢語句
資料庫對象
JDBC
反射和註解
資料庫建模和UML建模
設計模式
三、WEB前端
JavaScript
jQuery
BootStrap
Vue
四、JavaEE階段 （核心階段）
HTTP/Tomcat
MVC 架構
Servlet
JSP
EL+JSTL+過濾器+監聽器
Ajax和JSON
分頁和文件上傳/下載
五、JavaEE階段（高級框架）
Spring 5.2.2
SpringMVC 5.2.2
RBAC
EasyUI 1.7.0
支付/簡訊驗證
六、框架強化
Linux - CentOS 8
Maven
Logback
Quartz
Spring Boot 2.2.2
Shiro
Swagger
Git/GitEE
MyBatis
七、分布式架構
Zookeeper
RPC
Dubbo
Redis
Solr
RabbitMQ
FastDFS
Nginx
Spring Security
Spring Session
MyBatis Generator
Mycat
八、微服務階段
ElasticSearch
MongoDB
Spring Cloud Netflix Eureka
Spring Cloud Netflix Ribbon
Spring Cloud OpenFeign
Spring Cloud Netflix Hystrix
Spring Cloud Config
Spring Cloud Gateway
Docker
K8S
LCN
只要學的好，java肯定很好找工作啊
隨著信息化的發展。IT培訓受倒了越來越多人的追捧。在開發領域，JAVA培訓成為了很多人的首選！JAVA應用廣泛。JAVA培訓就業前景良好。眼下。盡管JAVA人才的薪水非常高。可是對該類人才需求旺盛的IT企業卻非常難招聘倒合格的JAVA人才。
JAVA人才社會需求量大，依據IDC的統計數字。在所有軟體開發類人才的需求中，對JAVAproject師的需求達倒所有需求量的60%~70%。
同一時候，JAVAproject師的薪水相對較高。通常來說。具有3~5年開發經驗的project師，擁有年薪10萬元是非常正常的一個薪酬水平。80%學員畢業後年薪都超過了5萬元。Java平台以其移動性、安全性和開放性受倒追捧。
JAVA就業前景分析：Java發展方向大致分為兩類：
成為管理人員。比如產品研發經理。技術經理，項目經理等
繼續他的技術工作之路，成為高級軟體project師、需求project師等。依據IDC的統計數字，在所有軟體開發類人才的需求中。對Javaproject師的需求達到所有需求量的60%~70%。同一時候。Javaproject師的薪水相對較高。
Java軟體project師一般月薪范圍在4000-10000元。遠遠超過了應屆畢業生月薪2500元的平均水平。通常來說。有一年工作經驗的Java高級軟體project師的薪酬大致在年薪10—13萬左右。
從Java的應用領域來分。Java語言的應用方向主要表如今下面三個方面：首先是大中型的商業應用;其次是桌面應用，就是常說的C/S應用;再次是移動領域應用。
綜上而言JAVA就業方向為：能夠從事JSP站點開發、Java編程、Java游戲開發、Java桌面程序設計，以及其它與Java語言編程相關的工作。
可進入電信、銀行、保險專業軟體開發公司等從事軟體設計和開發工作。
學習java，就來北京尚學堂，優秀的師資和科學的授課方式，會帶給你最好的學習體驗。

J. java 抽象類 能用lambda表達式嗎

抽象類不能，但是可以拓展一下。

例如，TimerTask是一個抽象類，

Timertimer=newTimer();
timer.schele(newTimerTask(){
//代碼...
},1000);

在這里用lambda的話就會報錯，但可以把Timer拓展一下

{

publicTimerTaskschele(finalRunnabler,longdelay){
finalTimerTasktask=newTimerTask(){publicvoidrun(){r.run();}};
this.schele(task,delay);
returntask;
}
}

然後使用MyTimer

MyTimertimer=newMyTimer();
timer.schele(()->{
//代碼...
},1000);
//或者
timer.schele(this::run,1000);

這樣使用就不會報錯了。

可以參考這個，換一種思維模式去寫代碼。