optional 订阅
optional 是一个英语单词,形容词,作形容词时意思是“可选择的,随意的”。 展开全文
optional 是一个英语单词,形容词,作形容词时意思是“可选择的,随意的”。
信息
外文名
optional
词    性
形容词
optional单词发音
英[ˈɒpʃənl];美[ˈɑːpʃənl] [1] 
收起全文
精华内容
参与话题
问答
  • optional用法

    千次阅读 2018-04-03 04:57:38
    java8的改进中一个非常有用的就是optional,一句话概括,optional允许使用一个不确定是否为null的对象并且在对象为null的时候采取一系列的应对措施而不必抛出nullpointerException。这项改进对于经常面对空指针异常...

    java8的改进中一个非常有用的就是optional,一句话概括,optional允许使用一个不确定是否为null的对象并且在对象为null的时候采取一系列的应对措施而不必抛出nullpointerException。

    这项改进对于经常面对空指针异常的程序是个福音,因为按照以往的方式,要避免空指针异常,就必需进行null判断,如if(obj==null),另一种方式就是抛出异常并处理,然而这两种方式的语言表达能力并不好,复杂的场合可读性太差,所以使用optional可以解决这个问题。

    public class Gen {
    	//创封装一个为空的Optional<User>对象
    	public Optional<User> user = Optional.empty();
    	//封装一个Optional<User>,如果提供的User为null,则返回一个空的Optional<User>
            public Optional<User> user = Optional.ofNullable(new User());
    	public void exe() {
    		//get从Optional<User>去除user对象,如果对象为空,则抛出NoSuchElementEception
    		user.get();
    		
    		//get相当于不判断user是否为null直接调用,为null则照旧抛出nullpointerException
    		user.get().setId(10);
    		user.get().setEmail("123");
    		
    		//of将一个对象封装为optional对象,如果对象为null,抛出NoSuchElementEception
    		Optional.of(new User());
    		
    		//isPresent相当于if(user==null)
    		System.out.println(user.isPresent());
    		
    		//ifPresent相当于if(user!=null)
    		//			System.out.println(user.getId());
    		//		else
    		//			doNothing
    		user.ifPresent((user)->System.out.println(user.getId()));
    		
    		//map和上面类似,但是必须使用对象本身的函数
    		System.out.println(user.map((user)->user.getId()));
    		
    		//orElse通常跟map搭配,不通过则返回默认值
    		System.out.println(user.map((user)->user.getId()).orElse(100));
    		
    		//orElseGet跟orElse类似,不通过返回一个Supplier<T>签名的函数
    		Supplier<Integer> s= ()->new Integer(12);
    		user.map((user)->user.getId()).orElseGet(s);
    		
    		//orElseThrow则是返回一个Supplier<Throwable>签名的函数
    		Supplier<NumberFormatException> n = ()->new NumberFormatException();
    		user.map((user)->user.getId()).orElseThrow(n);		
    		
    	}
    	
    	public static void main(String[] args) throws Exception {
    		new Gen().exe();
    	}
    	
    }

    我们增加一个方法,用于返回Gen中的一个Optional对象

    public Optional<User> getUser() {
    		return user;
    	}

    如果我们希望输出一个Gen对象中的User对象的email,第一时间想到的是如下做法:

    Optional<Gen> gen = Optional.ofNullable(new Gen());
    		String email = gen.map(Gen::getUser).map(User::getEmail).orElse("noemail");//类型检查不通过
    		System.out.println(email);

    但是出现了类型错误,因为map方法跟stream类似,返回的是一个流,只不过是只有一个对象的流,并且这个流是嵌套的,也就是说第一个map返回的是一个Optional<Optional<User>>的对象流,对他进行getEmail操作显然是不支持的,这个时候使用flapmap:

    String email = gen.flatMap(Gen::getUser).map(User::getEmail).orElse("noemail");

    flatmap跟stream的类似,将嵌套的流扁平化为单一的流,从而解这种引用链。

    比flatmap更进一步处理的有filter,例:

    {
    		user.get().setEmail("hello");//初始化一下属性
    	}
    gen.flatMap(Gen::getUser).filter((u)->u.getEmail().equals("hello"));

    那么当user不为null且email为hello是,返回其optional对象,否则返回空的optional对象。

    另外,optional对象作为属性,该属性是不能被序列化的,它没有实现序列化接口。



    展开全文
  • Optional用法

    2018-06-06 17:34:06
    转自https://www.cnblogs.com/xingzc/p/5778090.htmlJava 8 Optional类深度解析 思考: 调用一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法。原来解决方案: 我们首先要判断这个返回值是否为null,...


    转自https://www.cnblogs.com/xingzc/p/5778090.html

    Java 8 Optional类深度解析

           

     思考: 调用一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法。

    原来解决方案: 我们首先要判断这个返回值是否为null,只有在非空的前提下才能将其作为其他方法的参数。这正是一些类似Guava的外部API试图解决的问题。

            一些JVM编程语言比如Scala、Ceylon等已经将对在核心API中解决了这个问题。

     

    新版本的Java,比如Java 8引入了一个新的Optional类。Optional类的Javadoc描述如下:

    这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。

    本文会逐个探讨Optional类包含的方法,并通过一两个示例展示如何使用。

    of

    为非null的值创建一个Optional。

      of方法通过工厂方法创建Optional类。需要注意的是,创建对象时传入的参数不能为null。如果传入参数为null,则抛出NullPointerException 。

    1
    2
    3
    4
    //调用工厂方法创建Optional实例
    Optional<String> name = Optional.of("Sanaulla");
    //传入参数为null,抛出NullPointerException.
    Optional<String> someNull = Optional.of(null);

    ofNullable

    为指定的值创建一个Optional,如果指定的值为null,则返回一个空的Optional。

    ofNullable与of方法相似,唯一的区别是可以接受参数为null的情况。示例如下:

    1
    2
    3
    //下面创建了一个不包含任何值的Optional实例
    //例如,值为'null'
    Optional empty = Optional.ofNullable(null);

    isPresent

    非常容易理解

    如果值存在返回true,否则返回false。

    类似下面的代码:

    1
    2
    3
    4
    5
    //isPresent方法用来检查Optional实例中是否包含值
    if (name.isPresent()) {
      //在Optional实例内调用get()返回已存在的值
      System.out.println(name.get());//输出Sanaulla
    }

    get

    如果Optional有值则将其返回,否则抛出NoSuchElementException。

    上面的示例中,get方法用来得到Optional实例中的值。下面我们看一个抛出NoSuchElementException的例子:

    1
    2
    3
    4
    5
    6
    7
    //执行下面的代码会输出:No value present
    try {
      //在空的Optional实例上调用get(),抛出NoSuchElementException
      System.out.println(empty.get());
    } catch (NoSuchElementException ex) {
      System.out.println(ex.getMessage());
    }

    ifPresent  

    如果Optional实例有值则为其调用consumer,否则不做处理

    要理解ifPresent方法,首先需要了解Consumer类。简答地说,Consumer类包含一个抽象方法。该抽象方法对传入的值进行处理,但没有返回值。

    Java8支持不用接口直接通过lambda表达式传入参数。

    如果Optional实例有值,调用ifPresent()可以接受接口段或lambda表达式。类似下面的代码:

    1
    2
    3
    4
    5
    //ifPresent方法接受lambda表达式作为参数。
    //lambda表达式对Optional的值调用consumer进行处理。
    name.ifPresent((value) -> {
      System.out.println("The length of the value is: " + value.length());
    return “adf”;//此处不可以有返回值
    });
     

    orElse

    如果有值则将其返回,否则返回指定的其它值。

    如果Optional实例有值则将其返回,否则返回orElse方法传入的参数。示例如下:

    1
    2
    3
    4
    5
    6
    //如果值不为null,orElse方法返回Optional实例的值。
    //如果为null,返回传入的消息。
    //输出:There is no value present!
    System.out.println(empty.orElse("There is no value present!"));
    //输出:Sanaulla
    System.out.println(name.orElse("There is some value!"));

    orElseGet

    orElseGet与orElse方法类似,区别在于得到的默认值。orElse方法将传入的字符串作为默认值,orElseGet方法可以接受Supplier接口的实现用来生成默认值。示例如下:

    1
    2
    3
    4
    5
    6
    //orElseGet与orElse方法类似,区别在于orElse传入的是默认值,
    //orElseGet可以接受一个lambda表达式生成默认值。
    //输出:Default Value
    System.out.println(empty.orElseGet(() -> "Default Value"));
    //输出:Sanaulla
    System.out.println(name.orElseGet(() -> "Default Value"));

    orElseThrow

    如果有值则将其返回,否则抛出supplier接口创建的异常。

    在orElseGet方法中,我们传入一个Supplier接口。然而,在orElseThrow中我们可以传入一个lambda表达式或方法,如果值不存在来抛出异常。示例如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    try {
      //orElseThrow与orElse方法类似。与返回默认值不同,
      //orElseThrow会抛出lambda表达式或方法生成的异常
     
      empty.orElseThrow(ValueAbsentException::new);
    } catch (Throwable ex) {
      //输出: No value present in the Optional instance
      System.out.println(ex.getMessage());
    }

    ValueAbsentException定义如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    class ValueAbsentException extends Throwable {
     
      public ValueAbsentException() {
        super();
      }
     
      public ValueAbsentException(String msg) {
        super(msg);
      }
     
      @Override
      public String getMessage() {
        return "No value present in the Optional instance";
      }
    }

    map

    map方法文档说明如下:

    如果有值,则对其执行调用mapping函数得到返回值。如果返回值不为null,则创建包含mapping返回值的Optional作为map方法返回值,否则返回空Optional。

    map方法用来对Optional实例的值执行一系列操作。通过一组实现了Function接口的lambda表达式传入操作。map方法示例如下:

    1
    2
    3
    4
    //map方法执行传入的lambda表达式参数对Optional实例的值进行修改。
    //为lambda表达式的返回值创建新的Optional实例作为map方法的返回值。
    Optional<String> upperName = name.map((value) -> value.toUpperCase());
    System.out.println(upperName.orElse("No value found"));

    flatMap

    如果有值,为其执行mapping函数返回Optional类型返回值,否则返回空Optional。flatMap与map(Funtion)方法类似,区别在于flatMap中的mapper返回值必须是Optional。调用结束时,flatMap不会对结果用Optional封装。

    flatMap方法与map方法类似,区别在于mapping函数的返回值不同。map方法的mapping函数返回值可以是任何类型T,而flatMap方法的mapping函数必须是Optional。

    参照map函数,使用flatMap重写的示例如下:

    1
    2
    3
    4
    5
    //flatMap与map(Function)非常类似,区别在于传入方法的lambda表达式的返回类型。
    //map方法中的lambda表达式返回值可以是任意类型,在map函数返回之前会包装为Optional。
    //但flatMap方法中的lambda表达式返回值必须是Optionl实例。
    upperName = name.flatMap((value) -> Optional.of(value.toUpperCase()));
    System.out.println(upperName.orElse("No value found"));//输出SANAULLA

    filter

    filter个方法通过传入限定条件对Optional实例的值进行过滤。文档描述如下:

    如果有值并且满足断言条件返回包含该值的Optional,否则返回空Optional。

    读到这里,可能你已经知道如何为filter方法传入一段代码。是的,这里可以传入一个lambda表达式。对于filter函数我们应该传入实现了Predicate接口的lambda表达式。如果你不熟悉Predicate接口,可以参考这篇文章

    现在我来看看filter的各种用法,下面的示例介绍了满足限定条件和不满足两种情况:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //filter方法检查给定的Option值是否满足某些条件。
    //如果满足则返回同一个Option实例,否则返回空Optional。
    Optional<String> longName = name.filter((value) -> value.length() > 6);
    System.out.println(longName.orElse("The name is less than 6 characters"));//输出Sanaulla
     
    //另一个例子是Optional值不满足filter指定的条件。
    Optional<String> anotherName = Optional.of("Sana");
    Optional<String> shortName = anotherName.filter((value) -> value.length() > 6);
    //输出:name长度不足6字符
    System.out.println(shortName.orElse("The name is less than 6 characters"));

    以上,我们介绍了Optional类的各个方法。下面通过一个完整的示例对用法集中展示:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    public class OptionalDemo {
     
      public static void main(String[] args) {
        //创建Optional实例,也可以通过方法返回值得到。
        Optional<String> name = Optional.of("Sanaulla");
     
        //创建没有值的Optional实例,例如值为'null'
        Optional empty = Optional.ofNullable(null);
     
        //isPresent方法用来检查Optional实例是否有值。
        if (name.isPresent()) {
          //调用get()返回Optional值。
          System.out.println(name.get());
        }
     
        try {
          //在Optional实例上调用get()抛出NoSuchElementException。
          System.out.println(empty.get());
        } catch (NoSuchElementException ex) {
          System.out.println(ex.getMessage());
        }
     
        //ifPresent方法接受lambda表达式参数。
        //如果Optional值不为空,lambda表达式会处理并在其上执行操作。
        name.ifPresent((value) -> {
          System.out.println("The length of the value is: " + value.length());
        });
     
        //如果有值orElse方法会返回Optional实例,否则返回传入的错误信息。
        System.out.println(empty.orElse("There is no value present!"));
        System.out.println(name.orElse("There is some value!"));
     
        //orElseGet与orElse类似,区别在于传入的默认值。
        //orElseGet接受lambda表达式生成默认值。
        System.out.println(empty.orElseGet(() -> "Default Value"));
        System.out.println(name.orElseGet(() -> "Default Value"));
     
        try {
          //orElseThrow与orElse方法类似,区别在于返回值。
          //orElseThrow抛出由传入的lambda表达式/方法生成异常。
          empty.orElseThrow(ValueAbsentException::new);
        } catch (Throwable ex) {
          System.out.println(ex.getMessage());
        }
     
        //map方法通过传入的lambda表达式修改Optonal实例默认值。
        //lambda表达式返回值会包装为Optional实例。
        Optional<String> upperName = name.map((value) -> value.toUpperCase());
        System.out.println(upperName.orElse("No value found"));
     
        //flatMap与map(Funtion)非常相似,区别在于lambda表达式的返回值。
        //map方法的lambda表达式返回值可以是任何类型,但是返回值会包装成Optional实例。
        //但是flatMap方法的lambda返回值总是Optional类型。
        upperName = name.flatMap((value) -> Optional.of(value.toUpperCase()));
        System.out.println(upperName.orElse("No value found"));
     
        //filter方法检查Optiona值是否满足给定条件。
        //如果满足返回Optional实例值,否则返回空Optional。
        Optional<String> longName = name.filter((value) -> value.length() > 6);
        System.out.println(longName.orElse("The name is less than 6 characters"));
     
        //另一个示例,Optional值不满足给定条件。
        Optional<String> anotherName = Optional.of("Sana");
        Optional<String> shortName = anotherName.filter((value) -> value.length() > 6);
        System.out.println(shortName.orElse("The name is less than 6 characters"));
     
      }
     
    }

    上述代码输出如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    Sanaulla
    No value present
    The length of the value is: 8
    There is no value present!
    Sanaulla
    Default Value
    Sanaulla
    No value present in the Optional instance
    SANAULLA
    SANAULLA
    Sanaulla
    The name is less than 6 characters

     

     

    实例展示

    假如有一个Person 对象,它有一个Address 属性,而Address属性还嵌套一个validFrom的日期。所有的值都可能是null。
    好了,现在我们来判断一下Person 的这些属性是否是Valid的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    private boolean validAddress(NullPerson person{
        if (person != null{
            if (person.getAddress(!= null{
                final Instant validFrom = person.getAddress().getValidFrom();
                return validFrom != null && validFrom.isBefore(now());
            else
                return false;
        else
            return false;
    }

    或者也可以这么写:

    1
    2
    3
    4
    return person != null &&
           person.getAddress(!= null &&
           person.getAddress().getValidFrom(!= null &&
           person.getAddress().getValidFrom().isBefore(now());

    总之 都不是很好看。

    但如果这些属性都是Optional,那么看起来会稍微舒服一点。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    class Person {
     
        private final Optional<Address> address;
     
        public Optional<Address> getAddress({
            return address;
        }
     
        //...
    }
     
    class Address {
        private final Optional<Instant> validFrom;
     
        public Optional<Instant> getValidFrom({
            return validFrom;
        }

        //...
    }

    以下代码就实现了一样的判断:

    1
    2
    3
    4
    5
    return person.
            flatMap(Person::getAddress).
            flatMap(Address::getValidFrom).
            filter(x -> x.before(now())).
            isPresent();

    使用Optional以后,NullPointerException 就从此消失了。

    将一个Optional转为List或者Set

    Optional是一个集合,虽然里面只有0或者1个元素,但它一样是一个集合。如果要转为List或者Set,一般的写法可以是:

    1
    2
    3
    4
    5
    public static <T> List<T> toList(Optional<T> option{
        return option.
                map(Collections::singletonList).
                orElse(Collections.emptyList());
    }

    或者更传统的写法:

    1
    2
    3
    4
    5
    6
    public static <T> List<T> toList(Optional<T> option{
        if (option.isPresent())
            return Collections.singletonList(option.get());
        else
            return Collections.emptyList();
    }

    但是在java8里,其实只需要这么写:

    1
    2
    3
    4
    5
    import static java.util.stream.Collectors.*;
    //转为List
    List<String> list = collect(opt, toList());
    //转为Set
    Set<String>  set  = collect(opt, toSet());
    展开全文
  • Java8 Optional用法

    2020-01-05 20:53:42
    Optional.empty(): // 创建一个空的Optional实例 Optional.of(object); // 不允许object为null Optional.ofNullable(object); // 允许object为null 2. 方法 get() 获取optional中的对象,当optional 容器为空...

    1.实例

    Optional.empty():// 创建空的Optional
    Optional.of(object); // object不允许为null
    Optional.ofNullable(object); // object允许为null

    2. 方法

    get()
    // 获取optional中的对象,当optional 容器为空时报错

    isPresent()
    // 判断optional是否为空,为空返回false,否则返回true

    ifPresent(Consumer c)
    // optional不为空,则将optional中的对象传给Comsumer函数

    orElse(T other)
    // optional为空默认返回 other

    orElseGet(Supplier other)
    // optional为空默认使用Supplier函数生成默认值other

    orElseThrow(Supplier exception)
    // optional为空默认抛出异常

    filter(Predicate p)
    // 如果p的结果为true,则返回原本的optional,否则返回空的optional

    map(Function<T, U> mapper)
    // 映射对象

    flatMap(Function<T, Optional< U>> mapper)
    // 将对象映射成另外一个optional

    3.使用

    // 将对象放入Optional
    Optional studentOptional = Optional.ofNullable(student);

    // 是否为空
    studentOptional.isPresent();

    // 为空抛异常
    Student student = studentOptional.orElseThrow(Exception::new)
    Student student = studentOptional.orElseThrow(() -> new Exception(“error message”));

    // 为空默认为空字符串
    String name = studentOptional.map(Student::getName).orElse("");

    展开全文
  • Optional用法(Java SE 8–Java SE 9)

    万次阅读 2017-01-15 19:15:17
    Optional 是一个包含或着不包含一个非空值的容器对象。如果一个值存在,isPresent()将会返回true 并且 get() 将会返回所对应的值. 其他的方法依赖于所包含的值是否出现,比如orElse(如果值不存在就返回一个默认值...

    原文:原文地址
    Introduction
    Optional 是一个包含或着不包含一个非空值的容器对象。如果一个值存在,isPresent()将会返回true 并且 get() 将会返回所对应的值.
    其他的方法依赖于所包含的值是否出现,比如orElse(如果值不存在就返回一个默认值)并且ifPresent()(如果值存在就执行一个代码块)。
    Examples
    Map
    使用Optionalmap() 方法去处理可能为null 的值,而并不做显式的null 类型检查:
    Syntax:

    public <U> Optional<U> map(Function<? super T,? extends U> mapper)

    代码示例:

    String value = null;
    
    return Optional.ofNullable(value).map(String::toUpperCase).orElse("NONE");
    // returns "NONE"
    String value = "something";
    
    return Optional.ofNullable(value).map(String::toUpperCase).orElse("NONE");
    // returns "SOMETHING"

    Note that the map() and filter() operations are evaluated immediately, unlike their Stream counterparts which are only evaluated upon a terminal operation.
    注意到map()filter() 操作很快被evaluated , 不像他们的Stream counterparts 在出现终端操作的时候才被evaluated。(Stream中 如果没有出现终端操作流 前面的调用将不被考虑)

    Null-safe chaining
    因为 当它的mapping函数返回null Optional.map() 就会返回一个空的Optional,你能够链式的调用map() 操作来作为空指针安全的一种解决方式。考虑下面的列子:

    String value = foo.getBar().getBaz().toString();

    getBar, getBaz, 和toString 可能潜在的抛出NullPointerException 接下来变换一种方式使用Optional来从toString() 中得到值 :

    String value = Optional.ofNullable(foo)
                           .map(Foo::getBar)
                           .map(Bar::getBaz)
                           .map(Baz::toString)
                           .orElse("");

    如果任何一个mapping函数返回null 结果都将返回一个空字符串。

    Optional.ofNullable(foo)
            .map(Foo::getBar)
            .map(Bar::getBaz)
            .map(Baz::toString)
            .ifPresent(System.out::println);

    这个例子仅仅在没有任何mapping函数返回null 的情况下打印该值。

    Return default value if Optional is empty
    不要使用Optional.get() 因为这可能抛出 NoSuchElementException .。Optional.orElse(T)Optional.orElseGet(Supplier<? extends T>) 方法提供了一个方法当Optional是空的时候提供一个默认值。

    String value = "something";
    
    return Optional.ofNullable(value).orElse("defaultValue");
    // returns "something"
    
    return Optional.ofNullable(value).orElseGet(() -> getDefaultValue());
    // returns "something" (never calls the getDefaultValue() method)
    String value = null;
    
    return Optional.ofNullable(value).orElse("defaultValue");
    // returns "defaultValue"
    
    return Optional.ofNullable(value).orElseGet(() -> getDefaultValue());
    // calls getDefaultValue() and returns its results

    orElseorElseGet 的关键不同之处在于当Optional为空后者才被调用同时返回的参数被提供给前者(ofNullable),前者是无论Optional是否为空都会被调用。orElse 因此应该被用于常量,并且永远不会提供基于任何排序计算的值。
    Throw exception if there is no value edit share

    使用Optional 方法的orElseThrow() 方法去得到所包含的值或着抛出一个异常,如果值从未被设置。 除了它允许任意的异常类型,这和调用get()很相似 , 这个方法采用一个必须返回将要抛出异常的supplier。
    在第一个示例中,方法简单的返回所包含的值:

    Optional optional = Optional.of("something");
    
    return optional.orElseThrow(IllegalArgumentException::new);
    // returns "something" string

    第二个样例中,方法抛出一个异常,因为值从未被set

    Optional optional = Optional.empty();
    
    return optional.orElseThrow(IllegalArgumentException::new);
    // throws IllegalArgumentException

    如果抛出异常的话你也可以使用lambda语法,message是必须的。

    optional.orElseThrow(() -> new IllegalArgumentException("Illegal"));
    

    Using Optional containers for primitive number types
    OptionalDouble, OptionalIntOptionalLong 的工作就像Optional ,但是它们被专门的被设计为包装基本类型:

    OptionalInt presentInt = OptionalInt.of(value);
    OptionalInt absentInt = OptionalInt.empty();

    因为数字类型都有一个值,所以没有专门的对于null的处理,空的containers 能够被检查:

    presentInt.isPresent(); // Is true.
    absentInt.isPresent(); // Is false.

    类似的,shorthands 存在去补充对值的管理

    // Prints the value since it is provided on creation.
    presentInt.ifPresent(System.out::println);
    
    // Gives the other value as the original Optional is empty.
    int finalValue = absentInt.orElseGet(this::otherValue);
    
    // Will throw a NoSuchElementException.
    int nonexistentValue = absentInt.getAsInt();

    Filter
    filter() 被用来表示能够匹配你给定的条件的某些你想要的值。 把他想象成if (!somePredicate(x)) { x = null; }.
    代码示例:

    String value = null;
    Optional.ofNullable(value) // nothing
            .filter(x -> x.equals("cool string"))// this is never run since value is null
            .isPresent(); // false
    String value = "cool string";
    Optional.ofNullable(value) // something
            .filter(x -> x.equals("cool string"))// this is run and passes
            .isPresent(); // true
    String value = "hot string";
    Optional.ofNullable(value) // something
            .filter(x -> x.equals("cool string"))// this is run and fails
            .isPresent(); // false

    Lazily provide a default value using a Supplier
    (使用Supplier懒惰的提供一个默认值)
    正常的 orElse 方法需要一个Object 对象作为参数,所以你可能想知道为什么有一个选项来提供Supplier
    Consider:

    String value = "something";
    return Optional.ofNullable(value)
                   .orElse(getValueThatIsHardToCalculate()); // returns "something"

    它仍然会调用getValueThatIsHardToCalculate() 即使它的结果没有被使用,因为optional非空。
    要避免这个“惩罚”,你要提供一个supplier:

    String value = "something";
    return Optional.ofNullable(value)
                   .orElseGet(() -> getValueThatIsHardToCalculate()); // returns "something"

    这样 getValueThatIsHardToCalculate() 只有在Optional 为空的时候才会被调用。
    Run code only if there is a value present
    (当值存在的时候才运行代码)

    Optional<String> optionalWithValue = Optional.of("foo");
    optionalWithValue.ifPresent(System.out::println);//Prints "foo".
    
    Optional<String> emptyOptional = Optional.empty();
    emptyOptional.ifPresent(System.out::println);//Does nothing.

    flatMap
    flatMapmap 很相似, 但是如果你链式的调用返回Optional 的方法,你可能更倾向于使用flatMap ,这样你最终不用使用嵌套的Optionals
    Given the following classes:

    class Foo {
        Optional<Bar> getBar(){
            return Optional.of(new Bar());
        }
    }
    
    class Bar {
    }

    如果你使用map, 你将得到嵌套的Optional<Optional<Bar>>

    Optional<Optional<Bar>> nestedOptionalBar =
        Optional.of(new Foo())
            .map(Foo::getBar);

    然而,当使用flatMap ,一个简单的Optional<Bar> 被返回

    Optional<Bar> optionalBar =
        Optional.of(new Foo())
            .flatMap(Foo::getBar);

    译者补充
    假设你有一个会返回Optional<T> 的方法f, 并且目标类型T有一个会返回Optional<U> 的方法g。如果他们都是普通的方法,你可能会考虑调用s.f().g() 将他们组合起来。但是这种组合是行不通的。因为s.f()方法返回的是Optional<T> 而不是T,但是我们可以调用:

    Optional<U> = s.f().flatMap(T::g);

    假设有一个Test类包含一个计算平方根的静态方法和inverse(Double x)方法

    public class Test {
        public static Optional<Double> squareRoot(Double x) {
            return x < 0 ? Optional.empty() : Optional.of(Math.sqrt(x));
        }
        public static Optional<Double> inverse(Double x) {
            return x == 0 ? Optional.empty() : Optional.of(1 / x);
        }
    //那么我们可以这样计算反转值的平方根:
        public static void main(String[] args) {
            Optional<Double> result = Optional.of(4.0).flatMap(Test::inverse).flatMap(Test::squareRoot);
            result.ifPresent(System.out:: println);
        }
    }

    如果inversesquareRoot 有任何一个返回Optional.empty(), 结果都返回空

    Optional<Double> result = Optional.of(-4.0).flatMap(Test::inverse).flatMap(Test::squareRoot);
    // return Optional.empty
    展开全文
  • JAVA Optional用法分享

    2020-08-28 13:37:00
    本篇文章主要给大家分析了JAVA中Optional用法以及代码分析,跟着小编学习下吧。
  • java8 Optional 用法解析

    2018-12-25 16:50:28
    java8 Optional 用法解析 全局实例:  //调用工厂方法创建Optional实例 Optional&lt;String&gt; name = Optional.of("Sanaulla"); // name = Sanaulla Optional empty = Optional.ofNullable...
  • Java8之Optional用法

    2019-09-06 14:50:46
    Optional是Guava提出的概念,通过使用检查空值的方式来防止代码污染,鼓励程序员写更干净的代码,解决空指针异常NullPointerException。受到Google Guava的启发,Optional在Java8正式加入Java豪华套餐。Optional实际...
  • Java8 Optional用法详解

    2019-12-16 01:10:35
  • java8-Optional用法

    2018-04-09 00:42:35
    本文整理Optional常用用法。 of 为非null的值创建一个Optional。of方法通过工厂方法创建Optional类。需要注意的是,创建对象时传入的参数不能为null。如果传入参数为null,则抛出NullPointerException 。 //调用...
  • 关于optional用法

    2018-03-09 16:24:39
    optional是一个工具类,用来避免空指针异常,与传统java中用if判断是否为null相比,optional最大的优点是可以避免if嵌套(逐层判断是否为null), 可以链式调用,语义化非常好,简洁,易懂。 ...
  • Optional 的基本用法

    2018-07-06 10:17:00
    Optional 的基本用法 参考: https://www.cnblogs.com/xingzc/p/5778090.html http://www.runoob.com/java/java8-optional-class.html empty static <T> Optional<T> e...
  • Java 8 Optional 详细用法

    千次阅读 2019-01-08 23:14:19
    Optional 是一个对象容器,具有以下两个特点:  提示用户要注意该对象有可能为null  简化if else代码 二、使用介绍 1. 创建:  Optional.empty(): 创建一个空的 Optional 实例  Optional.of(T t):创建一...
  • Java 8 Optional用法

    2019-08-20 09:54:08
    1、Optional 用法 /** * Optional 用法 * * @author xuweizhi * @since 2019-08-20 */ public class OptionTest { /** * Optional.of() Optional.ofNullAble() Optional.empty() */ @Test p...
  • 根据Oracle文档,Optional是一个容器对象,可以包含也可以不包含非null值。Optional在Java 8中引入,目的是解决  NullPointerExceptions的问题。本质上,Optional是一个包装器类,其中包含对其他对象的...
  • 文章目录简介Option之前Option特性创建Optional对象Optional对象相关操作方法get()orElse(T other)ifPresent(Consumer<? super T>)orElseThrow(Supplier<? extends X> exceptionSupplier)其他Optional...
  • om.xml里面依赖dependency的元素标签optional的作用 比如父工程引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactI....
  • 主要介绍了Java8 Optional原理及用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 通常来说,我使用Optional是用来设置默认值的,杜绝null的出现。但是最近使用Optional.of报空指针了。。 那么我们先看看源码: /** * Returns an {@code Optional} with the specified present non-null value....
  • java8 Optional用法解析

    千次阅读 2016-07-12 16:48:45
    在Java中,null代表一个不存在的对象,如果对它进行操作就会抛出java.lang.NullPointerException异常。NPE(NullPointerException)是调试程序最常见的异常。google一下有很多关于方法到底应该返回null还是new一个空...
  • Java8-Optional简单用法

    2019-01-17 11:06:43
    Optional: 这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。 public class OptionalTest { private String name; private int age; private boolean ...

空空如也

1 2 3 4 5 ... 20
收藏数 30,459
精华内容 12,183
关键字:

optional