精华内容
下载资源
问答
  • Optional 使用方法

    千次阅读 2020-09-14 10:17:20
    学习好Optional使用方式,使我们的代码更加健壮。 示例类: class Insurance { private String name; public String getName() { return name; } } class Car { private Optional<Insurance> insurance...

    Java8引入了Optional类来解决NullPointerException的问题。学习好Optional的使用方式,使我们的代码更加健壮。
    示例类:

    class Insurance {
        private String name;
        public String getName() {
            return name;
        }
    }
    class Car {
        private Optional<Insurance> insurance;
        public Optional<Insurance> getInsurance() {
            return insurance;
        }
    }
    public class Person {
        private Optional<Car> car;
        public Optional<Car> getCar() {
            return car;
        }
    }
    

    1.创建Optional对象

    1.1 声明一个空Optional

    Optional<Car> optCar = Optional.empty();
    

    1.2 依据一个非空值创建Optional

    Car car = new Car();
    Optional<Car> optCar2 = Optional.of(car);
    

    1.3 可接受null的Optional

    Car car2 = null;
    Optional<Car> optCar3 = Optional.ofNullable(car2);
    

    2. 从Optional对象中提取和转换值

    Insurance insurance = new Insurance();
    Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
    Optional<String> name = optInsurance.map(Insurance::getName);
    System.out.println(name);
    // output
    // Optional.empty
    

    3. 在Optional对象中flatMap的使用方式

    Optional<Person> person1 = Optional.ofNullable(person);
            String insuranceName = person1.flatMap(Person::getCar)
            .flatMap(Car::getInsurance)
            .map(Insurance::getName)
            .orElse("Unknown");
    

    4. 序列化遇到的问题

    在程序中使用了某些要求序列化的库或者框架,在域模型中使用Optional,有可能引发应用程序故障。这是由于Optional类设计时就没有特别考虑将其作为类的字段使用,所以它也并未实现Serializable接口

    5. filter的用法

    Insurance insurance = new Insurance();
            Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
    optInsurance.filter(ins->"example".equals(ins.getName()))
                    .ifPresent(x->System.out.println("OK"));
    

    基础类型的Optional对象(OptionalInt、OptionalLong及OptionalDouble),避免使用,因为基础类型的Optional不支持map、flatMap以及filter方法

    6 Optional的实战中的用法

    6.1 用Optional封装可能为null的值
    Optional<Object> value = Optional.ofNullable(map.get("key"));
    
    6.2 异常与Optional的对比
    public static Optional<Integer> stringToInt(String s) {
            try {
                return Optional.of(Integer.parseInt(s));
            } catch (NumberFormatException e) {
                e.printStackTrace();
                return Optional.empty();
            }
        }
    
    6.3 Optional整合
    Optional.ofNullable(props.getProperty(name))
            .flatMap(OptionalUtils::stringToInt)
            .filter(i -> i>0)
            .orElse(0);
    

    7 Optional类的用法

    方法描述
    empty返回一个空的Optional实例
    filter如果值存在并且满足提供的谓词,就返回包含该值的Optional对象;否则返回一个空的Optional对象
    flatMap如果值存在,就对该值执行提供的mapping函数调用,返回一个Optional类型的值,否则就返回一个空的Optional对象
    get如果值存在,就将被Optional封装的值返回,否则抛出一个NoSuchElementException异常
    ifPresent如果值存在,就执行使用该值的方法调用,否则什么也不做
    isPresent如果值存在就返回true,否则返回false
    map如果值存在,就对该值执行提供的mapping函数调用
    of将指定用Optional封装之后返回,如果该值为null,则抛出一个NullPointerException异常
    ofNullable将指定值用Optional封装之后返回,如果该值为null,则返回一个空的Optional对象
    orElse如果有值则将其返回,否则返回一个默认值
    orElseGet如果有值则将其返回,否则返回一个由指定的Supplier接口生成的值
    orElseThrow如果有值则将其返回,否则抛出一个由指定的Supplier接口生成的异常
    展开全文
  • Optional使用方法

    2020-06-26 01:06:59
    import java.util.Optional; /** * @author Bingo.Ge * @date 2020年6月26日 */ public class OptionalUsage { /** * @param args */ public static void main(String[] args) { /* * Optional<...
    /**
     * 
     */
    package com.gewb.stream;
    
    import java.util.Optional;
    
    /**
     * @author Bingo.Ge
     * @date 2020年6月26日
     */
    public class OptionalUsage {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		/*
    		 * Optional<Dish> dishOptional = Optional.of(new Dish()); dishOptional.get();
    		 */
    		
    		Optional<Dish> dishOptional2 = Optional.ofNullable(new Dish("Bingo.Ge"));
    		/*
    		 * dishOptional2.orElseGet(Dish::new); 
    		 * dishOptional2.orElse(new Dish());
    		 * dishOptional2.orElseThrow(RuntimeException::new);
    		 * dishOptional2.orElseThrow(()->new RuntimeException("Not have reference"));
    		 */
    		
    		/*
    		 * Dish dish = dishOptional2.filter(i->i.getName()==null).get();
    		 * System.out.println(dish);
    		 */
    		
    		/*
    		 * Optional<String> map = dishOptional2.map(i->i.getName());
    		 * System.out.println(map.orElse("empty value")); // 是否有值
    		 * System.out.println(map.isPresent()); map.ifPresent(System.out::println);
    		 */
    		
    		System.out.println(getDishName(null));
    		System.out.println(getDishNameByOptional(null));
    		
    	}
    
    	private static String getDishName(Dish dish) {
    		if(dish == null) {
    			return "unknown";
    		}
    		
    		return dish.getName();
    	}
    	
    	private static String getDishNameByOptional(Dish dish) {
    		return Optional.ofNullable(dish).map(Dish::getName).orElse("unknown");
    	}
    	
    }
    

     

    展开全文
  • 文章目录简介Option之前Option特性创建Optional对象Optional对象相关操作方法get()orElse(T other)ifPresent(Consumer<? super T>)orElseThrow(Supplier<? extends X> exceptionSupplier)其他Optional...

    简介

    java8中新引入了optional特性,官方说法是更优雅的处理空指针异常,用来表示一个变量的值可以为空也可以不为空,此处引用java 8实战里面的描述:

    在你的代码中始终如一地使用Optional,能非常清晰地界定出变量值的缺失是结构上的问
    题,还是你算法上的缺陷,抑或是你数据中的问题。另外,我们还想特别强调,引入Optional
    类的意图并非要消除每一个null引用。与此相反,它的目标是帮助你更好地设计出普适的API,
    让程序员看到方法签名,就能了解它是否接受一个Optional的值。这种强制会让你更积极地将
    变量从Optional中解包出来,直面缺失的变量值

    所以,optional的作用是显示的表达变量的状态,而不是为了完全消灭NPE。

    Option之前

    talk is cheap,show me the code:

    //根据客户信息获取车辆保险公司的名称
    public String getCarInsuranceName(Person person) { 
    //对客户判空
     if (person == null) { 
     return "Unknown"; 
     } 
     //对车辆判空
     Car car = person.getCar(); 
     if (car == null) { 
     return "Unknown"; 
     } 
     //对保险公司判空
     Insurance insurance = car.getInsurance(); 
     if (insurance == null) { 
     return "Unknown"; 
     } 
     return insurance.getName(); 
    } 
    
    

    以上代码,可能是我日常开发经常遇到的,过多的NullPointerException检查,影响到了代码的可读性以及优雅性,而且存在潜在的风险,假设其中某个环节未做空指针的检查,则会看到我们熟悉而又讨厌的NullPointerException;

    Option特性

    创建Optional对象

    1. 声明一个空的Optional对象
    
    Optional<Car> optCar = Optional.empty(); 
    
    
    1. 依据一个非空值创建Optional
    Optional<Car> optCar = Optional.of(car); 
    
    

    Optional.of为静态工厂方法,参数为非控制,如果为空,则会直接抛出个NullPointerException

    1. 可接受null的Optional
    Optional<Car> optCar = Optional.ofNullable(car);
    

    Optional.ofNullable同样为静态方法,只是参与可为空,如上代码,如果car为null,则会直接返回一个空的Optional对象

    Optional对象相关操作方法

    get()

    Optional对象调用该方法,可以直接获取内容,但是前提是,Optional对象不能为空,否则会抛出NoSuchElementException异常;所以这种方法只有在确定Optional对象非空的情况下调用才是安全的。其实我们只需判断Optional是有值即可,这里官方的api也提供了相关方法,isPresent()返回布尔值来表明Optional对象是否为空

    Optional<String> optional= Optional.of("test");
    if (optional.isPresent()){ 
      String value = optional1.get();//test
    }
    

    orElse(T other)

    它允许你在Optional对象不包含值时提供一个默认值,如下:

    String nullName = null;
    String name=Optional.ofNullable(nullName).orElse("otherName");
    
    1. orElseGet(Supplier<? extends T> other)
      orElseGet是orElse的延伸版,supplier方法只有在optional对象为空的时候才会执行
    String name = Optional.ofNullable(nullName).orElseGet(() -> "otherName");
    

    ifPresent(Consumer<? super T>)

    顾名思义,就是当Optional值存在的时候,执行consume函数方法

    Optional<String> optional = Optional.of("test");
    
    optional.ifPresent(s -> System.out.println(s));
    

    orElseThrow(Supplier<? extends X> exceptionSupplier)

    当Optional值不存的时候,我们也可以抛出异常,异常可以自定义

    其他

    Optional对象也可以使用java8中的steam闲逛的方法,比如map、flatMap、filter这三种函数,引用java8实战中的样例,如下:
    找出年龄大于或者等于minAge参数的Person所对应的保险公司列表。

    public String getCarInsuranceName(Optional<Person> person, int minAge) { 
     return person.filter(p -> p.getAge() >= minAge) 
     .flatMap(Person::getCar) 
     .flatMap(Car::getInsurance) 
     .map(Insurance::getName) 
     .orElse("Unknown"); 
    } 
    
    

    注:当Optional对象为空时,则后面的map、flatMap、filter都不会继续执行

    Optional实践

    用于封装可能为null的值

    Object value = map.get("key");
    

    此时,map.get(“key”)可能为空,这里可用使用Optional进行良好的封装处理,如下:

    Optional<Object> value = Optional.ofNullable(map.get("key"));
    

    这样一来,只要看到这段代码,后面的人就知道该处的value值可能为空,很好的传达了程序处理的合理性,如果像上面那样,可能直接被当成存在对象使用,而引发空指针异常。

    尽量不用于域模型中的某些类型

    Optional的设计者并没有考虑将其作为类的字段使用,所以并没有实现Serializable接口,当使用到关于序列化的相关需求时,可能会引发的程序错误。如果确实有需求,可以采用以下方法作为替代方案:

    public class Person { 
     private Car car; 
     public Optional<Car> getCarAsOptional() { 
     	return Optional.ofNullable(car); 
     } 
    } 
    

    总结

    Optional主要是通过类型系统让你的域模型中隐藏的知识显式地体现在你的代码中,换句话说,你永远都不应该忘记语言的首要功能就是沟通,即使对程序设计语言而言也没有什么不同。声明方法接受一个Optional参数,或者将结果作为Optional类型返回,让你的同事或者未来你方法的使用者,很清楚地知道它可以接受空值,或者它可能返回一个空值。

    参考:
    java 8 in Action
    Java8 Optional用法和最佳实践

    展开全文
  • 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用法

    2021-12-01 18:56:33
    关于Optional 前言 本次向大家介绍下java Optional类 源码描述 官方的描述是这样的: A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true ...
  • Java8之Optional用法

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

    千次阅读 2019-07-18 16:56:05
    1.Optional.of()或者Optional.ofNullable():创建Optional对象,差别在于of不允许参数是null,而ofNullable则无限制。 @Test public void testOptional() { // 参数不能是null Optional<Object> optional...
  • java8 引入了Optional类,让我们可以以一种更加优雅的方式处理代码里的各种null值,但如果只是用Optional的isPresent()方法来代替原来代码中的null判断的话,其实和原来的写法也没有太大的区别,代码依然臃肿,也...
  • Optional用法(Java SE 8–Java SE 9)

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

    千次阅读 2019-01-08 08:43:41
    过去,为了解决空指针异常,Google公司著名的Guava项目引入了Optional类,Guava通过使用检查空值的方式来防止代码污染,它鼓励程序员写更干净的代码。受到Google Guava的启发,Optional类已经成为Java 8类库的一部分...
  • OPTIONAL的一些用法

    2021-01-26 20:32:13
    OPTIONAL的一些用法 TEST
  • Optional常见用法汇总

    2021-04-02 16:14:45
    Optional常见用法汇总 map() 类型转换 private static void test0(){ Optional<A> optionalA = Optional.ofNullable(new A()); Optional<B> optionalB = optionalA.map(A::getB); } orElseThrow() ...
  • Java8 Optional用法

    2021-03-16 22:55:19
    Optional类提供了大约10种方法,我们可以使用它们来创建和使用Optional类,下面将介绍如何使用它们。创建一个Optional类这是用于创建可选实例的三种创建方法。static [Optional] [empty]()返回一个空的Optional实例...
  • jdk1.8-optional用法

    2021-09-23 20:08:24
    optional optional可以防止null异常 错误用法 Optional<Integer> valuationWay = Optional.ofNullable(vo.getValuationWay()); if (valuationWay.isPresent()) { return valuationWay.get(); } ...
  • 对象,Optional对象是jdk1.8以后才支持的,所以要使用jpa2.5x需要至少jdk1.8或以上。 什么是Optional Optional主要是针对null值处理,也就是程序中绝大部分的bug,空指针异常。一方面程序更加的优
  • Java 8 Optional 详细用法

    万次阅读 多人点赞 2019-01-08 23:14:19
    一、简介 Optional 是一个对象容器,具有以下两个...二、使用介绍 1. 创建:  Optional.empty(): 创建一个空的 Optional 实例  Optional.of(T t):创建一个 Optional 实例,当 t为null时抛出异常  Optio...
  • 附上Optional用法大全 普通代码 首先声明:这篇文章是根据此文章《大数据技术与结构》,将现在的项目代码结构进行的二次调整的练习实战! 多层次if/else代码内容: 下面方法作用是:根据不同的类型进行对应的...
  • [转]devm_gpiod_get_optional用法

    千次阅读 2018-08-16 09:54:00
    https://blog.csdn.net/kris_fei/article/details/78932904
  • 我们知道 Java 8 增加了一些很有用的 API, 其中一个就是 Optional,下面这篇文章主要给大家介绍了关于Java8中Optional的一些常见错误用法的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
  • JDK8的Optional用法

    2021-02-25 19:03:29
    https://mp.weixin.qq.com/s/P2kb4fswb4MHfb0Vut_kZg1.描述Optional是java.util包中的一部分,所以要有相关的...2.创建Optional方法2.1empty,创建一个空的Optional@Testpublic voidwhenCreatesEmptyOptional_thenC...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 178,199
精华内容 71,279
关键字:

optional用法

友情链接: 黄金30分EA.rar