Java8特性简介

作者: yangziwen | 来源:发表于2021-07-26 10:15 被阅读0次

注：在2017年3月编写的版本的基础上，按简书要求清除了外链，一些外部信息请自行检索

Java8引入了哪些新特性？

Lambda表达式
Optional
Stream
默认方法
CompletableFuture
新的日期和时间api

为何要关心这些特性

声明式编程 vs 命令式编程
响应式编程 vs 多线程编程
面向函数 vs 面向对象

Java 8 提供了更多的编程工具和概念，能够以更简洁、更易于维护的方式解决新的和现有的编程问题。

在Java6,7的环境中使用Java8的新特性

retrolambda：支持Lambda表达式,方法引用,接口静态方法的backport库
streamsupport：支持Stream,CompletableFuture,函数接口,Optional的backport库
threetenbp：支持Java8时间日期api的backport库

lambda表达式

Lambda表达式是一个匿名函数，可以作为参数传递给方法或者存储在变量中。
Lambda表达式有参数列表、函数主体、返回类型，可以抛出异常。
Java中的lambda表达式仅仅是替代匿名内部类的语法糖。

声明表达式的例子↓

Runnable run = () -> {};

Runnable run = new Runnable() {
    @Override
    public void run() {
    }
};

BiFunction<Long, Long, Long> adder = (Long x, Long y) -> { return x + y; };

BiFunction<Long, Long, Long> adder = (x, y) -> x + y;
        
BiFunction<Long, Long, Long> adder = new BiFunction<Long, Long, Long>() {
    @Override
    public Long apply(Long x, Long y) {
        return x + y;
    }
};

Consumer<String> sayHi = (String name) -> System.out.println("Hi " + name);

Consumer<String> sayHi = new Consumer<String>() {
    @Override
    public void accept(String name) {
        System.out.println("Hi " + name);
    }
};

FileFilter filter = f -> f.isDirectory();

FileFilter filter = new FileFilter() {
    @Override
    public boolean accept(File f) {
        return f.isDirectory();
    }
};

局限性: 必须显式或隐式的通过函数式接口声明Lambda表达式 (表达式相同，函数接口不同，则用途不同)。

函数式接口: 只定义一个抽象方法的接口 (可通过标注@FunctionalInterface提示编译器进行检查)。

目标类型: Lambda表达式需要的类型。Lambda表达式的类型会从上下文中推断出来(类似List<String> list = new ArrayList<>;)。

隐式声明表达式的例子↓

file.listFiles(f -> f.isFile() && !f.isHidden());

file.listFiles(new FileFilter() {
    @Override
    public boolean accept(File f) {
        return f.isFile() && !f.isHidden();
    }
});

file.listFiles((dir, name) -> name.endsWith(".class"));

file.listFiles(new FilenameFilter() {
    @Override
    public boolean accept(File dir, String name) {
        return name.endsWith(".class");
    }
});

List<Integer> list = Arrays.asList(3, 5, 2, 1, 6);

list.sort((a, b) -> a.compareTo(b));

list.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer a, Integer b) {
        return a.compareTo(b);
    }
});

常用的函数式接口 (java.util.function.*)↓

函数式接口	函数描述符	使用场景
Predicate<T>	T → boolean	各种filter
Consumer<T>	T → void	forEach的情形
Supplier<T>	() → T	工厂函数
Function<T, R>	T → R	对象转换
BiFunction<T, U, R>	(T, U) → R	对象转换
UnaryOperator<T>	T → T	一元运算符
BinaryOperator<T>	(T, T) → T	二元运算符

方法引用

静态方法引用 ↓

Function<String, Integer> parser = Integer::parseInt;

Function<String, Integer> parser = str -> Integer.parseInt(str);

实例方法引用↓

List<Integer> list = Arrays.asList(3, 5, 2, 1, 6);

list.sort(Integer::compareTo);

list.sort((a, b) -> a.compareTo(b));

// 下面的语句对应静态方法引用
list.sort(Integer::compare);

对象方法引用↓

CountDownLatch latch = new CountDownLatch(5);

for (int i = 0; i < 5; i++) {
    new Thread(latch::countDown).start();
    // 等价于
    // new Thread(() -> { latch.countDown(); }).start();
}

latch.await();

构造方法引用↓

Executors.newCachedThreadPool(Thread::new);

Executors.newCachedThreadPool(r -> new Thread(r));

Executors.newCachedThreadPool(new ThreadFactory() {
    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r);
    }
});

一些有用的Lambda复合方法 (将多个表达式整合成一个)
java.util.Comparator提供的复合方法↓

List<Repo> repos = Arrays.asList(
        new Repo("code-service", true),
        new Repo("code-office", false),
        new Repo("code-browser", true));

repos.sort(Comparator
        .comparing(Repo::isFavorite)
        .reversed()
        .thenComparing(Repo::getName));

repos.stream().forEach(System.out::println);

输出结果↓
code-browser true code-service true code-office false

java.util.function.Predicate提供的复合方法↓

IntPredicate p23 = v -> v % 23 == 0;
IntPredicate p3 = v -> v % 3 == 0;
IntPredicate p37 = v -> v % 37 == 0;

IntStream.rangeClosed(1, 100)
    .filter(p23
            .and(p3.negate())
            .or(p37))
    .forEach(v -> System.out.print(v + " "));

输出结果：23 37 46 74 92

java.util.function.Function提供的复合方法↓

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = f.andThen(g); // 等价于 x -> (x + 1) * 2

** 注意事项**

Lambda表达式中的this
静态方法中声明的Lambda表达式，内部不允许出现this
类实例的方法中声明的Lambda表达式，内部出现的this直接指向类实例本身
在表达式内部对外部变量进行引用(打折扣的闭包)
Lambda表达式内部引用的方法中的局部变量，必须是不可变的(即使未声明final关键字)
Lambda表达式会让栈跟踪的分析变得更困难

Optional

“I call it my billion-dollar mistake. ... My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn’t resist the temptation to put in a null reference, simply because it was so easy to implement.”

from 《Invention of the null-reference a billion dollar mistake》
by Tony Hoare

null的坏处: 缺乏安全感
String name = revision.getCommit().getCommitter().getName();

通过使用Optional，消除业务代码中对null的判断

class RevisionInfo {
    private CommitInfo commit;
    public RevisionInfo(CommitInfo commit) {
        this.commit = commit;
    }
    public CommitInfo getCommit() {
        return commit;
    }
}

class CommitInfo {
    private String commit;
    private GitPersonInfo committer;
    public CommitInfo(String commit, GitPersonInfo committer){
        this.commit = commit;
        this.committer = committer;
    }
    public String getCommit() {
        return commit;
    }
    public GitPersonInfo getCommitter() {
        return committer;
    }
}

class GitPersonInfo {
    private String name;
    public GitPersonInfo(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

// 构造数据
GitPersonInfo personInfo = new GitPersonInfo("yangziwen");
CommitInfo commitInfo = new CommitInfo("e0f181e", personInfo);
RevisionInfo revision = new RevisionInfo(commitInfo);

// 不使用Optional的写法
String name = "";
if (revision != null) {
    CommitInfo commit = revision.getCommit();
    if (commit != null) {
        GitPersonInfo person = commit.getCommitter();
        if (person != null) {
            name = person.getName();
        }
    }
}

// 使用Optional的写法
String name = Optional.ofNullable(revision)
        .map(RevisionInfo::getCommit)
        .map(CommitInfo::getCommitter)
        .map(GitPersonInfo::getName)
        .orElse("");

// 等价的写法
String name = Optional.ofNullable(revision)
        .map(rev -> rev.getCommit())
        .map(commit -> commit.getCommitter())
        .map(commiter -> commiter.getName())
        .orElse("");

藉此实现了类似groovy中 def name = revision?.commit?.committer?.name?:""的效果

可通过如下方式创建Optional对象
Optional<String> optional = Optional.of("hello");
Optional<String> optional = Optional.ofNullable("world");
Optional<String> optional = Optional.empty();

注意事项

Optional类没有实现Serializable接口
不要在Model或DTO类中直接使用Optional做为字段类型
尽量不使用Optional的基础类型 (如OptionalInt, OptionalLong)

Stream

遍历数据集的高级迭代器
允许以声明性方式处理数据集合，类似linux中的管道，或者jQuery的集合操作

List<Integer> list = Arrays.asList(3, 5, 1, 7, 2, 9, 3, 9, 1);

// 去重后，取出最大的三个奇数
List<Integer> threeBiggestOdds = list.stream()
    .distinct()
    .filter(d -> d % 2 == 1)
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());

// 不使用流的方式
Set<Integer> set = new TreeSet<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer v1, Integer v2) {
        return v2.compareTo(v1);
    }
});
for (Integer v : list) {
    if (v % 2 == 1) {
        set.add(v);
    }
}
List<Integer> threeBiggestOdds = new ArrayList<>(set).subList(0, 3);

结果[9, 7, 5]

流的操作
中间操作：filter, map, sorted, skip, limit等 (继续返回Stream对象)
终端操作：collect, forEach, min, max, count, anyMatch, findFirst等
一个Stream对象只能消费(遍历)一次，遍历的执行由终端操作触发

int[] numbers = {4, 5, 3, 9};

// 求和
int result = Arrays.stream(numbers).reduce(0, (a, b) -> a + b);

// 等价于
int result = Arrays.stream(numbers).sum();

数值流

IntStream intStream = dishList.stream().mapToInt(Dish::getCalories);
Stream<Integer> stream = intStream.boxed();

IntStream.rangeClosed(1, 100).sum();

并行流

// 任务被分治拆解后，通过ForkJoinPool并行执行
List<Integer> threeBiggestOdds = list.parallelStream()  // 直接创建并行流
    .distinct()
    .filter(d -> d % 2 == 1)
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());

List<Integer> threeBiggestOdds = list.stream()
    .distinct()
    .filter(d -> d % 2 == 1)
    .parallel()  // 在某一步转换为并行流
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());

用流重构代码
简单的例子
重构前↓

public List<GroupMember> getUsersByProduct(Product product, RepoMemberRole role) {
    List<ProductGroupRelation> relations = getProductGroupRelationsByProductId(product.getId());
    List<Long> groupIds = new ArrayList<>();
    for (ProductGroupRelation relation : relations) {
        if (role == null || role == relation.getRole()) {
            groupIds.add(relation.getGroupId());
        }
    }
    return groupService.getMembersByGroupIds(groupIds);
}

重构后↓

public List<GroupMember> getusersByProduct(Product product, RepoMemberRole role) {
    return getProductGroupRelationsByProductId(product.getId())
            .stream()
            .filter(rel -> role == null || role == rel.getRole())
            .map(rel -> rel.getGroupId())
            .collect(collectingAndThen(toList(), groupService::getMembersByGroupIds));
}

复杂一些的例子
重构前↓

public List<RepoMember> getRepoUsers(Repo repo) {
    List<RepoMember> users = repoMemberDao.selectRepoMemberByRepoID(repo.getId());
    users.addAll(getRepoUsersViaGroup(repo));

    Map<String, RepoMember> userMap = new HashMap<>();
    for (RepoMember user : users) {
        RepoMember prev = userMap.get(user.getUserName());
        if (prev == null) {
            userMap.put(user.getUserName(), user);
            continue;
        }
        if (prev.getRepoMemberRole().hasPermission(user.getRepoMemberRole())) {
            continue;
        }
        userMap.put(user.getUserName(), user);
    }
    List<RepoMember> result = Lists.newArrayList(userMap.values());
    Collections.sort(result, new Comparator<RepoMember>() {
        @Override
        public int compare(RepoMember user1, RepoMember user2) {
            int result = user1.getRepoMemberRole().compareTo(user2.getRepoMemberRole());
            if (result == 0) {
                result = user1.getUserName().compareTo(user2.getUserName());
            }
            return result;
        }
    });
    return result;
}

使用流重构后↓

public List<RepoMember> getRepoUsers(Repo repo) {
    return Stream.concat(
            repoMemberDao.selectRepoMemberByRepoID(repo.getId()).stream(),
            getRepoUsersViaGroup(repo).stream())
        .collect(groupingBy(RepoMember::getUserName))  // 构造userListMap
        .values().stream()
        .map(list -> list.stream().min(comparing(RepoMember::getRepoMemberRole))) // 每个user的最大权限
        .filter(Optional::isPresent)
        .map(Optional::get)
        .sorted(comparing(RepoMember::getRepoMemberRole)
                .thenComparing(RepoMember::getUserName))  // 先按角色排序，再按用户名排序
        .collect(toList());
}

注意事项

并行流只适用于计算密集型的场景，不适合简单计算和IO密集型的场景
要注意使用流过程中基本类型的拆箱装箱操作对性能的影响

默认方法

接口中可定义以default关键字开头的非抽象非静态的方法
用来对接口进行扩展，可被实现类覆盖(Override)
默认方法只能调用本接口中的其他抽象方法或默认方法

// List接口中的sort方法
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

多继承问题
接口中允许声明默认方法，造成了方法多继承问题的出现

解决问题的三条规则

类中声明的方法的优先级高于接口中声明的默认方法
子接口中的默认方法的优先级高于父接口
继承了多个接口的类必须通过显示覆盖和调用期望的方法，显式的选择使用哪个默认方法的实现

interface A {
    default void hello () {
        System.out.println("Hello A");
    }
}

interface B {
    default void hello() {
        System.out.println("Hello B");
    }
}

class C implements A, B {
    @Override
    public void hello() {
        A.super.hello();
    }
}

CompletableFuture

Future接口只能以阻塞的方式获取结果，因此引入CompletableFuture，从而可以非阻塞(回调)的方式获取和处理结果
类似jQuery中基于Promise/Deferred模式的ajax api

辅助代码↓

static long now() {
    return System.currentTimeMillis();
}

// 产生一个1s到3s的延迟，模仿IO操作
static double randomDelay() {
    long t = now();
    sleepQuietly((new Random().nextInt(20) + 10) * 100L);
    return (now() - t) / 1000D;
}

static void sleepQuietly(Long millis) {
    try {
        Thread.sleep(millis);
    } catch (InterruptedException e) {
    }
}

例子1：串行的执行两个IO操作，并通过回调的方式处理结果

public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(10);
    long t = now();
    CompletableFuture.supplyAsync(() -> {
        System.out.println("delay before task is " + (now() - t) / 1000D);
        return randomDelay();
    }, executor)
    .thenAccept(d1 -> System.out.println("delay of 1st task is " + d1))
    .thenCompose(d1 -> CompletableFuture.supplyAsync(() -> {
        return randomDelay();
    }, executor))
    .thenAccept(d2 -> System.out.println("delay of 2nd task is " + d2))
    .thenAccept(d2 -> System.out.println("total time is " + (now() - t) / 1000D))
    .thenAcceptAsync(d2 -> executor.shutdown());
}

例子2：并行的执行两个IO操作，并通过回调的方式处理结果

static final ExecutorService executor = Executors.newFixedThreadPool(10);

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
    return CompletableFuture.supplyAsync(supplier, executor);
}

public static void main(String[] args) {
    long t = now();
    supplyAsync(() -> {
        System.out.println("delay before task is " + (now() - t) / 1000D);
        return randomDelay();
    }).thenCombine(supplyAsync(() -> {
        return randomDelay();
    }), (d1, d2) -> Arrays.asList(d1, d2))
    .thenAccept(delays -> {
        AtomicInteger counter = new AtomicInteger(0);
        delays.stream().forEach(delay -> {
            System.out.println("delay of task" + counter.incrementAndGet() + " is " + delay);
        });
        System.out.println("total delay is " + (now() - t) / 1000D);
    })
    .thenAcceptAsync(delays -> executor.shutdown());
}

注意事项

基于Blocking-IO的IO密集型应用不要使用ForkJoinPool (CompletableFuture默认使用ForkJoinPool，因此需指定自定义的线程池)
在高并发下，线程数的设置可参考如下公式
其中
N_threads：高并发下线程池的理想线程数
N_CPU：CPU内核个数，可通过Runtime.getRuntime().availableProcessors()获取
U_CPU：CPU总利用率，取值在0到1之间
W / C：CPU占空比(C为占用的时间，W为空闲的时间)

新的日期和时间api

Java曾经在同一个地方摔倒了两次 → Date and Calendar
new Date(117, 1, 16); // 2017-02-16
DateFormat // 线程不安全
Calendar // 仍然不好用 (线程不安全，可变，不支持格式化)

为了阻止悲剧反复上演，Java8决定整合Joda-Time的特性
LocalDate / LocalTime / LocalDateTime

LocalDate date = LocalDate.of(2017, 2, 16);

LocalDate today = LocalDate.now();

LocalDate date = LocalDate.parse("2017-02-16");  // 只抛运行时异常

DateTimeFormatter formatter = new DateTimeFormatter.ofPattern("yyyy/MM/dd"); // 线程安全
LocalDate date = LocalDate.parse("2017/02/16", formatter);  // 只抛运行时异常

Period // 按日计的时间间隔
Duration // 按秒记得时间间隔

TemporalAdjuster 调整日期时间

import static java.time.temporal.TemporalAdjusters.*;

LocalDate date = LocalDate.parse("2017-02-16").with(nextOrSame(DayOfWeek.SATURDAY));

时区

ZonedDateTime time = LocalDateTime.now().atZone(ZoneId.systemDefault());

ZonedDateTime londonTime = time.withZoneSameInstant(ZoneId.of("Europe/London"));

历法
ThaiBuddhistDate // 泰国佛教历
MinguoDate // 中华民国历
JapaneseDate // 日本历
HijrahDate // 伊斯兰历

MinguoDate date = MinguoDate.from(LocalDate.parse("2017-02-16"));
// Minguo ROC 106-02-16

JapaneseDate date = JapaneseDate.from(LocalDate.parse("2017-02-16"));
// Japanese Heisei 29-02-16

注意事项

所有的日期和时间对象，都是不可变对象，所以一定是线程安全的
尽量不用各种其他的历法(ChronoLocalDate)，在系统中统一使用LocalDate(ISO-8061的时间和日期标准)
LocalDateTime应用于MyBatis，需要自定义相应类型的handler，实现java.sql.Timestamp与LocalDateTime之间的转换

更多内容：JAVA 8：健壮、易用的时间/日期API

Java8特性简介

Java8引入了哪些新特性？

为何要关心这些特性

在Java6,7的环境中使用Java8的新特性

lambda表达式

Optional

Stream

默认方法

CompletableFuture

新的日期和时间api

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读