肯定有人会问,马上都Java11了,还在聊8,是不是太low了,要知道业内经常流传“线上用的JDK7甚至JDK6,JDK8还没用熟,JDK9都不知道做了啥改进,JDK10也才发布不久,JDK11又要来了”。其实Oracle用了近3年时间才发布了Java8,从7到8,在Java史上也是比较有代表意义的一次改进,其中的很多特性都让java在和其他语言争夺“哪种语言是最好的”问题上增加了说话的资本,下面我们一一道来。
1.Lambda expressions
首先我们说说Lambda表达式,这里首先提及一个概念叫函数接口,其实就是只包含一个抽象方法的接口,例如我们的Runnable接口,只有run抽象方法。开发者可以用Lambda来传递行为,大家都知道在Java开发中,类和对象是我们首先要考虑的,我们没法直接传递行为,我们只有通过对象包含一个行为进行传递,用lambda就可以让开发人员更专注于业务的开发上,不用每次都写接口和类,而且他还有很多特异功能,例如类型推断、闭包等等,可以让你的代码更优雅,但是Java语言的要求是类才是第一公民,这一点是融入骨子里的,解决不了的,那怎么办?Oracle那帮人很聪明,定义了一些类型来持有lambda表达式,Java里提供了Predicate/Consumer/Function/Supplier/BinaryOperator等类型,他们都在java.util.function下,这些类是不是看起来有些熟悉,在Guava里也是存在的,Google那帮大牛觉得Java的发布太慢了,他们借助匿名类和泛型实现了一套近似lambda的组件,但是使用过的同学肯定深有感触,你会发现用这种方式实现的代码冗长、混乱、可读性差而且非常低效,因为他仅仅是对Java的一层包装而已。
“talk is cheap,show me the code”,让我们来看一个例子:
// 这是提交一个任务到线程池
AsyncTaskManager.submit(new Runnable() {
@Override
public void run() {
checkSuddenInfoWithZip(infoData, param);
}
});
在这个实现中,infoData和param一定要是声明成final的,不过这种要求也是应该的,对业务逻辑也没啥影响,但是我们要写大量的样板式代码,很繁琐,用lambda写起来是这样的:
AsyncTaskManager.submit(() -> checkSuddenInfoWithZip(infoData, param));
在这里,你关注的将只是run里面的逻辑,而不用去关心这个对象是什么,lambda里不需要你一定使用final变量,只要变量在事实上是final的就可以使用!
再举个例子,你有个计算器程序,可以支持加减乘除,你一定会这么做:
public Integer execute(Integer left, Integer right, Operate<Integer, Integer> object) {
return object.operate(left, right);
}
public static void main(String[] args) {
// addition
execute(1,1,new Operate<Integer, Integer>() {
@Override
public Integer operate(Integer left, Integer right) {
return left + right;
}
});
// subtraction
execute(1,1,new Operate<Integer, Integer>() {
@Override
public Integer operate(Integer left, Integer right) {
return left - right;
}
});
}
public interface Operate<T, T> {
T operate(T left, T right);
}
为了实现这个功能,你要建一个Operate接口来定义操作行为,然后在执行的地方new个对象出来,这就是前面说的没法传递行为,你得用对象包裹着,换了lambda就这样写了
public static Integer execute(Integer left, Integer right, BinaryOperator<Integer> object) {
return object.apply(left, right);
}
public static void main(String[] args) {
execute(1, 1, (left, right) -> left + right);
execute(1, 1, (left, right) -> left - right);
}
我们不用定义接口来持有行为,我们的jvm也不用加载Operate接口,这里只有一个操作类型,你可能看上去一样,都要加载一个Class,但是如果还有类似的行为,你还要写更多的接口,加载更多的类,而lambda里只需要加载BinaryOperator这一个类就可以了,后面我们说到Stream再看看lambda的好处。、
对了,这里还有个非常方便的利器叫方法引用,方法引用其实就是用来简写lambda表达式中的方法,例如我们的Person类有个静态的compare方法
public static int compare(Person a, Person b) {
return a.age.compareTo(b.age);
}
执行排序的时候可以:
Arrays.sort(personList, Person::compare);
同样,System.out.printlin可以用在stream遍历的时候打印字符串:
list.forEach(System.out::println);
2.类型推断的增强
泛型可以做到参数化类型,使代码的可扩展性大大增强,但是在Java8之前,方法内套用泛型方法,是无法识别的,你需要显示的赋值给一个具体类型变量,才能推断出来真实类型,而在Java8里不再需要这样做:
public class Value<T> {
public static <T> T defaultValue() {
return null;
}
public T getOrDefault(T value, T defaultValue) {
return (value != null) ? value : defaultValue;
}
public static void main(String[] args) {
final Value<String> value = new Value<>();
value.getOrDefault("22", Value.defaultValue());// jdk7这里会报错,怎么样,java8是不是很智能
}
}
3.Stream
终于说到Stream了,该特性的引入可以说是Java史上最厉害的完善,没有之一!她可以让开发者能够快速写出更加有效、简洁和紧凑的代码。
流的主要思想是将外部迭代改为内部迭代,开发者只需关注迭代的动作而不用关心如何迭代。我们每次迭代Collection时,都要写样板式的for循环,甚至几层嵌套,让代码的可读性差到令人发指,稍有不慎就会出错。
举个例子来冲击一下你的思维:我们的客户端长连接系统会打包司机心跳数据并通过MQ发送给各业务方,假设现在是100个心跳一个包,业务上现在需要判断,筛选出杭州司机的心跳点,我们会这么做
List<Location> filterResult = new ArrayList<>();
for (Location hb:heartbeats) {
if (hb.cityId.equals("hangzhou")) {
filterResult.add(hb);
}
}
现在需求改了,我们还要加限制,是要杭州男司机的心跳:
List<Location> filterResult = new ArrayList<>();
for (Location hb:heartbeats) {
if (hb.cityId.equals("hangzhou") && hb.sex.equals("male")) {
filterResult.add(hb);
}
}
突然,tcp说我们现在逻辑变了,每个包里有1000个心跳点了,此时,你怎么办?还这样顺序处理1000个么?假设tcp包里有10000了呢?将这份代码改成并发处理,相信很多人都能做到,但是很麻烦。
现在看看Stream会怎么做:
heartbeats.stream().filter(hb -> hb.cityId.equals("haengzhou").collect(Collectors.toList());修改后增加属性判断后:
heartbeats.stream().filter(hb -> hb.cityId.equals("hangzhou") && hb.sex.equals("male")).collect(Collectors.toList());修改并发后:
heartbeats.parallelStream().filter(hb -> hb.cityId.equals("hangzhou") || hb.sex.equals("male")).collect(Collectors.toList());
代码看起来是不是简洁很多?一眼看去就知道是过滤(filter)出来杭州的男性司机!有没有感受到lambda带来的好处?把迭代的过程交给jvm吧,你要做的只是选择迭代规则。
假设我们又来新业务了,需要收集心跳里的各城市心跳数量统计,形如list->map<hangzhou,100>这样的结构,老的方式应该要
Map<City, Integer> count = new Hashmap<>();
for (Location hb:heartbeats) {
Integer cityCount = count.get(hb.cityId);
if (cityCount == null) {
count.put(hb.cityId, 1);
} else {
count.put(hb.cityId, cityCount+1);
}
}
这里穿插一个新功能,Java8里的Hashmap增加了例如getOrDefault/putIfAbsent/computeIfAbsent/computeIfPresent等方法来简化我们的代码,上面的get就可以用getOrDefault(hb.cityId, 0)来替代。
而lambda里就没这么麻烦了:
Map<City, Integer> count = heartbeats.stream().collect(Collectors.groupingBy(hb -> hb.getCityId(), Collectors.counting()));
有没有觉得很棒,能用一行代码解决的事,绝对不会用两行!我们从循环里逃出来了,只需要关注循环内的逻辑,关注怎么处理我的每个对象就可以了。
Filter、Transfer、Convert是函数式编程里比较重要的三个利器!映射到Java8里就是filter、map、collect。
Stream里有个非常重要的概念——惰性求值,这个概念就类似于Builder模式,只有到最后一步遇到调用build方法时,才会去组装对象,Stream里也一样,只要是返回stream对象的方法,都是惰性的,就不会真正执行运算,直到遇到返回非stream对象的方法,这种方法有自己的名字,有的地方叫“及早求值”,有的叫“严格求值”,都是一个意思,这样做的好处是jvm会给你优化执行过程,不会做多余的遍历运算,例如以下两个语句的执行过程是一样的:
xx.stream().filter(hb -> hb.cityId.equals("hangzhou") && hb.sex.equals("male")).collect(Collectors.toList());
xx.stream().filter(hb -> hb.cityId.equals("hangzhou")).filter(hb -> hb.sex.equals("male")).collect(Collectors.toList());
Stream提供了filter、sort、map、match、count、reduce等等很多功能,可以满足大家日常所有的开发需要,用stream的好处显而易见,所以不要再自己写循环了,用优雅、可读性高的Stream+lambda来替代吧!
刚刚一直在说list接口的stream方法,按照惯例,接口里增加了方法,实现类里应该都要增加实现的,如果我们在业务里实现了我们自己的一种AbcdList,如果直接升级Java8,岂不是编译就报错了?Oracle那帮大牛怎么解决你自己实现的List能兼容新加的stream方法呢?Java从一开始就声称要“永远向下兼容”,就是这句话,把自己带坑里了,哈哈!开玩笑的。。。回归正题,怎么解决呢?他们在接口里增加了一个特性-默认方法
4.默认方法
默认方法可以做到在不破坏二进制兼容性的前提下,给接口增加方法,就是不强制那些实现了该接口的类也同时实现这个新加的方法。
@FunctionalInterface
public interface FunctionalDefaultMethods {
void method();
default void defaultMethod() {
System.out.println("this is default method!");
}
}
这个特性在多态里用起来非常爽,当需要增加某个特性的时候,再也不用给每个实现类增加样板式的方法了,特别是例如命令模式时,增加了一个命令,你要给每个实现类增加抛NotSupport异常的样板代码,现在你只要在接口里做默认实现抛NotSupport异常就可以了,所有的实现类将自动继承这种实现!现在脑海中是不是回想起当初一个类一个类的加NotSupport的痛苦日子了。
接口的默认方法还有什么好处呢?它间接的解决了多重继承问题,但是Java8里的这种多重继承更倾向于解决的是代码块的继承,而不是对象状态的继承,这一点也完美避开了多重继承导致的二义性等一系列诟病。
5.Optional
Optional主要是用来替换null值的,使用他的目的主要是提示开发者使用之前要检查是否为空,避免NPE的发生!其实这个概念早在之前就出现在了Guava里,Google那帮大牛又一次教会我们:觉得不爽,咱们就自己干!
其实现在应用更多的应该还是Guava的Optional,特别是在对外api接口上,因为你没法要求你的调用方升级到1.8,但是你可以让他们去依赖Guava,当然,系统内部随便你用哪个,开心就好!
6.结束
Java8的主要功能就先介绍到这里,其他的一些改进,例如Hashmap和ConcurrentHashmap的改进、新引入的Date-time api、注解的扩展、Nashorn JavaScript引擎等特性也很不错,不过有的应用的场景比较特殊,就不一一介绍了。
如果深究Java8算不算函数式的,众说纷纭,纠结来纠结去也没啥意义,我个人觉得:如果我可以用函数式的思维来做逻辑实现,而且用起来爽、结构清晰,这就足够了,管他是什么语言,下一篇我们就一起探讨一下函数式编程,以及如何改变我们的编程思维,从命令式到函数式的蜕变!
Java8跑起来吧,你的升级总不能比Java版本的升级节奏还慢吧~~~
这里有IT新同学交流群: