美文网首页
jdk8集合的使用以及lambda表达式

jdk8集合的使用以及lambda表达式

作者: 柴崎越 | 来源:发表于2019-03-07 23:20 被阅读0次

    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);
    
    
    当你ctrl+鼠标点击->和::时,跳 图片.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

    相关文章

      网友评论

          本文标题:jdk8集合的使用以及lambda表达式

          本文链接:https://www.haomeiwen.com/subject/dxskpqtx.html