java接口现实应用_java8新特性的实际应用

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/get

isPresent()可以用来判断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自带的时间格式)