Java8学习【002】

深藏阁楼爱情的钟 2021-11-06 01:01 289阅读 0赞

### 文章目录 ###

*   *   *   *   *   *  一、什么是Lambda
                     *  二、在哪里使用Lambda表达式：
                     *  总结：

> 上一部分我们用Lambda表达式表示了匿名函数，看上去十分的简洁。所以我们现在就来学习一下。

--------------------

###### 一、什么是Lambda ######

*  它是简洁表示匿名函数的一种方式。
 *  基本介绍：
    
    1.  匿名【没有自己的名称】，本身就是一个匿名函数。
    2.  是函数，是匿名函数【但是不属于某个特定的类】。
    3.  麻雀虽小五脏俱全：和函数一样拥有自己的参数列表、函数主体、返回类型、也可有可抛出的异常列表。
    4.  行为参数传递【作为参数传递给方法、存储在变量中】.
    5.  重中之重-简洁【要不也没必要用它了?】。
 *  基本组成：
    
    1.  参数列表：(a,b)、(a)、a
    2.  箭头: ->【中间没有空格】
    3.  函数主体 : System.out.println();
 *  既然知道了基本组成那Lambda大概长啥样呢？
    
    1.  ( String str) -> str.length();
    2.  （int a, int b）-> a+b;
    3.  () -> 1;
    4.  (Object o1,Object o2) -> o1.hashCode()+o2.hashCode()；
    
    > 注意如果只有一个返回语句，return 关键字可以省略。
    
    --------------------

###### 二、在哪里使用Lambda表达式： ######

*  我们可以在函数式接口上使用Lambda表达式。

*  什么是函数式接口：
    
    > 函数式接口就是只定义一个抽象方法的接口【当然也可以有很多默认范发个】。
    > 
    >  *  我们可以使用Lambda表达式为函数式接口的抽象方法提供具体的实现，把整个Lambda表达式作为函数式接口其中一个具体实现的实例。【这些之前我们可以通过匿名内部类实现，但现在我们可以使用更简单的方式】。
    >  *  举个栗子: 线程实现  
    >     Runnable rbl = () -> System.out.println(“Runnable Lambda”);  
    >     rbl.start();  
    >     还可以像下面这样：  
    >     needThread（Runnable rbl；  
    >     needThread（() -> System.out.println(“Runnable Lambda”)）；  
    >     直接将Lambda作为行为参数传递给方法。
    >  *  我们可以使用 @FunctionalInterface 来定义一个函数式接口。
    
    --------------------

*  使用函数式接口：
    
    > 由于我们在使用Lambda表达式时需要有个函数式接口，jdk之前有一些已经定义好的函数式接口，但是并不全面，而我们在使用的时候也不能一直创建函数式接口，所以我们需要一些泛化的接口，而Java8就为我们提供了一些他们在java.util.fnction包下。
    
    --------------------
 *  Predicate

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

> 我们主要看一下test()方法，在我们需要一个接受泛型T 并返回一个布尔表达式的方法时我们就可以使用这个接口

--------------------

*  Consumer

@FunctionalInterface
    public interface Consumer<T> { 
        void accept(T t);
        default Consumer<T> andThen(Consumer<? super T> after) { 
            Objects.requireNonNull(after);
            return (T t) -> {  accept(t); after.accept(t); };
        }
    }

> 我们注意到accept函数，接受泛型T、且没有返回，所以如果我们需要处理类型T的对象就可以使用这个接口。

--------------------

*  Function

@FunctionalInterface
    public interface Function<T, R> { 
        R apply(T t);
        default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { 
            Objects.requireNonNull(before);
            return (V v) -> apply(before.apply(v));
        }
        default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { 
            Objects.requireNonNull(after);
            return (T t) -> after.apply(apply(t));
        }
        static <T> Function<T, T> identity() { 
            return t -> t;
        }
    }

> 这里有个apply()函数他接受一个泛型T的对象 ， 并返回一个泛型 R的对象。

--------------------

*  避免自动拆装箱

> Java 中数据分为引用类型和原始类型，我们在使用int、boolean、等基本类型的时候会需要将他们转成引用类型来使用，如：Boolean、Integer。而自动拆装箱是损耗性能的，所以我们可以来避免自动拆装箱，而java8为我们提供了这些办法。  
> ![接口][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lhbmd6YWlMZUhlSGU_size_16_color_FFFFFF_t_70]

1.  如上图：我们可以看到相应的接口
2.  具体的使用如下:

IntPredicate intPredicate = (int i) -> i % 2 == 0;
            System.out.println(intPredicate.test(2));
            System.out.println(intPredicate.test(3));
            结果：
            true
    		false

--------------------

*  异常处理：

1.  异常处理方式一：
    
    > @FunctionalInterface  
    > public interface IFunctionOne \{  
    > String do(String str) throws Exception;  
    > \}
2.  异常处理方式二：
    
    > Function<User, String> f = (User u) -> \{  
    > try \{  
    > return [u.do][]();  
    > \}  
    > catch(Exception e) \{  
    > throw new RuntimeException(e);  
    > \} \};

*  我们在使用Lambda的时候需要根据上下文去看一下 ，调用Lambda方法的声明以及 所使用的函数式接口中的方法声明去进行推断。
 *  Lambda使用的时候会对局部变量做了一些限制，Lambda可以没有限制的使用实例变量【成员变量】以及静态变量，但是对于局部变量会有一些限制【局部变量必须是final的】，
    
    > 那么为什么有这个限制呢？  
    > 1.首先我们要知道 实例变量、局部变量的区别：实例变量是类的一部分存储于堆中，而局部变量则保存在栈中。  
    > 2.如果Lambda可以直接访问局部变量，当我们在一个线程中使用Lambda表达式的时候，可能会出现使用Lambda的线程在分配该变量的线程将该变量回收之后，去访问该变量。【这显然是线程不安全的】。  
    > 3. 所以Java在访问局部变量的时候实际上是访问它的副本，而不是原始变量，所以就有了这个限制。
 *  方法引用
    
    > 我们可以像下面这样打印一个List：
    > 
    >     list.forEach(System.out::println);
    
     *  方法引用可以看做是调用特定方法的Lambda表达式的简洁写法。
     *  既如果一个Lambda表达式只意味着-直接调用这个方法，那就直接用名称调用它。
     *  下面看一下等效对比：
        
        > 1.  (User u) -> u.getSalary() | User::getSalary
        > 2.  (String s) -> System.out.println(s) | System.out::println
     *  如何构建方法引用：
        
        > 1.指向静态方法的方法引用：Integer::parseInt。  
        > 2.指向任意类型实例方法的引用：String::length。  
        > 3. 指向现有方法的实例方法的引用：UserCon::getName。

--------------------

###### 总结： ######

> 1.Lambda 可以理解为一种匿名函数，没有名称，但是有函数体、参数列表、返回类型、也可以有抛出的异常列表。【更简洁】  
> 2. 函数式接口就是只声明了一个抽象方法的接口【可以很多默认方法】  
> 3. 只有在接受函数式接口的地方才可以使用Lambda表达式。  
> 4. Lambda 允许我们直接实现抽象方法，并将整个表达式作为函数式接口的一个实例。  
> 5. Java8 自带了一些常用的函数式接口位于：java.util.funciton包下：
> 
>     Predicate< T> Function<T,R>
>     Supplier< T> Consumer< T> BinaryOperator< T>。
> 
> 6 .为了避免自动装箱操作：对Predicate< T > Function<T, R> 等通用的函数式接口的原始类型特化:IntPredicate IntToLongFunction 等。  
> 7 .Lambda所代表的类型称为目标类型。  
> 8 .方法引用让你重复使用现有的方法实现并直接传递他们。  
> 9 .Comparator Predicate和Function 等函数式接口都有几个可以用来结合Lambda的默认方法。

--------------------

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lhbmd6YWlMZUhlSGU_size_16_color_FFFFFF_t_70]: /images/20211104/e94aaeb7cd0244c49952a09ae56b4d9e.png
[u.do]: http://u.do