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);

这样使用就不会报错了。

可以参考这个，换一种思维模式去写代码。