1,代码实例一

 List<Integer> list= Arrays.asList(1,2,3,3,4,5,6);
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });

forEach源码

 /**
     * 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.
     *
对iterable的每个元素执行给定的操作
直到处理完所有元素或操作引发
异常。除非实现类另有指定，否则将按迭代顺序执行操作（如果迭代顺序
已指定）。操作引发的异常将中继到调用方。
     * @implSpec
     * <p>The default implementation behaves as if:
     * <pre>{@code
     *     for (T t : this)
     *         action.accept(t);
     * }</pre>
     *
     * @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<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

图片.png

consumer

/**
 * 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.
表示一种操作,传入单个值,且没有返回,不想其他大多数函数式接口,Consumer被认为是有副作用的操作
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #accept(Object)}.
 *
 * @param <T> the type of the input to the operation
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

2,代码实例二

 list.forEach(i->{
            System.out.println(i);
        });
 list.forEach(System.out::println);

图片.png

3,代码实例三

Conceptually, a functional interface has exactly one abstract
 * method.  Since {@linkplain java.lang.reflect.Method#isDefault()
 * default methods} have an implementation, they are not abstract.  If
 * an interface declares an abstract method overriding one of the
 * public methods of {@code java.lang.Object}, that also does
 * <em>not</em> count toward the interface's abstract method count
 * since any implementation of the interface will have an
 * implementation from {@code java.lang.Object} or elsewhere.

简单来说,函数式接口中只能有一个抽象方法,但是如果和object类中的方法重名,也可以有(可以重写)

@FunctionalInterface
public interface Test03 {
    void test();
    //会报错
    //只能有一个抽象方法
    // void test2();
    //不会报错,因为他是继承java.lang.Object对象的方法,并不会算大抽象方法里面去
    String toString();
}

* <p>Note that instances of functional interfaces can be created with
 * lambda expressions, method references, or constructor references.

函数式接口可以通过lambda表达式,函数引用或者构造器引用

4,代码实例4

 Test04MyInterface test04MyInterface=()->{
            System.out.println("test");
        };
        System.out.println(test04MyInterface.getClass());
        System.out.println(test04MyInterface.getClass().getSuperclass());
        System.out.println(test04MyInterface.getClass().getInterfaces()[0]);

lambda表达式创建的相当于是一个对象

5,代码实例6

需求:将list中的字符串内容大写然后输出

 List<String> list= Arrays.asList("hello","String","hello world");
        //jdk8的写法
        list.forEach(i->System.out.println(i));
        //需求二:构造新的集合,存放变成大写的数据
        List<String> list2=new ArrayList<>();
        //写法1
        list.forEach(i->{
            list.add(i.toUpperCase());
        });
        list.forEach(i->{
            System.out.println(i);
        });
        //写法2
        list.stream().map(item->item.toUpperCase()).forEach(item->System.out.println(item));
        //写法3
        list.stream().map(String::toUpperCase).forEach(System.out::println);

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}.
     *
     * @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 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);

图片.png