之前说了jdk1.8几个新特性,这里结合一个实际项目例子,看下这些新特性怎么玩的。直接看代码:
public List<MSG_ConMediaInfo> getConMediaInfoList(String liveType) { if (Util.isEmpty(liveType)) { return null; } List<MSG_ConMediaInfo> conMediaInfoList = getConMediaInfoList(); if (Util.isNotEmpty(conMediaInfoList)) { if (LIVE_TYPE_BEING.equals(liveType)) { return conMediaInfoList.parallelStream() .filter(s -> s != null) .filter(s -> isLiveBeing(s)) .collect(Collectors.toList()); } else if (LIVE_TYPE_PREVIEW.equals(liveType)) { return conMediaInfoList.parallelStream() .filter(s -> s != null) .filter(s -> isLivePreview(s)) .collect(Collectors.toList()); } else { return conMediaInfoList.parallelStream() .filter(s -> s != null) .filter(s -> liveType.equals(s.getLiveStatus())) .collect(Collectors.toList()); } } return null; } private boolean isLiveBeing(MSG_ConMediaInfo conMediaInfo) { String liveStatus = conMediaInfo.getLiveStatus(); if (LIVE_TYPE_BEING.equals(liveStatus)) { return Boolean.TRUE; } if (LIVE_TYPE_PREVIEW.equals(liveStatus)) { if (!isLivePreview(conMediaInfo)) { return Boolean.TRUE; } } return Boolean.FALSE; } private boolean isLivePreview(MSG_ConMediaInfo conMediaInfo) { if (LIVE_TYPE_PREVIEW.equals(conMediaInfo.getLiveStatus())) { String startTime = DateTools.timeTransform(conMediaInfo.getLiveStartTime(), DateTools.DATE_PATTERN_24HOUR_16); int result = DateTools.compare(new Date(), DateTools.timeStr2Date(startTime, DateTools.DATE_PATTERN_24HOUR_16), CompareDateFormate.yyyyMMddhhmmss); //当前时间已超过直播开始时间 if (result != -1) { return Boolean.FALSE; } return Boolean.TRUE; } return Boolean.FALSE; }
这里3个方法,第一个方法使用了lambda表达式,这里是一个List实例conMediaInfoList,通过调用parallelStream方法得到一个Stream接口,再调用它的filter方法,该方法的参数是一个函数式接口Predicate。步步为营,终于绕到函数式接口这个jdk1.8的新特性了。我们知道,lambda表达式使用的前提就是函数式接口。
那么首先让我们来看下Predicate:
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. package java.util.function; import java.util.Objects; /** * Represents a predicate (boolean-valued function) of one argument. * * <p>This is a <a href="package-summary.html">functional interface</a> * whose functional method is {@link #test(Object)}. * * @param <T> the type of the input to the predicate * * @since 1.8 */ @FunctionalInterface public interface Predicate<T> { /** * Evaluates this predicate on the given argument. * * @param t the input argument * @return {@code true} if the input argument matches the predicate, * otherwise {@code false} */ boolean test(T t); /** * Returns a composed predicate that represents a short-circuiting logical * AND of this predicate and another. When evaluating the composed * predicate, if this predicate is {@code false}, then the {@code other} * predicate is not evaluated. * * <p>Any exceptions thrown during evaluation of either predicate are relayed * to the caller; if evaluation of this predicate throws an exception, the * {@code other} predicate will not be evaluated. * * @param other a predicate that will be logically-ANDed with this * predicate * @return a composed predicate that represents the short-circuiting logical * AND of this predicate and the {@code other} predicate * @throws NullPointerException if other is null */ default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); } /** * Returns a predicate that represents the logical negation of this * predicate. * * @return a predicate that represents the logical negation of this * predicate */ default Predicate<T> negate() { return (t) -> !test(t); } /** * Returns a composed predicate that represents a short-circuiting logical * OR of this predicate and another. When evaluating the composed * predicate, if this predicate is {@code true}, then the {@code other} * predicate is not evaluated. * * <p>Any exceptions thrown during evaluation of either predicate are relayed * to the caller; if evaluation of this predicate throws an exception, the * {@code other} predicate will not be evaluated. * * @param other a predicate that will be logically-ORed with this * predicate * @return a composed predicate that represents the short-circuiting logical * OR of this predicate and the {@code other} predicate * @throws NullPointerException if other is null */ default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } /** * Returns a predicate that tests if two arguments are equal according * to {@link Objects#equals(Object, Object)}. * * @param <T> the type of arguments to the predicate * @param targetRef the object reference with which to compare for equality, * which may be {@code null} * @return a predicate that tests if two arguments are equal according * to {@link Objects#equals(Object, Object)} */ static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); } }
我们看到该接口只有一个抽象方法(只能有一个,否则就不能叫函数式接口),3个默认方法和一个静态方法。该接口只有一个参数t,返回一个布尔值。我们先看看能怎么用这个接口:
// Predicate接口实例predicate指代一段判断字符串s是否长度大于0的代码 Predicate<String> predicate = (s) -> s.length() > 0; // predicate应用,判断字符串wlf是否长度>0 predicate.test("wlf"); // predicate应用,判断字符串wlf是否长度<=0 predicate.negate().test("wlf"); // 方法引用:Objects.isNull返回一个boolean, Predicate<Object> isNull = Objects::isNull; // 方法引用:String.isEmpty方法一个boolean Predicate<String> isEmpty = String::isEmpty;
Predicate接口做的事情就是判断参数s是否符合方法体里的判断逻辑,而方法体的逻辑是由你自己实现的。上面分别判断了一个字符串的长度大于0、不大于0,对象是否为空,字符串是否为空。
我们溯流而上,接下来再看下Stream的filter方法
public interface Stream<T> extends BaseStream<T, Stream<T>> { /** * Returns a stream consisting of the elements of this stream that match * the given predicate. * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * predicate to apply to each element to determine if it * should be included * @return the new stream */ Stream<T> filter(Predicate<? super T> predicate); }
这个方法就是执行Predicate的判断逻辑,通过再返回一个Stream。再回过来看我们的业务代码:
conMediaInfoList.parallelStream() .filter(s -> s != null) .filter(s -> isLiveBeing(s)) .collect(Collectors.toList());
我们看到lambda表达式里先判断MSG_ConMediaInfo实例是否不为null,再判断实例是否符合isLiveBeing方法里的判断逻辑,两个都返回true的话,继续调用collect方法返回一个List。
接下来聊下Stream接口。它表示在一组元素上一次执行的操作序列,包括中间操作或者最终操作,中间操作继续返回Stream,直到操作序列结束,执行最终操作。像上面的业务代码,filter是中间操作,collect是最终操作。那么Stream怎么创建呢?只能通过容器类来创建:
public interface Collection<E> extends Iterable<E> { /** * Returns a possibly parallel {@code Stream} with this collection as its * source. It is allowable for this method to return a sequential stream. * * <p>This method should be overridden when the {@link #spliterator()} * method cannot return a spliterator that is {@code IMMUTABLE}, * {@code CONCURRENT}, or <em>late-binding</em>. (See {@link #spliterator()} * for details.) * * @implSpec * The default implementation creates a parallel {@code Stream} from the * collection's {@code Spliterator}. * * @return a possibly parallel {@code Stream} over the elements in this * collection * @since 1.8 */ default Stream<E> parallelStream() { return StreamSupport.stream(spliterator(), true); } }
Collection还有它的孩子们List、Set都可以通过parallelStream来创造一个Stream对象,然后才后面的那些lambda表达式。