List<String> list =  new  ArrayList<String>();

List<String> list = new ArrayList<>();

package com.demo.jdk8;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;public class Test3 {public static void main(String[] args) {System.out.println("part1------------------");List<String> list = Arrays.asList("a","b","hello");list.stream().map(i -> i.toUpperCase()).forEach(i -> System.out.println(i));System.out.println("part2--------------------");list.stream().map(String::toUpperCase).forEach(i -> System.out.println(i));System.out.println("part3--------------------");Function<String , String> fun = String::toUpperCase;System.out.println(fun.apply("hello"));System.out.println("part4-------------------");System.out.println(calc1(3, v -> v+1));System.out.println("part5------------------");System.out.println(calc2(2, v -> v + 1, v -> v * 2));System.out.println("part6------------------");System.out.println(calc3(2, v -> v + 1, v -> v * 2));System.out.println("part7------------------");System.out.println(calc4(1,3,(v1,v2) -> v1 + v2));System.out.println("part8------------------");System.out.println(calc5(1,3,(v1,v2) -> v1 + v2 ,v -> v + 3) );}public static Integer calc1(Integer a ,Function<Integer, Integer> fun){return fun.apply(a);}public static Integer calc2(int a ,Function<Integer, Integer> fun1,Function<Integer, Integer> fun2){return  fun1.compose(fun2).apply(a);}public static Integer calc3(int a ,Function<Integer, Integer> fun1,Function<Integer, Integer> fun2){return  fun1.andThen(fun2).apply(a);}public static Integer calc4(int a ,int b ,BiFunction<Integer, Integer, Integer> biFun){return biFun.apply(a, b);}public static Integer calc5(int a ,int b ,BiFunction<Integer, Integer, Integer> biFun,Function<Integer, Integer> fun){return biFun.andThen(fun).apply(a, b);}
}

/*** Returns a sequential {@code Stream} with this collection as its source.** <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 sequential {@code Stream} from the* collection's {@code Spliterator}.*这个默认的实现会从Spliterator中创建一个串行流* @return a sequential {@code Stream} over the elements in this collection* @since 1.8*/default Stream<E> stream() {return StreamSupport.stream(spliterator(), false);}/*** 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);
}

/*** Returns a stream consisting of the results of applying the given* function to the elements of this stream.*返回一个流，其中包含将给定函数应用到该流的元素的结果。* <p>This is an <a href="package-summary.html#StreamOps">intermediate* operation</a>.*这是一个中间操作* @param <R> The element type of the new stream* 返回一个新的流* @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,*               <a href="package-summary.html#Statelessness">stateless</a>*               function to apply to each element* @return the new stream*/<R> Stream<R> map(Function<? super T, ? extends R> mapper);

@FunctionalInterface
public interface Function<T, R>
这是一个函数式接口，其中有一个抽象方法。
/*** Applies this function to the given argument.* 将这个参数运用到给定的参数上* @param t the function argument* @return the function result*/R apply(T t);

static <T> Function<T, T> identity() {return t -> t;
}

/*** Returns a composed function that first applies the {@code before}* function to its input, and then applies this function to the result.* If evaluation of either function throws an exception, it is relayed to* the caller of the composed function.*首先应用before这个函数返回一个组合函数的结果，然后再返回这个函数的结果。*如果这个函数抛出异常，那么它会将这个异常交给调用这个函数的人处理。* @param <V> the type of input to the {@code before} function, and to the*           composed function* @param before the function to apply before this function is applied* @return a composed function that first applies the {@code before}* function and then applies this function* @throws NullPointerException if before is null** @see #andThen(Function)*/default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));
}/*** Returns a composed function that first applies this function to* its input, and then applies the {@code after} function to the result.* If evaluation of either function throws an exception, it is relayed to* the caller of the composed function.*首先运用这个函数的输入返回一个组合函数，然后运用这个after的参数返回结果* @param <V> the type of output of the {@code after} function, and of the*           composed function* @param after the function to apply after this function is applied* @return a composed function that first applies this function and then* applies the {@code after} function* @throws NullPointerException if after is null** @see #compose(Function)*/default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));
}

@FunctionalInterface
public interface BiFunction<T, U, R> {/*** Applies this function to the given arguments.** @param t the first function argument* @param u the second function argument* @return the function result*/R apply(T t, U u);/*** Returns a composed function that first applies this function to* its input, and then applies the {@code after} function to the result.* If evaluation of either function throws an exception, it is relayed to* the caller of the composed function.** @param <V> the type of output of the {@code after} function, and of the*           composed function* @param after the function to apply after this function is applied* @return a composed function that first applies this function and then* applies the {@code after} function* @throws NullPointerException if after is null*/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));}
}