1.lambda表达式简单使用

lambda表达式之前就有听说过，但也没有系统的学习过，此处也不算系统的学习，而且目前我还没有找到学习方法，只是在网上找对于lambda表达式的基本使用，然后自己试一下这样子。
在没有java8的lambda表达式前，我写一个将一个List<String>的所有字符串转为小写字符的东西。（除了lambda表达式也用到了其他东西，组合更好用的样子，大家都是这么玩的）

    @Test
    public void test03(){
        //lambda
        List<String> names = new ArrayList<>();
        names.add("yanyan");
        names.add("linzhihe");
        List<String> lowercaseNames = names.stream().map((String name) -> {return name.toLowerCase();}).collect(Collectors.toList());

        //没有jdk8 自己的写法
        List<String> names1 = new ArrayList<>();
        names1.add("yanyan");
        names1.add("linzhihe");
        List<String> lowercaseNames1 = new ArrayList<>();
        for (String name : names1) {
            lowercaseNames1.add(name.toLowerCase());
        }

        //没有jdk8 高手的写法（据说这个是什么声明式编程，我那种叫命令式编程）
        List<String> names2 = new ArrayList<>();
        names.add("yanyan");
        names.add("linzhihe");
        List<String> lowercaseNames2 = FluentIterable.from(names2).transform(new Function<String, String>() {
            @Override
            public String apply(String name) {
                return name.toLowerCase();
            }
        }).toList();

    }

当然高手的那种声明式的写法，我现在水平还不够，不能理解中间的奥义，lambda还可以理解，简化写也行

        List<String> lowercaseNames = names.stream().map(name -> name.toLowerCase()).collect(Collectors.toList());

甚至于可以用::关键词,当然这个以前也没用过，此处不做深究

        List<String> lowercaseNames = names.stream().map(String::toLowerCase).collect(Collectors.toList());

lambda END 简单总结：
语法结构如下：

(Type1 param1,Type2 Param2,...TypeN ParamN) ->
{
执行语句1;
执行语句2;
...
执行语句N;
retrun *;
}

2.java.util.function.Predicate

作用：Represents a predicate (boolean-valued function) of one argument.（表示一个参数的布尔值函数）
这个点的学习也是在网上别人的分享来学习的，很多有问题，后来自己尝试着源码，觉得效果很好，这个接口源码如下

package java.util.function;
import java.util.Objects;
@FunctionalInterface
public 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);
    }
}

大概就是返回true或false。而依据是t（demo里是(str)->str.equals("Java")，当然方法里我自己加了or方法源码里一看就很容易明白），比如

    @Test
    public void test06(){
        List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp", "JavaScript");
        filter(languages, (str)->str.equals("Java"));

    }

    public static void filter(List<String> names, Predicate condition) {
        names.forEach((name)->{
            if(condition.or((str)->str.equals("JavaScript")).test(name)) {
                System.out.println("I like " + name + " ");
            }
        });
    }

2.java.util.function.Consumer

作用：Performs this operation on the given argument（在给定的参数上执行此操作）
源码：

3.java.util.Optional

作用：A container object which may or may not contain a non-null value（一个容器对象，它可能包含或不包含非空值）
它的ifPresent就是Consumer接口的一个例子。

 public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

4. A::B

A的B方法

5.java.util.stream.Stream

Returns a stream consisting of the elements of this stream that match the given predicate(返回由流元素组成的流，该流与给定predicate匹配。)

List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
System.out.println("sum is:"+nums.stream().filter(num -> num != null).distinct().
mapToInt(num -> num * 2).peek(MyTest::print).skip(2).limit(4).sum());