我们继续看lambda表达式的应用：
public void urlExcuAspect(RpcController controller, Message request, RpcCallback done) { if (Util.isEmpty(request)) { return; } Descriptor descriptor = request.getDescriptorForType(); if (Util.isEmpty(descriptor)) { return; } FieldDescriptor paramMapField = descriptor.findFieldByName("paramMap"); if (Util.isEmpty(paramMapField)) { return; } List > paramList = (List >)request.getField(paramMapField); Map paramMap = new HashMap<>(); paramList.forEach((entry) -> { if (Util.isNotEmpty(entry)) { paramMap.put(entry.getKey(), entry.getValue()); } }); UesServiceUtils.setPublicParamToRequest(paramMap); } 这里仍然是针对一个List接口实例paramList的操作，只不过lambda表达式所操作的函数是Collection的父接口Iterable的默认方法forEach，该方法入参是一个函数式接口Consumer：
/* * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */package java.lang;import java.util.Iterator;import java.util.Objects;import java.util.Spliterator;import java.util.Spliterators;import java.util.function.Consumer;/** * Implementing this interface allows an object to be the target of * the "for-each loop" statement. See * * For-each Loop * * * @paramthe type of elements returned by the iterator * * @since 1.5 * @jls 14.14.2 The enhanced for statement */public interface Iterable { /** * Returns an iterator over elements of type { @code T}. * * @return an Iterator. */ Iterator iterator(); /** * Performs the given action for each element of the { @code Iterable} * until all elements have been processed or the action throws an * exception. Unless otherwise specified by the implementing class, * actions are performed in the order of iteration (if an iteration order * is specified). Exceptions thrown by the action are relayed to the * caller. * * @implSpec * The default implementation behaves as if: *
{ @code * for (T t : this) * action.accept(t); * }* * @param action The action to be performed for each element * @throws NullPointerException if the specified action is null * @since 1.8 */ default void forEach(Consumer action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); } } /** * Creates a { @link Spliterator} over the elements described by this * { @code Iterable}. * * @implSpec * The default implementation creates an * early-binding * spliterator from the iterable's { @code Iterator}. The spliterator * inherits the fail-fast properties of the iterable's iterator. * * @implNote * The default implementation should usually be overridden. The * spliterator returned by the default implementation has poor splitting * capabilities, is unsized, and does not report any spliterator * characteristics. Implementing classes can nearly always provide a * better implementation. * * @return a { @code Spliterator} over the elements described by this * { @code Iterable}. * @since 1.8 */ default Spliteratorspliterator() { return Spliterators.spliteratorUnknownSize(iterator(), 0); }}
先看下静态方法requireNonNull：
/* * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */package java.util;import java.util.function.Supplier;/** * This class consists of { @code static} utility methods for operating * on objects. These utilities include { @code null}-safe or { @code * null}-tolerant methods for computing the hash code of an object, * returning a string for an object, and comparing two objects. * * @since 1.7 */public final class Objects { private Objects() { throw new AssertionError("No java.util.Objects instances for you!"); } /** * Returns { @code true} if the arguments are equal to each other * and { @code false} otherwise. * Consequently, if both arguments are { @code null}, { @code true} * is returned and if exactly one argument is { @code null}, { @code * false} is returned. Otherwise, equality is determined by using * the { @link Object#equals equals} method of the first * argument. * * @param a an object * @param b an object to be compared with { @code a} for equality * @return { @code true} if the arguments are equal to each other * and { @code false} otherwise * @see Object#equals(Object) */ public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); } /** * Returns { @code true} if the arguments are deeply equal to each other * and { @code false} otherwise. * * Two { @code null} values are deeply equal. If both arguments are * arrays, the algorithm in { @link Arrays#deepEquals(Object[], * Object[]) Arrays.deepEquals} is used to determine equality. * Otherwise, equality is determined by using the { @link * Object#equals equals} method of the first argument. * * @param a an object * @param b an object to be compared with { @code a} for deep equality * @return { @code true} if the arguments are deeply equal to each other * and { @code false} otherwise * @see Arrays#deepEquals(Object[], Object[]) * @see Objects#equals(Object, Object) */ public static boolean deepEquals(Object a, Object b) { if (a == b) return true; else if (a == null || b == null) return false; else return Arrays.deepEquals0(a, b); } /** * Returns the hash code of a non-{ @code null} argument and 0 for * a { @code null} argument. * * @param o an object * @return the hash code of a non-{ @code null} argument and 0 for * a { @code null} argument * @see Object#hashCode */ public static int hashCode(Object o) { return o != null ? o.hashCode() : 0; } /** * Generates a hash code for a sequence of input values. The hash * code is generated as if all the input values were placed into an * array, and that array were hashed by calling { @link * Arrays#hashCode(Object[])}. * * This method is useful for implementing {
@link * Object#hashCode()} on objects containing multiple fields. For * example, if an object that has three fields, { @code x}, { @code * y}, and { @code z}, one could write: * * * @Override public int hashCode() { * return Objects.hash(x, y, z); * } *
* * Warning: When a single object reference is supplied, the returned * value does not equal the hash code of that object reference. This * value can be computed by calling { @link #hashCode(Object)}. * * @param values the values to be hashed * @return a hash value of the sequence of input values * @see Arrays#hashCode(Object[]) * @see List#hashCode */ public static int hash(Object... values) { return Arrays.hashCode(values); } /** * Returns the result of calling { @code toString} for a non-{ @code * null} argument and { @code "null"} for a { @code null} argument. * * @param o an object * @return the result of calling { @code toString} for a non-{ @code * null} argument and { @code "null"} for a { @code null} argument * @see Object#toString * @see String#valueOf(Object) */ public static String toString(Object o) { return String.valueOf(o); } /** * Returns the result of calling { @code toString} on the first * argument if the first argument is not { @code null} and returns * the second argument otherwise. * * @param o an object * @param nullDefault string to return if the first argument is * { @code null} * @return the result of calling { @code toString} on the first * argument if it is not { @code null} and the second argument * otherwise. * @see Objects#toString(Object) */ public static String toString(Object o, String nullDefault) { return (o != null) ? o.toString() : nullDefault; } /** * Returns 0 if the arguments are identical and { @code * c.compare(a, b)} otherwise. * Consequently, if both arguments are { @code null} 0 * is returned. * * Note that if one of the arguments is {
@code null}, a { @code * NullPointerException} may or may not be thrown depending on * what ordering policy, if any, the { @link Comparator Comparator} * chooses to have for { @code null} values. * * @param the type of the objects being compared * @param a an object * @param b an object to be compared with { @code a} * @param c the { @code Comparator} to compare the first two arguments * @return 0 if the arguments are identical and { @code * c.compare(a, b)} otherwise. * @see Comparable * @see Comparator */ public static int compare(T a, T b, Comparator c) { return (a == b) ? 0 : c.compare(a, b); } /** * Checks that the specified object reference is not { @code null}. This * method is designed primarily for doing parameter validation in methods * and constructors, as demonstrated below: * * public Foo(Bar bar) { * this.bar = Objects.requireNonNull(bar); * } *
* * @param obj the object reference to check for nullity * @param the type of the reference * @return { @code obj} if not { @code null} * @throws NullPointerException if { @code obj} is { @code null} */ public static T requireNonNull(T obj) { if (obj == null) throw new NullPointerException(); return obj; } /** * Checks that the specified object reference is not { @code null} and * throws a customized { @link NullPointerException} if it is. This method * is designed primarily for doing parameter validation in methods and * constructors with multiple parameters, as demonstrated below: * * public Foo(Bar bar, Baz baz) { * this.bar = Objects.requireNonNull(bar, "bar must not be null"); * this.baz = Objects.requireNonNull(baz, "baz must not be null"); * } *
* * @param obj the object reference to check for nullity * @param message detail message to be used in the event that a { @code * NullPointerException} is thrown * @param the type of the reference * @return { @code obj} if not { @code null} * @throws NullPointerException if { @code obj} is { @code null} */ public static T requireNonNull(T obj, String message) { if (obj == null) throw new NullPointerException(message); return obj; } /** * Returns { @code true} if the provided reference is { @code null} otherwise * returns { @code false}. * * @apiNote This method exists to be used as a * { @link java.util.function.Predicate}, { @code filter(Objects::isNull)} * * @param obj a reference to be checked against { @code null} * @return { @code true} if the provided reference is { @code null} otherwise * { @code false} * * @see java.util.function.Predicate * @since 1.8 */ public static boolean isNull(Object obj) { return obj == null; } /** * Returns { @code true} if the provided reference is non-{ @code null} * otherwise returns { @code false}. * * @apiNote This method exists to be used as a * { @link java.util.function.Predicate}, { @code filter(Objects::nonNull)} * * @param obj a reference to be checked against { @code null} * @return { @code true} if the provided reference is non-{ @code null} * otherwise { @code false} * * @see java.util.function.Predicate * @since 1.8 */ public static boolean nonNull(Object obj) { return obj != null; } /** * Checks that the specified object reference is not { @code null} and * throws a customized { @link NullPointerException} if it is. * * Unlike the method {
@link #requireNonNull(Object, String)}, * this method allows creation of the message to be deferred until * after the null check is made. While this may confer a * performance advantage in the non-null case, when deciding to * call this method care should be taken that the costs of * creating the message supplier are less than the cost of just * creating the string message directly. * * @param obj the object reference to check for nullity * @param messageSupplier supplier of the detail message to be * used in the event that a { @code NullPointerException} is thrown * @param the type of the reference * @return { @code obj} if not { @code null} * @throws NullPointerException if { @code obj} is { @code null} * @since 1.8 */ public static T requireNonNull(T obj, Supplier messageSupplier) { if (obj == null) throw new NullPointerException(messageSupplier.get()); return obj; }} 再重点看Consumer接口：
/* * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */package java.util.function;import java.util.Objects;/** * Represents an operation that accepts a single input argument and returns no * result. Unlike most other functional interfaces, { @code Consumer} is expected * to operate via side-effects. * * This is a functional interface * whose functional method is {
@link #accept(Object)}. * * @param the type of the input to the operation * * @since 1.8 */@FunctionalInterfacepublic interface Consumer { /** * Performs this operation on the given argument. * * @param t the input argument */ void accept(T t); /** * Returns a composed { @code Consumer} that performs, in sequence, this * operation followed by the { @code after} operation. If performing either * operation throws an exception, it is relayed to the caller of the * composed operation. If performing this operation throws an exception, * the { @code after} operation will not be performed. * * @param after the operation to perform after this operation * @return a composed { @code Consumer} that performs in sequence this * operation followed by the { @code after} operation * @throws NullPointerException if { @code after} is null */ default Consumer andThen(Consumer after) { Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; }} 抽象方法accept接收一个对象，然后操作该对象，无需返回任何类型。很简单吧，拿Predicate的test对比一下，test做的是判断，accept做的是操作。举个例子：
Consumerconsumer = (s) -> System.out.println("Hello, " + s.toUpperCase()); consumer.accept("wlf");
这个consumer实例做的就是打印"Hello，wlf"这个操作。再回过来看我们最开始的代码：
paramList.forEach((entry) -> { if (Util.isNotEmpty(entry)) { paramMap.put(entry.getKey(), entry.getValue()); } }); 遍历paramList，从每个MapEntry<String, String>对象中取出key和value，放到paramMap对象中。好了，我们继续看：
Listlist = new ArrayList (); list.add("wlf"); list.add("wms"); list.stream().filter((s) -> s.startsWith("w")).forEach(System.out::println);
最后一行融合之前所有jdk1.8新特性，从List父接口Collection的stream默认方法取得一个Stream，通过Stream的filter进行中间操作（这里的操作就是Predicate的test，判断是否w开头），最后通过List祖父接口Iterable的forEach方法进行最终操作（这里的操作就是Consumer的accept，打印最终list对象）。