《Java 1.8》方法引用与Optional 类

一、方法引用分类

通过方法引用，可以将方法的引用赋值给一个变量,通过赋值给Function，说明方法引用也是一种函数式接口的书写方式，Lambda表达式也是一种函数式接口，Lambda表达式一般用于自己提供方法体，而方法引用一般直接引用现成的方法。

1、构造器引用：它的语法是Class::new，或者更一般的Class< T >::new

2、静态方法引用：它的语法是Class::static_method

3、特定类的任意对象的方法引用：它的语法是Class::method

4、特定对象的方法引用：它的语法是instance::method

二、方法引用优缺点

优点：方法引用使得语言的构造更加简洁，减少冗余代码。

缺点：代码易读性差，不方便调试

三、示例

package com.learn.demo;

import java.util.ArrayList;
import java.util.List;

@FunctionalInterface
interface MethodInterface<T>{
    T get();
}
class MethodModel {
    private String name;
    private String word;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getWord() {
        return word;
    }
    public void setWord(String word) {
        this.word = word;
    }
    @Override
    public boolean equals(Object obj) {
        MethodModel method = (MethodModel)obj;
        return this.getName().equals(method.getName()) && this.getWord().equals(method.getWord());
    }
    @Override
    public String toString() {
        return "MethodDemo [name=" + name + ", word=" + word + "]";
    }
    public static MethodModel create(final MethodInterface<MethodModel> method){
        MethodModel methodDemo = method.get();
        methodDemo.setName("name 3");
        methodDemo.setWord("word 3");
        return methodDemo;
    }
    public static void collide(final MethodModel method){
        System.out.println("Collided "+method.toString());
    }
    public void follow(final MethodModel method){
        if(method.equals(this)){
            System.out.println("Following the "+method.toString());
        }
    }
    public void repair(){
        System.out.println("Repaired "+this.toString());
    }
}
public class MethodDemo{
    public static void main(String[] args) {
        //构造器引用(创建实例)
        final MethodModel method = MethodModel.create(MethodModel :: new);
        System.out.println(method.toString());

        //静态方法引用(遍历实例)
        List<MethodModel> list = new ArrayList<MethodModel>();
        for (int i = 0; i < 10; i++) {
            MethodModel demo = new MethodModel();
            demo.setName("name "+i);
            demo.setWord("word "+i);
            list.add(demo);
        }
        list.forEach(MethodModel :: collide);
        
        //特定对象的方法引用（筛选实例）
        final MethodModel police = MethodModel.create(MethodModel :: new);
        list.forEach(police :: follow);
        
        //实例方法引用（选出自己）
        list.forEach(MethodModel::repair);
    }
}

四、Optional类

序号	方法	描述
1	static <T> Optional<T> empty()	返回空的 Optional 实例。
2	<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)	如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional
3	Optional<T> filter(Predicate<? super <T> predicate)	如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
4	T get()	如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException
5	void ifPresent(Consumer<? super T> consumer)	如果值存在则使用该值调用 consumer , 否则不做任何事情。
6	boolean isPresent()	如果值存在则方法会返回true，否则返回 false。
7	<U>Optional<U> map(Function<? super T,? extends U> mapper)	如果存在该值，提供的映射方法，如果返回非null，返回一个Optional描述结果。
8	static <T> Optional<T> of(T value)	返回一个指定非null值的Optional。
9	static <T> Optional<T> ofNullable(T value)	如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。
10	T orElse(T other)	如果存在该值，返回值，否则返回 other。
11	T orElseGet(Supplier<? extends T> other)	如果存在该值，返回值，否则触发 other，并返回 other 调用的结果。
12	<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)	如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常

示例：

package com.learn.demo;

import java.util.Optional;

public class OptionalDemo {
    public static void main(String[] args) {
//        of();
//        ofNullable();
//        empty();
//        get();
//        orElse();
//        orElseGet();
//        orElseThrow();
//        filter();
//        map();
//        ifPresent();
//        flagMap();
//        isPresent();
    }
    
    /**
     * 不能为null，否则会报NullPointerException错误
     */
    public static void of(){
        //创建Optional示例，并赋值
        Optional<String> optional1 = Optional.of("of demo");
        //如果我们用of方法创建Optional对象时，所传入的值为null，则抛出NullPointerException
        Optional<String> optional2 = Optional.of(null);
    }
    
    /**
     * of的补充，增加了判空条件
     */
    public static void ofNullable(){
        //为指定的值创建Optional对象，不管所传入的值为null不为null，创建的时候都不会报错
        Optional<String> optional3 = Optional.ofNullable(null);
        Optional<String> optional4 = Optional.ofNullable("of demo");
    }
    
    /**
     * 创建一个空的Optional对象
     */
    public static void empty(){
        //创建一个空的String类型的Optional对象
        Optional<String> optional5 = Optional.empty();
    }
    
    /**
     * 如果我们创建的Optional对象中有值存在则返回此值，如果没有值存在，则会抛出 NoSuchElementException异常
     */
    public static void get(){
        Optional<String> optional5 = Optional.ofNullable("get demo");
        System.out.println(optional5.get());
        Optional<String> optional6 = Optional.ofNullable(null);
        System.out.println(optional6.get());
    }
    
    /**
     * 如果创建的Optional中有值存在，则返回此值，否则返回一个默认值
     */
    public static void orElse(){
        Optional<String> optional7 = Optional.of("of else demo");
        System.out.println(optional7.orElse("demo"));

        Optional<String> optional8 = Optional.empty();
        System.out.println(optional8.orElse("demo"));
    }
    
    /**
     * 如果创建的Optional中有值存在，则返回此值，否则返回一个由Supplier接口生成的值
     */
    public static void orElseGet(){
        Optional<String> optional9 = Optional.of("or else get demo");
        System.out.println(optional9.orElseGet(() -> "demo"));

        Optional<String> optional10 = Optional.empty();
        System.out.println(optional10.orElseGet(() -> "demo"));
    }
    
    /**
     * 如果创建的Optional中有值存在，则返回此值，否则抛出一个由指定的Supplier接口生成的异常
     */
    public static void orElseThrow(){
        try {
            Optional<String> optional11 = Optional.of("else throw demo");
            System.out.println(optional11.orElseThrow(ElseDefaultException::new));

            Optional<String> optional12 = Optional.empty();
            System.out.println(optional12.orElseThrow(ElseDefaultException::new));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 如果创建的Optional中的值满足filter中的条件，则返回包含该值的Optional对象，否则返回一个空的Optional对象
     * 
     * 注意Optional中的filter方法和Stream中的filter方法是有点不一样的，Stream中的filter方法是对一堆元素进 
     * 行过滤，而Optional中的filter方法只是对一个元素进行过滤，可以把Optional看成是最多只包含一个元素 的Stream。
     */
    public static void filter(){
        Optional<String> optional = Optional.of("filter demo");
        System.out.println(optional.filter(e -> e.length() > 5).orElse("demo"));
        optional = Optional.empty();
        System.out.println(optional.filter(e -> e.length() > 5).orElse("demo"));
    }
    
    /**
     * 如果创建的Optional中的值存在，对该值执行提供的Function函数调用
     */
    public static void map(){
        //map方法执行传入的lambda表达式参数对Optional实例的值进行修改,修改后的返回值仍然是一个Optional对象
        Optional<String> optional = Optional.of("map demo");
        System.out.println(optional.map(e -> e.toUpperCase()).orElse("error"));

        optional = Optional.empty();
        System.out.println(optional.map(e -> e.toUpperCase()).orElse("success"));
    }
    
    /**
     * ifPresent方法的参数是一个Consumer的实现类，Consumer类包含一个抽象方法，该抽象方法对传入的值进行处理，只处理没有返回值。
     */
    public static void ifPresent(){
        Optional<String> optional = Optional.of("if present");
        optional.ifPresent(e-> System.out.println("我被处理了。。。"+e));
    }
    
    /**
     * 1、创建的Optional中的值存在，执行提供的Function函数调用，返回一个Optional类型的值
     * 2、创建的Optional中的值不存在，返回一个空的Optional对象.
     * flatMap与map（Funtion）方法类似，区别在于flatMap中的mapper返回 
     * 值必须是Optional，map方法的mapping函数返回值可以是任何类型T。调用结束时，flatMap不会对结果 
     * 用Optional封装。
     */
    public static void flagMap(){
        //map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。 
        //但flatMap方法中的lambda表达式返回值必须是Optionl实例
        Optional<String> optional = Optional.of("flag map demo");
        System.out.println(optional.flatMap(e -> Optional.of("flag default")).orElse("error"));

        optional = Optional.empty();
        System.out.println(optional.flatMap(e -> Optional.empty()).orElse("error"));
    }
    
    /**
     * 如果值存在则方法会返回true，否则返回 false。
     */
    public static void isPresent(){
        Optional<String> optional = Optional.of("present demo");
        System.out.println(optional.isPresent());
    }
    static class ElseDefaultException extends Exception{
        private static final long serialVersionUID = 1609463882582374229L;
        public ElseDefaultException(){
            super("自定义异常");
        }
        public ElseDefaultException(String message){
            super(message);
        }
    }
}

友情链接：

https://blog.csdn.net/zknxx/article/details/78586799

posted @ 2018-07-02 14:02 xylfjk 阅读(46) 评论(0) 收藏举报

刷新页面返回顶部

xylfjk

《Java 1.8》方法引用与Optional 类

一、方法引用分类

二、方法引用优缺点

三、示例

四、Optional类

公告