注：在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，因此需指定自定义的线程池)
- 在高并发下，线程数的设置可参考如下公式
其中
Nthreads：高并发下线程池的理想线程数
NCPU：CPU内核个数，可通过Runtime.getRuntime().availableProcessors()获取
UCPU：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
