浅谈Java 8 API增强
文章目录[隐藏]
Collection
removeIf方法
众所周知，对于List、Set等集合而言，如果期望删除某些元素，其实是一件非常麻烦的事情。例如下面的示例，删除列表中长度大于2的元素。
public static void main(String[] args) {
List<String> list = new LinkedList<>();
list.add("乒乓球");
list.add("足球");
list.add("羽毛球");
list.add("篮球");
System.out.println("list（前）: " + list);
list.forEach(e -> {
// 移除长度大于2的元素
if(e.length()>2 ) {
list.remove(e);
}
});
System.out.println("list（后）: " + list);
}
结果显然易见，如下所示，删除失败。原因自然是不言自明。在迭代器遍历过程中，通过list.remove方法进行删除是不允许的。除非我们显式使用迭代器进行遍历、删除，显然这样非常繁琐。
list（前）: [乒乓球, 足球, 羽毛球, 篮球] Exception in thread "main" java.util.ConcurrentModificationException at java.util.LinkedList$ListItr.checkForComodification(LinkedList.java:966) at java.util.LinkedList$ListItr.next(LinkedList.java:888) at java.lang.Iterable.forEach(Iterable.java:74) at com.jhtsoft.component.test.main(test.java:22)
因此Java8在Collection中提供removeIf默认方法，其接收一个谓词参数。大大方便了我们对集合进行删除的操作，示例如下所示
public static void main(String[] args) {
List<String> list = new LinkedList<>();
list.add("乒乓球");
list.add("足球");
list.add("羽毛球");
list.add("篮球");
System.out.println("list（前）: " + list);
// 移除长度大于2的元素
list.removeIf(e -> e.length()>2 );
System.out.println("list（后）: " + list);
}
测试结果如下，符合预期
list（前）: [乒乓球, 足球, 羽毛球, 篮球] list（后）: [足球, 篮球]
Map
计算模式
在Map中可以根据Key存在与否的情况，按条件执行相关操作并将计算结果作为Value存储到Map中。具体有以下方法：
- compute：使用指定的Key计算新值，并将计算结果作为Value存储到Map中
- computeIfAbsent：如果指定Key在Map中没有对应的值(Key不存在 或 其值为null), 则计算该Key的新值并存储到Map中
- computeIfPresent：如果指定Key在Map中有对应的值(Key存在 且 其值不为null),则计算该Key的新值并存储到Map中
compute方法
比如下面的代码，是一个统计单词次数的方法
public static void main(String[] args) {
// 每个单词出现的次数, key: 单词; value: 次数
Map<String, Integer> map = new HashMap<>();
String doc = "I am Aaron I like Aaron";
String[] words = doc.split(" ");
for(String word : words) {
Integer count = map.get(word);
if( count==null ) {
count = 0;
}
count++;
map.put(word, count);
}
System.out.println("map : " + map);
}
如果采用compute方法则可以大大简化代码，如下所示。利用Key及其Value进行计算，并将计算结果作为该Key的新值存储到Map中
public static void main(String[] args) {
// 每个单词出现的次数, key: 单词; value: 次数
Map<String, Integer> map = new HashMap<>();
String doc = "I am Aaron I like Aaron";
String[] words = doc.split(" ");
for(String word : words) {
map.compute( word, (key, oldValue) ->{
if( oldValue==null ) {
oldValue = 0;
}
oldValue++;
return oldValue;
});
}
System.out.println("<Test 2> map : " + map);
}
两个方法测试结果如下，符合预期
第1个执行结果：
map : {Aaron=2, like=1, I=2, am=1}
第二个执行结果：
<Test 2> map : {Aaron=2, like=1, I=2, am=1}
computeIfAbsent方法
下面是一个在Map中保存各人所喜欢的书单的方法。每次在向value中添加书时，都需要判断该value是否为空，非常繁琐
public static void main(String[] args) {
// 每个人喜欢的书单, key: 人名; value: 书名列表
Map<String, List<String>> map = new HashMap<>();
// 场景: 给Amy喜欢的书单添加《老人与海》
String name = "Amy";
String bookName = "老人与海";
List list = map.get(name);
if( list==null ) {
list = new LinkedList<>();
map.put(name, list);
}
list.add(bookName);
System.out.println("<Test 1> map : " + map);
}
幸运的是，在有了computeIfAbsent方法后，我们实现起来就简洁很多
public static void main(String[] args) {
// 每个人喜欢的书单, key: 人名; value: 书名列表
Map<String, List<String>> map = new HashMap<>();
// 场景: 给Amy喜欢的书单添加《老人与海》
String name = "Amy";
String bookName = "老人与海";
// 如果map中 key不存在 或 key所对应的值为null
// 则会通过第二个参数 function 计算新value，并put到map中
// 该方法最终会返回该key所对应的value值
List<String> list = map.computeIfAbsent( name, key -> new LinkedList<>() );
list.add(bookName);
System.out.println("<Test 2> map : " + map);
}
可以看到，computeIfAbsent方法非常适用于value为集合类型、且需要向该集合中添加元素的场景。测试结果如下，符合预期
第1个执行结果：
<Test 1> map : {Amy=[老人与海]}
第二个执行结果：
<Test 2> map : {Amy=[老人与海]}
与此同时，computeIfAbsent方法也适用于缓存信息的场景。在下面的示例中，对于已有签名数据作为Value的Key，显然没有必要重复计算、浪费资源
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
System.out.println("\n-------------------- Test 1: Start --------------------");
map.computeIfAbsent("China", test::calcSign);
System.out.println("-------------------- Test 1: End ----------------------");
System.out.println("\n-------------------- Test 2: Start --------------------");
map.computeIfAbsent("USA", test::calcSign);
System.out.println("-------------------- Test 2: End ----------------------");
System.out.println("\n-------------------- Test 3: Start --------------------");
map.computeIfAbsent("China", test::calcSign);
System.out.println("-------------------- Test 3: End ----------------------");
System.out.println("\nmap: " + map);
}
/**
* 计算签名
*
* @param str
* @return
*/
private static Integer calcSign(String str) {
System.out.println("Start Calc Sign, str: " + str);
Integer result = str.hashCode();
return result;
}
测试结果如下，符合预期
-------------------- Test 1: Start --------------------
Start Calc Sign, str: China
-------------------- Test 1: End ----------------------
-------------------- Test 2: Start --------------------
Start Calc Sign, str: USA
-------------------- Test 2: End ----------------------
-------------------- Test 3: Start --------------------
-------------------- Test 3: End ----------------------
map: {USA=84323, China=65078583}
computeIfPresent方法
下面是一个在Map中保存各人所喜欢的书单的方法。每次从value中移除书时，都需要判断该value是否为空，非常繁琐
public static void main(String[] args) {
// 每个人喜欢的书单, key: 人名; value: 书名列表
Map<String, List<String>> map = new HashMap();
// map数据初始化
map.put("Amy", new ArrayList(Arrays.asList("资治通鉴", "金瓶梅", "山海经")));
// 场景: Amy喜欢的书单中不能有《金瓶梅》
String name = "Amy";
String bookName = "金瓶梅";
List<String> list = map.get(name);
if( list!=null ) {
list.remove( bookName );
}
System.out.println("<Test 1> map : " + map);
}
结果符合预期，如下所示
<Test 1> map : {Amy=[资治通鉴, 山海经]}
幸运的是，在有了computeIfPresent方法后，我们实现起来就简洁很多
public static void main(String[] args) {
// 每个人喜欢的书单, key: 人名; value: 书名列表
Map<String, List<String>> map = new HashMap<>();
// map数据初始化
map.put("Amy", new ArrayList(Arrays.asList("资治通鉴", "金瓶梅", "山海经")));
map.put("Bob", new ArrayList(Arrays.asList("三年高考五年模拟")));
map.put("Tony", new ArrayList(Arrays.asList("21天入门理发")));
// 场景: Amy喜欢的书单中不能有《金瓶梅》
String name = "Amy";
String bookName1 = "金瓶梅";
// 如果map中key所对应的value不为null
// 则会通过第二个参数, 利用key、oldValue 计算newValue，并put到map中
// 该方法最终会返回该key所对应的value值
map.computeIfPresent(name, (key, value) -> {
value.remove(bookName1);
return value;
});
// 场景: Bob喜欢的书单中不能有《三年高考五年模拟》
name = "Bob";
String bookName2 = "三年高考五年模拟";
map.computeIfPresent(name, (key, value) -> {
value.remove(bookName2);
return value;
});
// 场景: 用户Tony注销了，不需要再保存其喜欢的书单
name = "Tony";
// 在computeIfPresent方法中， 如果该key计算的newValue为null, 则该映射会被移除
map.computeIfPresent(name, (key, value) -> {
List newValue = null;
return newValue;
});
System.out.println("<Test 2> map : " + map);
}
可以看到，computeIfPresent方法非常适用于value为集合类型、且需要从集合中移除元素的场景。测试结果如下，符合预期。值得一提的是在computeIfPresent方法中，如果该key计算的新值为null, 则该映射会被移除
<Test 2> map : {Bob=[], Amy=[资治通鉴, 山海经]}
merge方法
Map接口提供的默认方法merge，签名如下。其第一、二个参数就是我们期望存储到Map的key、newValue。但如果该key在map已经存在且其值(这里记为oldValue)不为空，则就需要通过 第三个参数(BiFunction类型)，其定义了合并oldValue、newValue这两个值的计算规则
merge(K key, V value,
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
通过下面的例子，可以更好的帮助大家理解
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("Aaron", "篮球");
map.merge("Bob", "足球", (oldValue, newValue) -> oldValue + "&" + newValue);
System.out.println("map 1: " + map);
map.merge("Aaron", "乒乓球", (oldValue, newValue) -> oldValue + "&" + newValue);
System.out.println("map 2: " + map);
}
map 1: {Aaron=篮球, Bob=足球}
map 2: {Aaron=篮球&乒乓球, Bob=足球}
可以看到，由于merge方法对于欲插入的key是否在map中存在不为null的value，实际上是提供了两种不同的计算路径。故对于上文通过compute方法实现次数统计的例子而言，我们如果使用merge方法实现会更加简单，示例代码如下所示
public static void main(String[] args) {
// 每个单词出现的次数, key: 单词; value: 次数
Map<String, Integer> map = new HashMap<>();
String doc = "can Aaron can Aaron like I can like Aaron can";
String[] words = doc.split(" ");
for(String word : words) {
// 该单词在map中value为null,说明该单词首次被统计, 故直接记为1
// 该单词在map中value不为null,说明该单词非首次被统计, 故使用原有次数自增1
map.merge(word, 1, (oldValue, newValue) -> oldValue + 1);
}
System.out.println("<Test 2> map : " + map);
}
测试结果如下，符合预期
<Test 2> map : {Aaron=3, can=4, like=2, I=1}
Optional
orElse与orElseGet
二者都是用于在option实例中value值不存在时，提供一个默认值。
- orElse方法是每次均会计算默认值，无论option实例中value值是否存在；
- orElseGet方法则是延迟计算，即只有在option实例中value值不存在时，才会去计算默认值。
故如果对于默认值的计算、获取过程比较昂贵，推荐使用orElseGet方法
public static void main(String[] args) {
Optional<String> optional1 = Optional.ofNullable("Aaron");
Optional<String> optional2 = Optional.ofNullable(null);
System.out.println("\n-------------------- Test 1: Start --------------------");
String s1 = optional1.orElse(getDefault());
System.out.println("s1: " + s1);
System.out.println("-------------------- Test 1: End ----------------------");
System.out.println("\n-------------------- Test 2: Start --------------------");
String s2 = optional2.orElse(getDefault());
System.out.println("s2: " + s2);
System.out.println("-------------------- Test 2: End ----------------------");
System.out.println("\n-------------------- Test 3: Start --------------------");
s1 = optional1.orElseGet(() -> getDefault());
System.out.println("s1: " + s1);
System.out.println("-------------------- Test 3: End ----------------------");
System.out.println("\n-------------------- Test 4: Start --------------------");
s2 = optional2.orElseGet(() -> getDefault());
System.out.println("s2: " + s2);
System.out.println("-------------------- Test 4: End ----------------------");
}
public static String getDefault() {
System.out.println("call getDefault method");
return "Tony";
}
测试结果如下，符合预期
-------------------- Test 1: Start -------------------- call getDefault method s1: Aaron -------------------- Test 1: End ---------------------- -------------------- Test 2: Start -------------------- call getDefault method s2: Tony -------------------- Test 2: End ---------------------- -------------------- Test 3: Start -------------------- s1: Aaron -------------------- Test 3: End ---------------------- -------------------- Test 4: Start -------------------- call getDefault method s2: Tony -------------------- Test 4: End ----------------------
map与flatMap
Optional的初衷就是为了解决NPE而设计的。比如在传统的代码中，为了防止出现NPE，开发者需要层层判空。示例代码如下所示，这样显然非常繁琐
public static void main(String[] args) {
Person person = getPerson();
String addr = null;
if(person != null) {
Person.Company company = person.getCompany();
if(company != null) {
addr = company.getAddr();
}
}
String tel = null;
if(person != null) {
Person.Company company = person.getCompany();
if(company != null) {
tel = company.getTel();
}
}
System.out.println("addr: " + addr);
System.out.println("tel: " + tel);
}
测试结果如下，符合预期
addr: 广东省 tel: null
而自从有了Optional后，情况就大不一样了。我们可以使用map、flatMap实现层层转化。在整个链式调用过程中一旦某个Optional的value为null，则会返回一个空Optional，继续执行。以免出现NPE
public static void main(String[] args) {
Person person = getPerson();
Optional<Person> optionalPerson = Optional.ofNullable(person);
String addr = optionalPerson.map(Person::getCompany)
.map(Person.Company::getAddr)
.orElse(null);
String tel = optionalPerson.map(Person::getCompany)
.map(Person.Company::getTel)
.orElse(null);
String mother = optionalPerson.flatMap(Person::getFamily)
.map(Person.Family::getMother)
.orElse(null);
String father = optionalPerson.flatMap(Person::getFamily)
.map(Person.Family::getFather)
.orElse(null);
System.out.println("addr: " + addr);
System.out.println("tel: " + tel);
System.out.println("mother: " + mother);
System.out.println("father: " + father);
}
测试结果如下，符合预期
addr: 广东省 tel: null mother: Amy father: null
注意
对于Map接口提供的putIfAbsent默认方法而言，其与computeIfAbsent方法在功能上虽然类似。但有一些不同的地方。
- 首先，computeIfAbsent方法对于value的计算是延迟计算，即只有在key不存在 或 该key在Map中的value为null 时，其才会计算value。而putIfAbsent无论最终是否需要设置该键值对，都会去计算value。所以value的计算如果是一个昂贵的过程，推荐使用延迟计算特性的computeIfAbsent方法；
- 其次，二者返回值不同。computeIfAbsent方法总是会返回该key在map中相应的value值，而putIfAbsent方法，如果 key不存在 或 该key在Map中的value为null 时，会返回null。否则返回该key在map中相应的value值
本站文章主要用于个人学习记录，可能对您有所帮助，仅供参考！
