类库
随着lambda表达式的标准正式启动后，使得JDK类库特别是Java集合的API进行大幅度的变化。新增了java.util.funcion包，此包中包含常用的函数接口，函数接口是Lambda表达式的基础。集合框架为了和Lambda表达式对接，也增加了接口。所以新增的API大部分都要用到java.util.funcion包下的接口，所以新增的方法和Lambda表达式有关。
Collection中新的方法
forEach()
void forEach(Consumer<? super E> action)
作用：对集合中的每个元素执行action指定的动作，Consumer是一个函数接口。
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t);};
}
}
示例：forEach和Lambda表达式结合使用
ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));list.forEach( str -> { if(str.length()>3) System.out.println(str); });
说明：在此方法中传入一个Lambda表达式，我们都不需要知道accept方法，也不需要知道有Consumer这么个接口。类型推导给我们做了这一切。
removeIf()
boolean removeIf(Predicate<? super E> filter)
作用：删除集合中所有满足filter指定条件的元素。Predicate是一个函数接口。
@FunctionalInterfacepublic interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); }
default Predicate<T> negate() { return (t) -> !test(t); }
default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); }
static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); }
}
示例：removeIf和Lambda表达式结合使用
ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));list.removeIf(str -> str.length()>3);// 删除长度大于3的元素
replaceAll()
void replaceAll(UnaryOperator<E> operator)
作用：对集合中的每个元素执行operator指定的操作，并用操作结果来替换原来的元素。UnaryOperator是一个接口函数
@FunctionalInterfacepublic interface UnaryOperator<T> extends Function<T, T> { static <T> UnaryOperator<T> identity() { return t -> t; }}
示例：replaceAll和Lambda表达式结合使用
ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));list.replaceAll(str -> { if(str.length()>3) return str.toUpperCase(); return str;});
sort()
void sort(Comparator<? super E> c)
作用：定义在List中，根据c指定的比较规则对集合元素进行排序。Comparator是一个函数接口。
示例：
ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));list.sort((str1, str2) -> str1.length()-str2.length()); // 按照字符串长度进行排序
spliterator()
Spliterator<E> spliterator()
作用：返回集合的可拆分迭代器，Spliterator是Iterator的增强版：1，Iterator逐个迭代，Spliterator既可以逐个迭代，又可以批量迭代。批量迭代的好处可以降低迭代的开销。2，Spliterator可拆分，一个Spliterator可以通过调用Spliterator<T> trySplit()方法来尝试分成两个。一个是this，另一个是新返回的那个，这两个迭代器代表的元素没有重叠。这样可以多次调用trySplit来分解集合，多线程来处理。
stream()和parallelStream()
stream()和parallelStream()分别返回该容器的Stream视图表示，parallelStream()返回并行的Stream。
Map中新的方法
forEach()
void forEach(BiConsumer<? super K,? super V> action)
作用：对map中每个映射执行action指定的操作，BiConsumer是一个函数接口。
@FunctionalInterfacepublic interface BiConsumer<T, U> { void accept(T t, U u); default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) { Objects.requireNonNull(after); return (l, r) -> { accept(l, r); after.accept(l, r); }; }}
getOrDefault()
V getOrDefault(Object key, V defaultValue)
作用：和Lambda表达式没什么关系。按照给定的key查询Map中对应的value。如果没有找到则发挥defaultValue。使用该方法可以省去查询指定键值是否存在的麻烦。
putIfAbsent()
V putIfAbsent(K key, V value)
作用：和Lambda表达式没什么关系。只有在不存在key值或映射值为Null时，才将value指定的值放到map中，否则不对map做更改。
remove()
作用：remove(Object key)方法，来根据指定key值删除Map中的映射关系。Java8中增加remove(Object key, Object value)方法，只有在当前Map中key正好映射到value时才删除该映射，否则什么也不做。
replace()
在Java8以前，想替换Map中的映射关系可通过put(K key, V value)方法实现，该方法总是会用新值替换原来的值。Java8在Map中加入了两个replace()方法。
1，replace(K key, V value)：只有在当前Map中key的映射存在时才用value去替换原来的值，否则什么也不做。
2，replace(K key, V oldValue, V newValue)，只有在当前Map中key的映射存在且等于oldValue时才用newValue去替换原来的值，否则什么也不做。
replaceAll()
replaceAll(BiFunction<? super K,? super V,? extends V> function)
作用：对map中的每个映射执行function指定操作，并用function的执行结果替换原来的value。BiFunction是一个函数接口。
@FunctionalInterfacepublic interface BiFunction<T, U, R> { R apply(T t, U u); default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) { Objects.requireNonNull(after); return (T t, U u) -> after.apply(apply(t, u)); }}
merge()
merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
作用：1，如果Map中key对应的映射不存在或者为null，则将value（不能是null）关联到key上。2，否则执行remappingFunction，如果执行结果非null则用该结果跟key关联，否则在Map中删除key的映射。
compute()
compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
作用：把remappingFunction的计算结果关联到key上，如果计算结果为null，则在Map中删除key的映射。
computeIfAbsent()
V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
作用：只有在当前Map中不存在key值的映射或映射值为null时，才调用mappingFunction，并在mappingFunction执行结果非null时，将结果跟key关联。
Function函数接口
@FunctionalInterfacepublic interface Function<T, R> { R apply(T t); default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); } default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); } static <T> Function<T, T> identity() { return t -> t; }}
computeIfPresent()
V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
作用：只有在当前Map中存在key值的映射且非null时，才调用remappingFunction，如果remappingFunction执行结果为null，则删除key的映射，否则使用该结果替换key原来的映射。
内部迭代和外部迭代：集合类库主要依赖于外部迭代。Collection实现Iterable接口，使用户可以一次遍历集合的元素。
for (Shape shape : shapes) { shape.setColor(RED);}
上面的例子是外部迭代，for-each循环调用集合的iterator()方法进行依次遍历。外部迭代是串行的，并且必须按照集合中元素的顺序进行依次处理；集合框架无法对控制流进行优化（排序，并行）。
使用内部迭代代替外部迭代，用户把对迭代的控制权交给类库，并向类库传递迭代时所需的执行代码。
shapes.forEach(s -> s.setColor(RED));
用户把对操作的控制权交还给类库，类库就可以进行各种优化。
外部迭代同时承担了做什么（把形状设为红色）和怎么做（得到Iterator实例然后依次遍历）的职责；内部迭代只负责做什么，而怎么做留给类库处理。
