本文github地址html
Java8为容器新增一些有用的方法,这些方法有些是为完善原有功能,有些是为引入函数式编程(Lambda表达式),学习和使用这些方法有助于咱们写出更加简洁有效的代码.本文分别以ArrayList和HashMap为例,讲解Java8集合框架(Java Collections Framework)中新加入方法的使用.java
咱们先从最熟悉的Java集合框架(Java Collections Framework, JCF)开始提及。git
为引入Lambda表达式,Java8新增了java.util.funcion
包,里面包含经常使用的函数接口,这是Lambda表达式的基础,Java集合框架也新增部分接口,以便与Lambda表达式对接。程序员
首先回顾一下Java集合框架的接口继承结构:github
上图中绿色标注的接口类,表示在Java8中加入了新的接口方法,固然因为继承关系,他们相应的子类也都会继承这些新方法。下表详细列举了这些方法。编程
接口名 | Java8新加入的方法 |
---|---|
Collection | removeIf() spliterator() stream() parallelStream() forEach() |
List | replaceAll() sort() |
Map | getOrDefault() forEach() replaceAll() putIfAbsent() remove() replace() computeIfAbsent() computeIfPresent() compute() merge() |
这些新加入的方法大部分要用到java.util.function
包下的接口,这意味着这些方法大部分都跟Lambda表达式相关。咱们将逐一学习这些方法。markdown
如上所示,接口Collection
和List
新加入了一些方法,咱们以是List
的子类ArrayList
为例来讲明。了解Java7ArrayList
实现原理,将有助于理解下文。多线程
该方法的签名为void forEach(Consumer<? super E> action)
,做用是对容器中的每一个元素执行action
指定的动做,其中Consumer
是个函数接口,里面只有一个待实现方法void accept(T t)
(后面咱们会看到,这个方法叫什么根本不重要,你甚至不须要记忆它的名字)。app
需求:假设有一个字符串列表,须要打印出其中全部长度大于3的字符串.框架
Java7及之前咱们能够用加强的for循环实现:
// 使用曾强for循环迭代 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); for(String str : list){ if(str.length()>3) System.out.println(str); }
// 使用曾强for循环迭代 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); for(String str : list){ if(str.length()>3) System.out.println(str); }
如今使用forEach()
方法结合匿名内部类,能够这样实现:
// 使用forEach()结合匿名内部类迭代 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.forEach(new Consumer<String>(){ @Override public void accept(String str){ if(str.length()>3) System.out.println(str); } });
// 使用forEach()结合匿名内部类迭代 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.forEach(new Consumer<String>(){ @Override public void accept(String str){ if(str.length()>3) System.out.println(str); } });
上述代码调用forEach()
方法,并使用匿名内部类实现Comsumer
接口。到目前为止咱们没看到这种设计有什么好处,可是不要忘记Lambda表达式,使用Lambda表达式实现以下:
// 使用forEach()结合Lambda表达式迭代 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.forEach( str -> { if(str.length()>3) System.out.println(str); });
// 使用forEach()结合Lambda表达式迭代 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.forEach( str -> { if(str.length()>3) System.out.println(str); });
上述代码给forEach()
方法传入一个Lambda表达式,咱们不须要知道accept()
方法,也不须要知道Consumer
接口,类型推导帮咱们作了一切。
该方法签名为boolean removeIf(Predicate<? super E> filter)
,做用是删除容器中全部知足filter
指定条件的元素,其中Predicate
是一个函数接口,里面只有一个待实现方法boolean test(T t)
,一样的这个方法的名字根本不重要,由于用的时候不须要书写这个名字。
需求:假设有一个字符串列表,须要删除其中全部长度大于3的字符串。
咱们知道若是须要在迭代过程冲对容器进行删除操做必须使用迭代器,不然会抛出ConcurrentModificationException
,因此上述任务传统的写法是:
// 使用迭代器删除列表元素 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); Iterator<String> it = list.iterator(); while(it.hasNext()){ if(it.next().length()>3) // 删除长度大于3的元素 it.remove(); }
// 使用迭代器删除列表元素 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); Iterator<String> it = list.iterator(); while(it.hasNext()){ if(it.next().length()>3) // 删除长度大于3的元素 it.remove(); }
如今使用removeIf()
方法结合匿名内部类,咱们但是这样实现:
// 使用removeIf()结合匿名名内部类实现 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.removeIf(new Predicate<String>(){ // 删除长度大于3的元素 @Override public boolean test(String str){ return str.length()>3; } });
// 使用removeIf()结合匿名名内部类实现 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.removeIf(new Predicate<String>(){ // 删除长度大于3的元素 @Override public boolean test(String str){ return str.length()>3; } });
上述代码使用removeIf()
方法,并使用匿名内部类实现Precicate
接口。相信你已经想到用Lambda表达式该怎么写了:
// 使用removeIf()结合Lambda表达式实现 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.removeIf(str -> str.length()>3); // 删除长度大于3的元素
// 使用removeIf()结合Lambda表达式实现 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.removeIf(str -> str.length()>3); // 删除长度大于3的元素
使用Lambda表达式不须要记忆Predicate
接口名,也不须要记忆test()
方法名,只须要知道此处须要一个返回布尔类型的Lambda表达式就好了。
该方法签名为void replaceAll(UnaryOperator<E> operator)
,做用是对每一个元素执行operator
指定的操做,并用操做结果来替换原来的元素。其中UnaryOperator
是一个函数接口,里面只有一个待实现函数T apply(T t)
。
需求:假设有一个字符串列表,将其中全部长度大于3的元素转换成大写,其他元素不变。
Java7及以前彷佛没有优雅的办法:
// 使用下标实现元素替换 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); for(int i=0; i<list.size(); i++){ String str = list.get(i); if(str.length()>3) list.set(i, str.toUpperCase()); }
// 使用下标实现元素替换 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); for(int i=0; i<list.size(); i++){ String str = list.get(i); if(str.length()>3) list.set(i, str.toUpperCase()); }
使用replaceAll()
方法结合匿名内部类能够实现以下:
// 使用匿名内部类实现 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.replaceAll(new UnaryOperator<String>(){ @Override public String apply(String str){ if(str.length()>3) return str.toUpperCase(); return str; } });
// 使用匿名内部类实现 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.replaceAll(new UnaryOperator<String>(){ @Override public String apply(String str){ if(str.length()>3) return str.toUpperCase(); return str; } });
上述代码调用replaceAll()
方法,并使用匿名内部类实现UnaryOperator
接口。咱们知道能够用更为简洁的Lambda表达式实现:
// 使用Lambda表达式实现 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.replaceAll(str -> { if(str.length()>3) return str.toUpperCase(); return str; });
// 使用Lambda表达式实现 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.replaceAll(str -> { if(str.length()>3) return str.toUpperCase(); return str; });
该方法定义在List
接口中,方法签名为void sort(Comparator<? super E> c)
,该方法根据c
指定的比较规则对容器元素进行排序。Comparator
接口咱们并不陌生,其中有一个方法int compare(T o1, T o2)
须要实现,显然该接口是个函数接口。
需求:假设有一个字符串列表,按照字符串长度增序对元素排序。
因为Java7以及以前sort()
方法在Collections
工具类中,因此代码要这样写:
// Collections.sort()方法 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); Collections.sort(list, new Comparator<String>(){ @Override public int compare(String str1, String str2){ return str1.length()-str2.length(); } });
// Collections.sort()方法 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); Collections.sort(list, new Comparator<String>(){ @Override public int compare(String str1, String str2){ return str1.length()-str2.length(); } });
如今能够直接使用List.sort()方法
,结合Lambda表达式,能够这样写:
// List.sort()方法结合Lambda表达式 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.sort((str1, str2) -> str1.length()-str2.length());
// List.sort()方法结合Lambda表达式 ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too")); list.sort((str1, str2) -> str1.length()-str2.length());
方法签名为Spliterator<E> spliterator()
,该方法返回容器的可拆分迭代器。从名字来看该方法跟iterator()
方法有点像,咱们知道Iterator
是用来迭代容器的,Spliterator
也有相似做用,但两者有以下不一样:
Spliterator
既能够像Iterator
那样逐个迭代,也能够批量迭代。批量迭代能够下降迭代的开销。Spliterator
是可拆分的,一个Spliterator
能够经过调用Spliterator<T> trySplit()
方法来尝试分红两个。一个是this
,另外一个是新返回的那个,这两个迭代器表明的元素没有重叠。可经过(屡次)调用Spliterator.trySplit()
方法来分解负载,以便多线程处理。
stream()
和parallelStream()
分别返回该容器的Stream
视图表示,不一样之处在于parallelStream()
返回并行的Stream
。Stream
是Java函数式编程的核心类,咱们会在后面章节中学习。
相比Collection
,Map
中加入了更多的方法,咱们以HashMap
为例来逐一探秘。了解Java7HashMap
实现原理,将有助于理解下文。
该方法签名为void forEach(BiConsumer<? super K,? super V> action)
,做用是对Map
中的每一个映射执行action
指定的操做,其中BiConsumer
是一个函数接口,里面有一个待实现方法void accept(T t, U u)
。BinConsumer
接口名字和accept()
方法名字都不重要,请不要记忆他们。
需求:假设有一个数字到对应英文单词的Map,请输出Map中的全部映射关系.
Java7以及以前经典的代码以下:
// Java7以及以前迭代Map HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); for(Map.Entry<Integer, String> entry : map.entrySet()){ System.out.println(entry.getKey() + "=" + entry.getValue()); }
// Java7以及以前迭代Map HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); for(Map.Entry<Integer, String> entry : map.entrySet()){ System.out.println(entry.getKey() + "=" + entry.getValue()); }
使用Map.forEach()
方法,结合匿名内部类,代码以下:
// 使用forEach()结合匿名内部类迭代Map HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.forEach(new BiConsumer<Integer, String>(){ @Override public void accept(Integer k, String v){ System.out.println(k + "=" + v); } });
// 使用forEach()结合匿名内部类迭代Map HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.forEach(new BiConsumer<Integer, String>(){ @Override public void accept(Integer k, String v){ System.out.println(k + "=" + v); } });
上述代码调用forEach()
方法,并使用匿名内部类实现BiConsumer
接口。固然,实际场景中没人使用匿名内部类写法,由于有Lambda表达式:
// 使用forEach()结合Lambda表达式迭代Map HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.forEach((k, v) -> System.out.println(k + "=" + v)); }
// 使用forEach()结合Lambda表达式迭代Map HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.forEach((k, v) -> System.out.println(k + "=" + v)); }
该方法跟Lambda表达式不要紧,可是颇有用。方法签名为V getOrDefault(Object key, V defaultValue)
,做用是按照给定的key
查询Map
中对应的value
,若是没有找到则返回defaultValue
。使用该方法程序员能够省去查询指定键值是否存在的麻烦.
需求;假设有一个数字到对应英文单词的Map,输出4对应的英文单词,若是不存在则输出NoValue
// 查询Map中指定的值,不存在时使用默认值 HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // Java7以及以前作法 if(map.containsKey(4)){ // 1 System.out.println(map.get(4)); }else{ System.out.println("NoValue"); } // Java8使用Map.getOrDefault() System.out.println(map.getOrDefault(4, "NoValue")); // 2
// 查询Map中指定的值,不存在时使用默认值 HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // Java7以及以前作法 if(map.containsKey(4)){ // 1 System.out.println(map.get(4)); }else{ System.out.println("NoValue"); } // Java8使用Map.getOrDefault() System.out.println(map.getOrDefault(4, "NoValue")); // 2
该方法跟Lambda表达式不要紧,可是颇有用。方法签名为V putIfAbsent(K key, V value)
,做用是只有在不存在key
值的映射或映射值为null
时,才将value
指定的值放入到Map
中,不然不对Map
作更改.该方法将条件判断和赋值合二为一,使用起来更加方便.
咱们都知道Map
中有一个remove(Object key)
方法,来根据指定key
值删除Map
中的映射关系;Java8新增了remove(Object key, Object value)
方法,只有在当前Map
中key
正好映射到value
时才删除该映射,不然什么也不作.
在Java7及之前,要想替换Map
中的映射关系可经过put(K key, V value)
方法实现,该方法老是会用新值替换原来的值.为了更精确的控制替换行为,Java8在Map
中加入了两个replace()
方法,分别以下:
replace(K key, V value)
,只有在当前Map
中key
的映射存在时才用value
去替换原来的值,不然什么也不作.replace(K key, V oldValue, V newValue)
,只有在当前Map
中key
的映射存在且等于oldValue
时才用newValue
去替换原来的值,不然什么也不作.该方法签名为replaceAll(BiFunction<? super K,? super V,? extends V> function)
,做用是对Map
中的每一个映射执行function
指定的操做,并用function
的执行结果替换原来的value
,其中BiFunction
是一个函数接口,里面有一个待实现方法R apply(T t, U u)
.不要被如此多的函数接口吓到,由于使用的时候根本不须要知道他们的名字.
需求:假设有一个数字到对应英文单词的Map,请将原来映射关系中的单词都转换成大写.
Java7以及以前经典的代码以下:
// Java7以及以前替换全部Map中全部映射关系 HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); for(Map.Entry<Integer, String> entry : map.entrySet()){ entry.setValue(entry.getValue().toUpperCase()); }
// Java7以及以前替换全部Map中全部映射关系 HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); for(Map.Entry<Integer, String> entry : map.entrySet()){ entry.setValue(entry.getValue().toUpperCase()); }
使用replaceAll()
方法结合匿名内部类,实现以下:
// 使用replaceAll()结合匿名内部类实现 HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.replaceAll(new BiFunction<Integer, String, String>(){ @Override public String apply(Integer k, String v){ return v.toUpperCase(); } });
// 使用replaceAll()结合匿名内部类实现 HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.replaceAll(new BiFunction<Integer, String, String>(){ @Override public String apply(Integer k, String v){ return v.toUpperCase(); } });
上述代码调用replaceAll()
方法,并使用匿名内部类实现BiFunction
接口。更进一步的,使用Lambda表达式实现以下:
// 使用replaceAll()结合Lambda表达式实现 HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.replaceAll((k, v) -> v.toUpperCase());
// 使用replaceAll()结合Lambda表达式实现 HashMap<Integer, String> map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.replaceAll((k, v) -> v.toUpperCase());
简洁到让人难以置信.
该方法签名为merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
,做用是:
Map
中key
对应的映射不存在或者为null
,则将value
(不能是null
)关联到key
上;remappingFunction
,若是执行结果非null
则用该结果跟key
关联,不然在Map
中删除key
的映射.参数中BiFunction
函数接口前面已经介绍过,里面有一个待实现方法R apply(T t, U u)
.
merge()
方法虽然语义有些复杂,但该方法的用方式很明确,一个比较常见的场景是将新的错误信息拼接到原来的信息上,好比:
map.merge(key, newMsg, (v1, v2) -> v1+v2);
map.merge(key, newMsg, (v1, v2) -> v1+v2);
该方法签名为compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
,做用是把remappingFunction
的计算结果关联到key
上,若是计算结果为null
,则在Map
中删除key
的映射.
要实现上述merge()
方法中错误信息拼接的例子,使用compute()
代码以下:
map.compute(key, (k,v) -> v==null ? newMsg : v.concat(newMsg));
map.compute(key, (k,v) -> v==null ? newMsg : v.concat(newMsg));
该方法签名为V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
,做用是:只有在当前Map
中不存在key
值的映射或映射值为null
时,才调用mappingFunction
,并在mappingFunction
执行结果非null
时,将结果跟key
关联.
Function
是一个函数接口,里面有一个待实现方法R apply(T t)
.
computeIfAbsent()
经常使用来对Map
的某个key
值创建初始化映射.好比咱们要实现一个多值映射,Map
的定义多是Map<K,Set<V>>
,要向Map
中放入新值,可经过以下代码实现:
Map<Integer, Set<String>> map = new HashMap<>(); // Java7及之前的实现方式 if(map.containsKey(1)){ map.get(1).add("one"); }else{ Set<String> valueSet = new HashSet<String>(); valueSet.add("one"); map.put(1, valueSet); } // Java8的实现方式 map.computeIfAbsent(1, v -> new HashSet<String>()).add("yi");
Map<Integer, Set<String>> map = new HashMap<>(); // Java7及之前的实现方式 if(map.containsKey(1)){ map.get(1).add("one"); }else{ Set<String> valueSet = new HashSet<String>(); valueSet.add("one"); map.put(1, valueSet); } // Java8的实现方式 map.computeIfAbsent(1, v -> new HashSet<String>()).add("yi");
使用computeIfAbsent()
将条件判断和添加操做合二为一,使代码更加简洁.
该方法签名为V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
,做用跟computeIfAbsent()
相反,即,只有在当前Map
中存在key
值的映射且非null
时,才调用remappingFunction
,若是remappingFunction
执行结果为null
,则删除key
的映射,不然使用该结果替换key
原来的映射.
这个函数的功能跟以下代码是等效的:
// Java7及之前跟computeIfPresent()等效的代码 if (map.get(key) != null) { V oldValue = map.get(key); V newValue = remappingFunction.apply(key, oldValue); if (newValue != null) map.put(key, newValue); else map.remove(key); return newValue; } return null;
// Java7及之前跟computeIfPresent()等效的代码 if (map.get(key) != null) { V oldValue = map.get(key); V newValue = remappingFunction.apply(key, oldValue); if (newValue != null) map.put(key, newValue); else map.remove(key); return newValue; } return null;