Java 8 新特性
官网java8介绍地址
菜鸟教程关于java8的介绍
Java 8 里面加了很多的新特性，在这里我们只讨论一些常用和实际可能用的到的特性，其他的特性，感兴趣的人可以去官网研究下。
总的来说，常用的特性主要有：
- Lambda表达式 ——允许把函数作为一个方法的参数
- 方法引用 ——方法引用提供了非常有用的语法，可以直接引用已有的Java类或对象（实例）的方法和构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码
- 默认方法 ——默认方法就是一个在接口里面有了一个实现的方法（为Lambda所推出的特性，java8之前接口不能拥有实现方法）
- Stream API ——新添加的Stream API（java.util.stream）把真正的函数式编程风格引入到java中
- Date Time API ——加强对日期与时间的处理（LocalDateTime，LocalDate，LocalTime）
- Optional ——Optional类已成为Java8类库的一部分，用来解决空指针异常
- Base64 ——Java8中,Base64编码已经成为Java类库标准。Java8内置了Base64的编码器和解码器
Lambda 表达式
Lambda 允许把函数作为一个方法的参数（可以参考js）
Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
语法
(parameters, parameters) -> expressions
(parameters) -> { statements; }
如何了解Lambda表达式
通过这段时间上网上找资料、看视频、翻官方文档，我发现我们可以通过这个脉络去了解和使用Lambda表达式：匿名内部类->函数式接口->Lambda表达式
内部类->匿名内部类
内部类：将一个类的定义放在另一个类的定义内部，就是内部类。其优点为可以访问外部类中的资源，就是属性、方法等；缺点破坏代码结构，简单的说就是丑。
匿名内部类：顾名思义就是没有名字的内部类；通常为直接初始化一个接口，并初始化时将接口的方法实现。（我在写android的时候倒是经常遇到）
这里我们通过一个官方内部类的示例改写下来了解下：
package com.education.java8;
/**
* @author weichen
* @description: 匿名内部类实例
* @create 2020-04-23 13:47
* @from https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html
*/
public class HelloWorldAnonymousClasses {
// 申明一个接口
interface HelloWorld {
void greet();
void greetSomeone(String someone);
}
interface HelloWorldLambda {
void greet();
}
// 定义一个方法
public void sayHello() {
// 方法内部类实现了HelloWorld接口
class EnglishGreeting implements HelloWorld {
String name = "world";
@Override
public void greet() {
greetSomeone("world");
}
@Override
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld englishGreeting = new EnglishGreeting();
// 匿名内部类实现
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
@Override
public void greet() {
greetSomeone("tout le monde");
}
@Override
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};
// 匿名内部类实现
HelloWorld spanishGreeting = new HelloWorld() {
String name = "mundo";
@Override
public void greet() {
greetSomeone("mundo");
}
@Override
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hola," + name);
}
};
// 匿名内部类实现
HelloWorld chineseGreeting1 = new HelloWorld() {
String name = "世界";
@Override
public void greet() {
greetSomeone("世界");
}
@Override
public void greetSomeone(String someone) {
name = someone;
System.out.println("你好 " + name);
}
};
// 匿名内部类实现
// HelloWorldLambda chineseGreeting2 = new HelloWorldLambda() {
// @Override
// public void greet() {
// System.out.println("你好 世界");
// }
// };
HelloWorldLambda chineseGreeting2 = () -> System.out.println("你好 世界");
englishGreeting.greet();
frenchGreeting.greetSomeone("Fred");
spanishGreeting.greet();
chineseGreeting1.greet();
chineseGreeting2.greet();
}
public static void main(String... args) {
HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
myApp.sayHello();
}
}
输出：
Hello world
Salut Fred
Hola,mundo
你好 世界
你好 世界
获取上面的例子在实际中没啥卵用，这里再给出个线程相关的例子：
package com.education.java8;
/**
* @author weichen
* @description: 创建Runnable接口的实现类，重写run方法，设置线程任务
* @create 2020-04-24 14:39
*/
public class RunnableImpl implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "被创建了");
}
public static void main(String[] args) {
RunnableImpl runnable = new RunnableImpl();
Thread t = new Thread(runnable);
t.start();
// 简化代码，使用匿名内部类
Runnable runnable1 = new Runnable(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "被创建了");
}
};
new Thread(runnable1).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "被创建了");
}
}).start();
new Thread(() -> System.out.println(Thread.currentThread().getName() + "被创建了")).start();
}
}
输出：
Thread-0被创建了
Thread-1被创建了
Thread-2被创建了
Thread-3被创建了
上面的例子中，我们发现对于有且仅有一个抽象方法的接口，我们可以使用lambda表达式，而大于一个的接口只能继续使用匿名内部类的方法。这里就衍生出了函数式接口的概念。
函数式接口
函数式接口就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
首先，我们来定义一个函数式接口：
/**
* @author weichen
* @description: 函数式接口，注意：只包含一个抽象方法,或多个default修饰的默认方法
* @create 2020-05-12 22:17
*/
@FunctionalInterface
public interface FunctionService {
void test();
default void printString(String msg) {
System.out.println(msg);
}
}
在java8后，可以通过@FunctionalInterface注解来定义函数式接口，其实在该注解源码的注释里已经给出了详细的说明：
/**
* An informative annotation type used to indicate that an interface
* type declaration is intended to be a functional interface as
* defined by the Java Language Specification.
*
* 一种信息性注释类型，用于指示接口类型声明是由Java语言规范定义的函数接口
*
* Conceptually, a functional interface has exactly one abstract
* method. Since {@linkplain java.lang.reflect.Method#isDefault()
* default methods} have an implementation, they are not abstract. If
* an interface declares an abstract method overriding one of the
* public methods of {@code java.lang.Object}, that also does
* not count toward the interface's abstract method count
* since any implementation of the interface will have an
* implementation from {@code java.lang.Object} or elsewhere.
*
* 从概念上讲，函数接口只有一个抽象方法。因为{@linkplain
* java.lang.reflect.Method#isDefault（）default
* methods}有一个实现，所以它们不是抽象的。如果一个接口声明了一个抽象方法重写{@
* ode java.lang.Object}的一个公共方法，那么它也会对接口的抽象方法计数进行
* 不是计数，因为接口的任何实现都将具有来自{@code
* java.lang.Object}或其他地方的实现。
*
* Note that instances of functional interfaces can be created with
* lambda expressions, method references, or constructor references.
*
*
注意，函数接口的实例可以使用lambda表达式、方法引用或构造函数引用创建。
*
*
If a type is annotated with this annotation type, compilers are
* required to generate an error message unless:
*
*
如果使用此注解类型对类型进行注解，则编译器生成错误消息，那么需要注意的是：
*
*
* - The type is an interface type and not an annotation type, enum, or
* class.
*
- The annotated type satisfies the requirements of a functional interface.
*
*
* - 类型是接口类型，而不是注解类型、枚举或类。
- 带注解的类型满足函数式接口的要求。
*
* However, the compiler will treat any interface meeting the
* definition of a functional interface as a functional interface
* regardless of whether or not a {@code FunctionalInterface}
* annotation is present on the interface declaration.
*
*
但是，无论接口声明中是否存在{@code-functionainterface}注解，编译器都会将满足函数接口定义的任何接口视为函数接口。
*
* @jls 4.3.2. The Class Object
* @jls 9.8 Functional Interfaces
* @jls 9.4.3 Interface Method Body
* @since 1.8
*/
@Documented // 可被javadoc导出
@Retention(RetentionPolicy.RUNTIME)// 运行时注解
@Target(ElementType.TYPE)// 参数类型type
public @interface FunctionalInterface {}
注：在java8中如果你的接口符合函数式接口的定义，编译器默认是将其编译为函数式接口，在上面的注释中已经有体现。
其实在java8之前，接口是只能包含抽象方法，然而在8之后添加了一种默认方法。默认方法使得8之后的代码完美的与之前的版本相兼容。
函数式接口在java里实际上仍然是对象。
使用Lambda表达式
forEach -> Consumer
java中对一个数组遍历有几种方法。java8之前有 for->i, 增强型遍历for->Object,迭代器遍历等，java8后多出个forEach,及外部遍历和内部遍历。
forEach的内部其实也是使用迭代器遍历的,注意forEach中不好对元素进行删除和新增会报ConcurrentModificationException异常，但可以修改属性。