Java8自从14年发布之后增加了很多新特性，其中好多特性在实际应用中都可以用到，不仅简化了我们代码，还弥补了旧版本里的一些不足。这里只列举出一些实际开发中可能用得到的特性，加以说明。
函数式接口
函数式接口就是有且仅有一个抽象函数的接口，在java8之前就有一些函数是接口，比如java.util.Comparator，以前我们用到这种接口的时候，一般使用匿名内部类来进行实现，如下，我们定义一个Person类：
@Data
@AllArgsConstructor
@NoArgsConstructor
class Person {
private Integer id;
private String name;
private Integer age;
public static List getList() {
return Arrays.asList(
new Person(1, "1号", 19),
new Person(2, "2号", 16),
new Person(3, "3号", 20),
new Person(4, "4号", 19),
new Person(5, "5号", 14));
}
} 例如我们要实现按照年龄排序，就要实现一个Comparator类，重写compare方法：
public static void main(String[] args) {
List list = Person.getList();
list.sort(new Comparator() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});
list.forEach(System.out::println);
} 运行结果如下：
在java8之后就可以使用Lambda表达式来表示该接口的一个实现，如下：
public static void main(String[] args) {
List list = Person.getList();
list.sort((o1, o2) -> o1.getAge() - o2.getAge());
list.forEach(System.out::println);
} 方法引用
方法引用通过方法的名字来指向一个方法，可以使语言的构造更紧凑简洁，减少冗余代码。
例如上面代码中的list.forEach(System.out::println);就引用了println方法，继续优化上面的代码，我们可以使用方法引用来对集合进行排序：
public static void main(String[] args) {
List list = Person.getList();
list.sort(Comparator.comparingInt(Person::getAge));
list.forEach(System.out::println);
} stream
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
我们可以通过以下两种方式生成流对象：
- stream() − 为集合创建串行流。
- parallelStream() − 为集合创建并行流。
下面介绍几个常用的方法：
filter
filter接受一个返回值为布尔类型的函数作为参数，该函数可以用Lambda表达式表示。顾名思义，filter可用于过滤出集合中满足条件元素。
例如我们要在刚才定义的集合中找到年龄为19岁的：
public static void main(String[] args) {
List list = Person.getList();
list.stream().filter(person -> person.getAge() == 19).forEach(System.out::println);
} 运行结果：
map
map就是将对应的元素按照给定的方法进行转换，参数为Lambda表达式形式或者是方法引用。
例如我们要获得所有person对象的name：
public static void main(String[] args) {
List list = Person.getList();
list.stream().map(person -> person.getName()).forEach(System.out::println);
} 或者使用函数引用：
public class Test02 {
public static void main(String[] args) {
List list = Person.getList();
list.stream().map(Person::getName).forEach(System.out::println);
}
} 运行结果：
flatMap
和map像似，都是将对应元素按照对应的方法进行转换，但是区别在于map只能一对一，而flatMap可以一对多转换。
例如我们要获取文章集合中的所有标签，多个标签用逗号隔开。
文章类的定义如下：
@Data
@AllArgsConstructor
@NoArgsConstructor
class Article {
private String title;
private Integer id;
private String tags;
public static List getList() {
return Arrays.asList(
new Article("如何学习SpringBoot？", 1, "java,Spring"),
new Article("python学习方法总结", 2, "python,学习经验"),
new Article("sql优化", 3, "sql,数据库"),
new Article("jvm面试必考要点？", 4, "java,jvm,面试")
);
}
} 使用flatMap实现：
public static void main(String[] args) {
List list = Article.getList();
list.stream().flatMap(article -> Arrays.stream(article.getTags().split(","))).forEach(System.out::println);
} 运行结果：
但是假如使用map：
public static void main(String[] args) {
List list = Article.getList();
list.stream().map(article -> Arrays.stream(article.getTags().split(","))).forEach(System.out::println);
} 运行结果为：
可见map是能实现一对一，上面的代码只是将集合中的各个元素转换为stream类。
distinct
顾名思义，distinct可以实现去重。
例如，还是上面的标签问题，刚才打印出来的结果中存在标签重复，我们可以对其进行去重操作：
public static void main(String[] args) {
List list = Article.getList();
list.stream()
.flatMap(article -> Arrays.stream(article.getTags().split(",")))
.distinct()
.forEach(System.out::println);
} 运行结果：
sorted
使用soured可以对流中元素进行排序。
例如对person进行按照年龄排序：
public static void main(String[] args) {
List list = Person.getList();
list.stream().sorted(Comparator.comparingInt(Person::getAge)).forEach(System.out::println);
} 运行结果：
limit
限制返回的个数，例如我们只要前三个person的信息：
public static void main(String[] args) {
List list = Person.getList();
list.stream().limit(3).forEach(System.out::println);
} 运行结果：
skip
与limit相反，skip的作用是跳过前面指定个数元素，例如只显示后三个person的信息：
public static void main(String[] args) {
List list = Person.getList();
list.stream().skip(list.size() - 3).forEach(System.out::println);
} 运行结果：
min/max
求最大值或者最小值：
public static void main(String[] args) {
List list = Person.getList();
list.stream().min(Comparator.comparingInt(Person::getAge)).ifPresent(System.out::println);
} 这里的ifPresent是Optional类里面的方法，下面会谈到。
运行结果：
anyMatch/allMatch/noneMatch
返回一个boolean类型的值，其中
- anyMatch：Stream 中任意一个元素符合传入的 predicate，返回 true
- allMatch：Stream 中全部元素符合传入的 predicate，返回 true
- noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true
public static void main(String[] args) {
List list = Person.getList();
if (list.stream().noneMatch(person -> person.getAge() > 20)) {
System.out.println("没有人年龄大于20岁");
}
if (list.stream().anyMatch(person -> person.getAge() > 15)) {
System.out.println("存在年龄大于15岁的人");
}
if (list.stream().allMatch(person -> person.getAge() > 10)) {
System.out.println("所有人年龄都大于10岁");
}
} collect
collect在流中生成列表，map，等常用的数据结构
Optional
Optional类的出现是为了解决返回值为null的问题，以Spring Data Jpa为例，函数findById()的返回值就为一个Optional类的对象。
isPresent/getisPresent()可以用来判断Optional对象里面的值是否为null，get()可以获取里面的值：
但是这样似乎并没有比原始的方法if(xxx==null){}好用，其实Optional主要与Lambda表达式结合才能发挥出作用。
- 存在就执行操作：
Person p = new Person();
Optional p1 = Optional.ofNullable(p);
p1.ifPresent(person -> {
System.out.println(person);
}); - 存在就返回，否则返回其他内容（例如一个返回数组的函数，如果没有数据的话一般返回一个长度为0的数组，而不是null）
private static int[] test() {
int[] ints = {1, 2, 3, 4};
Optional optional = Optional.ofNullable(ints);
return optional.orElse(new int[0]);
} - 也可以由函数产生：
private static int[] test() {
int[] ints = {1, 2, 3, 4};
Optional optional = Optional.ofNullable(ints);
return optional.orElseGet(() -> {
// 一系列操作
return new int[0];
});
} - 存在就返回，否则就抛出异常
private static int[] test() {
int[] ints = {1, 2, 3, 4};
Optional optional = Optional.ofNullable(ints);
return optional.orElseThrow(() -> new RuntimeException());
} -
Optional类还可以进行链式操作，下面为java7的写法：
private static String getUpperName() {
Person p = new Person();
if (p != null) {
if (p.getName() != null) {
return p.getName().toUpperCase();
} else {
return null;
}
} else {
return null;
}
}使用java8可以大量简化操作：
private static String getUpperName() {
Person p = new Person();
return Optional.ofNullable(p)
.map(person -> person.getName())
.map(name -> name.toUpperCase())
.orElse(null);
}Java 8 日期时间 API
在旧版的 Java 中，日期时间 API 存在诸多问题，其中有：
- 非线程安全 − java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。
- 设计很差 − Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
- 时区处理麻烦 − 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。
java8中引入了很多新的类，使我们更加方便的操作时间与日期
- LocalDate：不包含时间的日期，比如2019-10-14。可以用来存储生日，周年纪念日，入职日期等。
- LocalTime：与LocalDate想对照，它是不包含日期的时间。
- LocalDateTime：包含了日期及时间，没有偏移信息（时区）。
- ZonedDateTime：包含时区的完整的日期时间，偏移量是以UTC/格林威治时间为基准的。
- Instant：时间戳，与System.currentTimeMillis()类似。
- Duration：表示一个时间段。
- Period：用来表示以年月日来衡量一个时间段。
- DateTimeFormatter：日期格式化类
毫秒数转LocalDateTime
实现需求：为了方便我们经常在数据库中存入毫秒数，从数据库中读取出毫秒数之后，我们可以通过以下方法转换为LocalDateTime
Instant instant = Instant.ofEpochMilli(System.currentTimeMillis());
LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());格式化LocalDateTime
实现需求：我们可以将时间转换为相应格式，返回给前端
LocalDateTime localDateTime = LocalDateTime.now();
String format = localDateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
String format1 = localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));参考：（DateTimeFormatter自带的时间格式）
参考文章：
https://www.runoob.com/java/j...
https://mp.weixin.qq.com/s/QQ...
https://mp.weixin.qq.com/s/sz...
https://juejin.im/post/5da3fd...
https://mp.weixin.qq.com/s/gq...