首页 > 代码库 > Java 8 新特性:3-函数（Function）接口
Java 8 新特性:3-函数（Function）接口
(原)
以前，在创建泛型时，是这么写的：
List<String> list = new ArrayList<String>();
现在，可以这么写了：
List<String> list = new ArrayList<>();
在java8中，这种写法被叫作diamond语法，有些书里叫他钻石语法，有些则称之为菱形语法，说的就是这种语法。
看下面的例子：
package com.demo.jdk8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
public class Test3 {
public static void main(String[] args) {
List<String> list = Arrays.asList("a","b","hello");
list.stream().map(i -> i.toUpperCase()).forEach(i -> System.out.println(i));
System.out.println("--------------------");
list.stream().map(String::toUpperCase).forEach(i -> System.out.println(i));
System.out.println("--------------------");
Function<String , String> fun = String::toUpperCase;
System.out.println(fun.apply("hello"));
}
}
Java8里面，List上层Collection接口中，加入了一个stream方法
/**
* 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);
}
stream方法会返回一个串行流，parallelStream方法会返回一个并行流，在这个例子中，你可以将它看作返回了一个Stream，这个Stream是java8新加的接口，其中有一个map方法。
/**
* Returns a stream consisting of the results of applying the given
* function to the elements of this stream.
*返回一个流，其中包含将给定函数应用到该流的元素的结果。
* <p>This is an <a href="http://www.mamicode.com/package-summary.html#StreamOps">intermediate
* operation</a>.
*这是一个中间操作
* @param <R> The element type of the new stream
* 返回一个新的流
* @param mapper a <a href="http://www.mamicode.com/package-summary.html#NonInterference">non-interfering</a>,
* <a href="http://www.mamicode.com/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);
这里的map接收一个参数，是一个Function接口
@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);
这个方法的含义是接收一个流的参数，返回一个新的流。
在刚才的这个例子中list.stream().map(i -> i.toUpperCase()).forEach(i -> System.out.println(i));
list.stream()先将list转换成了stream,map是对Function接口的lambda实现，接收了每次迭代的一个参数，然后将该参数转换成大写再返回。
i -> i.toUpperCase()这里的i指的就是R apply(T t);这里的T，而i.toUpperCase()则是它的返回结果R，那String::toUpperCase这又是什么？在java8中，这叫方法的引用，因为toUpperCase并不是static方法，那么这个字符串必需是对象，那么这个对象是什么呢？其实这里的String就是传入的第一个参数T。这里总结一下，这个::后面的方法，一定是lambda表达式中第一个参数的方法。因为i -> i.toUpperCase()和String::toUpperCase是等价，这第二种写法里，你也可以认为有一个string对象调用了toUpperCase,这个对象是谁呢？就是第一种写法里面的i。（这里确实不太好理解）
在Function中，还有一个静态方法：
static <T> Function<T, T> identity() {
return t -> t;
}
这是在java8中引入的新的写法。接口中可以有方法的实现，可以是default的，也可以是static的。
Java 8 新特性:3-函数（Function）接口