Java8 新特性
date: 2019-09-23 16:50:00
updated: 2019-09-24 11:00:00
Java8 新特性
1. Lambda 表达式
语法：
(parameters) -> expression
或
(parameters) -> { statements; }
特征：
- 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值
- 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号
- 可选的大括号：如果主体只包含一个语句，就不需要使用大括号
- 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值
例子：
public class Java8Tester {
public static void main(String args[]) {
Java8Tester tester = new Java8Tester();
// 类型声明
MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明
MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句
MathOperation multiplication = (int a, int b) -> { return a * b; };
// 没有大括号及返回语句
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 不用括号
GreetingService greetService1 = message -> System.out.println("Hello " + message);
// 用括号
GreetingService greetService2 = (message) -> System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");
greetService2.sayMessage("Google");
}
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation) {
return mathOperation.operation(a, b);
}
}
lambda 表达式中访问外层的局部变量，这个局部变量可以不显式声明为 final，但是不能在后面代码修改（即隐式具有 final 含义）。但是如果外层变量是 static 声明的话，可以在 lambda 表达式内部引用，并且在后面的代码中修改。
static变量是恒定指向内存的一个位置的，哪怕修改变量的值也是同一个位置，final 不可修改，也可以算是指向了内存中的一个位置（从创建那时候开始算的话）。变量只是引用，普通变量修改值的话会指向另一块内存位置，而 lambda 应该规定的是，只要一块不变的内存地址
lambda 和 匿名内部类的比较：
匿名内部类的格式：
new 父类或接口() {
重写的方法;
}
在匿名内部类中很多是内容是冗余的。lambda 提取匿名内部类中最核心的内容（方法参数，方法体，返回值）。
Lambda 表达式的使用条件:
- 必须有接口（不能是抽象类），接口中有且仅有一个需要被重写的抽象方法。
- 必须支持上下文推导，要能够推导出来 Lambda 表达式表示的是哪个接口中的内容。
可以使用接口当做参数，然后传递 Lambda 表达式(常用)，也可以将 Lambda 表达式赋值给一个接口类型的变量。
2. 方法引用
语法：
- 构造器引用：
Class::new - 静态方法引用：
Class::static_method - 特定类的任意对象的方法引用：
Class::method - 特定对象的方法引用：
instance::method
public class Java8Tester {
public static void main(String args[]) {
List names = new ArrayList();
names.add("Google");
names.add("Runoob");
names.add("Taobao");
names.add("Baidu");
names.add("Sina");
names.forEach(System.out::println);
// 对每一个 names 中的值，依次传递给 System.out 类下面的 println 这个方法
}
}
3. 函数式接口
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为 lambda 表达式。
// Predicate <T> 接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。
// 该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。
// 该接口用于测试对象是 true 或 false。
public class Java8Tester {
public static void main(String args[]) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
// Predicate<Integer> predicate = n -> true
// n 是一个参数传递到 Predicate 接口的 test 方法
// n 如果存在则 test 方法返回 true
System.out.println("输出所有数据:");
// 传递参数 n
eval(list, n -> true);
// Predicate<Integer> predicate1 = n -> n%2 == 0
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n%2 为 0 test 方法返回 true
System.out.println("输出所有偶数:");
eval(list, n -> n % 2 == 0);
// Predicate<Integer> predicate2 = n -> n > 3
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n 大于 3 test 方法返回 true
System.out.println("输出大于 3 的所有数字:");
eval(list, n -> n > 3);
}
public static void eval(List<Integer> list, Predicate<Integer> predicate) {
for (Integer n : list) {
if (predicate.test(n)) {
System.out.println(n + " ");
}
}
}
}
// 换成流计算的话
private static void eval(List<Integer> list, Predicate<Integer> predicate) {
list.stream().filter(predicate).forEach(System.out::println);
}
// 直接填写过滤条件的话
list.stream().filter(n -> n > 3).forEach(System.out::println);
4. 接口的默认方法
接口可以有实现方法，并且不需要实现类来实现其方法。在方法名前面加 default 关键字即可实现默认方法。一个接口可以用多个默认方法。
目的：为了解决接口的修改与现有的实现不兼容的问题。之前需要修改接口的时候，需要修改全部实现该接口的类。
如果一个实现类实现了多个接口，并且多个接口中有相同的默认方法，可以在实现类中覆写掉这个默认方法，或者在实现类中通过 super 来指定接口的默认方法。
接口还可以声明（并且可以提供实现）静态方法。
public interface Vehicle {
default void print(){
System.out.println("我是一辆车!");
}
// 静态方法
static void blowHorn(){
System.out.println("按喇叭!!!");
}
}
5. Stream
流计算：
stream of elements
=> 聚合操作：filter、map、reduce、find、match、sorted、collect etc
生成流：
- stream()：为集合创建串行流
- parallelStream()：为集合创建并行流
如果是 Random 的话，通过 random.ints() 来生成流
Collectors：
Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。
Collectors 可用于返回列表或字符串：
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);
统计：
一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());
6. Optional 类
目的：为了解决空指针问题
demo：
import java.util.Optional;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8Tester = new Java8Tester();
Integer value1 = null;
Integer value2 = new Integer(10);
// Optional.ofNullable - 允许传递为 null 参数
Optional<Integer> a = Optional.ofNullable(value1);
// Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
Optional<Integer> b = Optional.of(value2);
System.out.println(java8Tester.sum(a,b));
}
public Integer sum(Optional<Integer> a, Optional<Integer> b){
// Optional.isPresent - 判断值是否存在
System.out.println("第一个参数值存在: " + a.isPresent());
System.out.println("第二个参数值存在: " + b.isPresent());
// Optional.orElse - 如果值存在，返回它，否则返回默认值
Integer value1 = a.orElse(new Integer(0));
//Optional.get - 获取值，值需要存在
Integer value2 = b.get();
return value1 + value2;
}
}
7. Nashorn, JavaScript 引擎
8. 新的日期时间 API
旧的日期 API 有诸多问题：
- 非线程安全： java.util.Date 是非线程安全的，所有的日期类都是可变的
- 设计差：java.util 和 java.sql 的包中都有日期类
- 时区处理麻烦：没有时区支持，因此引入了 java.util.Calendar 和 java.util.TimeZone 类，但他们同样存在上述所有的问题
新的日期 API：java.time
- 本地化日期时间 API
LocalDate/LocalTime 和 LocalDateTime 类可以在处理时区不是必须的情况
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8tester = new Java8Tester();
java8tester.testLocalDateTime();
}
public void testLocalDateTime(){
// 获取当前的日期时间
LocalDateTime currentTime = LocalDateTime.now();
System.out.println("当前时间: " + currentTime);
LocalDate date1 = currentTime.toLocalDate();
System.out.println("date1: " + date1);
Month month = currentTime.getMonth();
int day = currentTime.getDayOfMonth();
int seconds = currentTime.getSecond();
System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
System.out.println("date2: " + date2);
// 12 december 2014
LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
System.out.println("date3: " + date3);
// 22 小时 15 分钟
LocalTime date4 = LocalTime.of(22, 15);
System.out.println("date4: " + date4);
// 解析字符串
LocalTime date5 = LocalTime.parse("20:15:30");
System.out.println("date5: " + date5);
}
}
- 使用时区的日期时间 API
import java.time.ZonedDateTime;
import java.time.ZoneId;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8tester = new Java8Tester();
java8tester.testZonedDateTime();
}
public void testZonedDateTime(){
// 获取当前时间日期
ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
System.out.println("date1: " + date1);
ZoneId id = ZoneId.of("Europe/Paris");
System.out.println("ZoneId: " + id);
ZoneId currentZone = ZoneId.systemDefault();
System.out.println("当期时区: " + currentZone);
}
}
