快速学习Java8新特性第七讲——Optional类

比眉伴天荒 2023-06-23 02:57 2阅读 0赞

在[《快速学习Java8新特性第五讲——强大的Stream API》][Java8_Stream API]这一讲中，我就已经提及到了Optional类。在这一讲中，我将对其做一个更加细致的讲解。

# Optional类是什么？ #

Optional类（java.util.Optional）是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在使用Optional类可以更好的表达这个概念，并且它还可以避免空指针异常。

# Optional类中的常用方法 #

Optional容器类中的常用方法有：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]  
下面，我会举例分别一一介绍以上方法。

## Optional.of(T t) ##

先来看一下Optional类中的of()方法。我们可以使用该方法来构建一个Optional容器类。

@Test
    public void test1() { 
        //创建一个带泛型的Optional容器类
        Optional<Employee> op = Optional.of(new Employee());
        Employee emp = op.get();
        System.out.println(emp);
    }

其中，Employee实体类的内容如下：

package com.meimeixia.java8;
    
    public class Employee { 
    
    	private Integer id;
    	private String name;
    	private Integer age;
    	private Double salary;
    	
    	private Status status;//加个状态
    
    	public Employee() { 
    		super();
    	}
    
    	public Employee(Integer id) { 
    		super();
    		this.id = id;
    	}
    
    	public Employee(Integer id, Integer age) { 
    		super();
    		this.id = id;
    		this.age = age;
    	}
    
    	public Employee(Integer id, String name, Integer age, Double salary) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    	}
    	
    	public Employee(Integer id, String name, Integer age, Double salary, Status status) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    		this.status = status;
    	}
    
    	public Integer getId() { 
    		return id;
    	}
    
    	public void setId(Integer id) { 
    		this.id = id;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public Integer getAge() { 
    		return age;
    	}
    
    	public void setAge(Integer age) { 
    		this.age = age;
    	}
    
    	public Double getSalary() { 
    		return salary;
    	}
    
    	public void setSalary(Double salary) { 
    		this.salary = salary;
    	}
    	
    	public Status getStatus() { 
    		return status;
    	}
    
    	public void setStatus(Status status) { 
    		this.status = status;
    	}
    
    	@Override
    	public int hashCode() { 
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((age == null) ? 0 : age.hashCode());
    		result = prime * result + ((id == null) ? 0 : id.hashCode());
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		result = prime * result + ((salary == null) ? 0 : salary.hashCode());
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) { 
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Employee other = (Employee) obj;
    		if (age == null) { 
    			if (other.age != null)
    				return false;
    		} else if (!age.equals(other.age))
    			return false;
    		if (id == null) { 
    			if (other.id != null)
    				return false;
    		} else if (!id.equals(other.id))
    			return false;
    		if (name == null) { 
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		if (salary == null) { 
    			if (other.salary != null)
    				return false;
    		} else if (!salary.equals(other.salary))
    			return false;
    		return true;
    	}
    	
    	@Override
    	public String toString() { 
    		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
    				+ "]";
    	}
    
    	public enum Status { 
    		FREE,
    		BUSY,
    		VOCATION;
    	}
    
    }

有一点，需要引起我们的注意，of()方法中传入null，会报NullPointerException异常。

@Test
    public void test1() { 
        //创建一个带泛型的Optional容器类
        Optional<Employee> op = Optional.of(null);//of()方法不能构建null
        Employee emp = op.get();
        System.out.println(emp);
    }

如果运行以上测试方法，那么你就能看到所报的NullPointerException异常了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]

## Optional.empty() ##

使用Optional类中的empty()方法可以创建一个空的Optional实例，即里面没有任何的东西。

@Test
    public void test2() { 
        Optional<Employee> op = Optional.empty();//empty()方法只是构建一个空的Optional，里面没有任何的东西
        System.out.println(op.get());
    }

如果运行以上测试方法，那么你就会发现报了`java.util.NoSuchElementException:No value present`这样一个异常，如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]

## Optional.ofNullable(T t) ##

虽然Optional类中的of()方法不允许包装null，但是ofNullable()方法可以，传递到该方法中的若为null，则构建一个空的Optional实例；传递到该方法中的若为一个对象，则构建一个包装有该对象的Optional实例。实际上，ofNullable()方法是empty()方法和of()方法它俩的综合，你要不相信的话，不妨查看一下ofNullable()方法的源代码。  
![在这里插入图片描述][20191217113423397.png]  
你可以试着运行一下以下test3()测试方法：

@Test
    public void test3() { 
        Optional<Employee> op = Optional.ofNullable(new Employee());
    
        //isPresent()方法判断Optional容器类中是否包含值
        if (op.isPresent()) { 
            System.out.println(op.get());
        }
    }

那么，你便可以在Eclipse控制台中看到如下打印内容。  
![在这里插入图片描述][20191217113430361.png]  
如果要是将测试代码改写成下面这样，那么运行test3()测试方法之后，Eclipse控制台将会没有任何内容输出。

@Test
    public void test3() { 
        Optional<Employee> op = Optional.ofNullable(null);
    
        //isPresent()方法判断Optional容器类中是否包含值
        if (op.isPresent()) { 
            System.out.println(op.get());
        }
    }

## isPresent() ##

isPresent()方法用于判断Optional容器类中是否包含值。演示该方法的例子已在上面给出，这里不再赘述。

## orElse(T t) ##

如果调用对象包含有值，那么返回该值，否则返回orElse()方法中的对象。例如，有如下一段测试代码：

@Test
    public void test3() { 
        Optional<Employee> op = Optional.ofNullable(new Employee());
    
        Employee emp = op.orElse(new Employee(109, "杰哥", 18, 8889.88, Status.FREE));
        System.out.println(emp);
    }

运行以上测试方法，你便可以在Eclipse控制台中看到如下打印内容。  
![在这里插入图片描述][20191217113439348.png]  
如果要是将测试代码改写成下面这样：

@Test
    public void test3() { 
        Optional<Employee> op = Optional.ofNullable(null);
    
        Employee emp = op.orElse(new Employee(109, "杰哥", 18, 8889.88, Status.FREE));
        System.out.println(emp);
    }

那么，运行以上测试方法，你便可以在Eclipse控制台中看到如下打印内容。  
![在这里插入图片描述][2019121711344654.png]

## orElseGet(Supplier s) ##

如果调用对象包含有值，那么返回该值，否则返回orElseGet()方法中的供给函数获取的值。例如，有如下一段测试代码：

@Test
    public void test3() { 
        Optional<Employee> op = Optional.ofNullable(new Employee());
    
        Employee emp = op.orElseGet(() -> new Employee(109, "杰哥", 18, 8889.88, Status.FREE));
        System.out.println(emp);
    }

运行以上测试方法，你便可以在Eclipse控制台中看到如下打印内容。  
![在这里插入图片描述][20191217113453628.png]  
如果要是将测试代码改写成下面这样：

@Test
    public void test3() { 
        Optional<Employee> op = Optional.ofNullable(null);
    
        Employee emp = op.orElseGet(() -> new Employee(109, "杰哥", 18, 8889.88, Status.FREE));
        System.out.println(emp);
    }

那么，运行以上测试方法，你便可以在Eclipse控制台中看到如下打印内容。  
![在这里插入图片描述][20191217113505197.png]

## map(Function f) ##

若有值则对其处理，并返回处理后的Optional，否则返回Optional.empty()。为了演示该方法，可以编写如下一段测试代码进行测试。

@Test
    public void test4() { 
        Optional<Employee> op = Optional.ofNullable(new Employee(109, "杰哥", 18, 8889.88, Status.FREE));
        
        Optional<String> str = op.map((e) -> e.getName());
        System.out.println(str.get());
    }

运行以上测试方法，你便可以在Eclipse控制台中看到如下打印内容。  
![在这里插入图片描述][20191217113513849.png]

## flatMap(Function mapper) ##

与map类似，但要求返回值必须是Optional。为了演示该方法，可以编写如下一段测试代码进行测试。

@Test
    public void test4() { 
        Optional<Employee> op = Optional.ofNullable(new Employee(109, "杰哥", 18, 8889.88, Status.FREE));
        
        Optional<String> str2 = op.flatMap((e) -> Optional.of(e.getName()));//进一步地避免空指针异常
        System.out.println(str.get());
    }

但是，你要写成下面这样，就会报错，如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]  
运行以上test4()测试方法，你便可以在Eclipse控制台中看到如下打印内容。  
![在这里插入图片描述][20191217113527594.png]

# 综合案例 #

下面，我会举一个综合案例来说明Optional类在实际开发中的使用。例如，有这样一个需求：男人心中可能会有一个女神（但并不是每一个男人心中都有一个女神），现在要获取一个男人心中女神的名字。

为了解决这样的需求，我们需要建立一个男人类和女神类：

*  男人类，即Man.java。
    
        package com.meimeixia.java8;
        
        public class Man { 
        
            //男人心中可能会有一个女神，但并不是每一个男人心中都有一个女神
            private Godness godness;
        
            public Man() { 
                super();
                // TODO Auto-generated constructor stub
            }
        
            public Man(Godness godness) { 
                super();
                this.godness = godness;
            }
        
            public Godness getGodness() { 
                return godness;
            }
        
            public void setGodness(Godness godness) { 
                this.godness = godness;
            }
        
            @Override
            public String toString() { 
                return "Man [godness=" + godness + "]";
            }
            
        }
 *  女神类，即Godness.java
    
        package com.meimeixia.java8;
        
        public class Godness { 
            
            private String name;//女神肯定得有一个名字，所以这样的值没必要包装在Optional类里面
        
            public Godness() { 
                super();
                // TODO Auto-generated constructor stub
            }
        
            public Godness(String name) { 
                super();
                this.name = name;
            }
        
            public String getName() { 
                return name;
            }
        
            public void setName(String name) { 
                this.name = name;
            }
        
            @Override
            public String toString() { 
                return "Godness [name=" + name + "]";
            }
            
        }

现在，我们要想获取一个男人心中女神的名字，可能一开始会将代码写成下面这样：

package com.meimeixia.java8;
    
    import org.junit.Test;
    
    public class OptionalDemo { 
    	
    	//综合案例
    	@Test
    	public void test() { 
    		Man man = new Man();
    		String name = getGodnessName(man);
    		System.out.println(name);
    	}
    	
    	//需求：获取一个男人心中女神的名字
    	public String getGodnessName(Man man) { 
    		return man.getGodness().getName();
    	}
    	
    }

运行以上test()测试方法，你会发现报NullPointerException异常了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]  
这是因为并不是每一个男人心中都有一个女神，所以获取到的女神有可能为null，继而就会报NullPointerException异常。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]  
要想解决这样的NullPointerException异常，搁之前我们是像下面这样做的：

package com.meimeixia.java8;
    
    import org.junit.Test;
    
    public class OptionalDemo { 
    	
    	//综合案例
    	@Test
    	public void test() { 
    		Man man = new Man();
    		String name = getGodnessName(man);
    		System.out.println(name);
    	}
    	
    	//需求：获取一个男人心中女神的名字
    	public String getGodnessName(Man man) { 
    		// return man.getGodness().getName();
    		
    		if (man != null) { 
    			Godness gn = man.getGodness();
    			if (gn != null) { 
    				return gn.getName();
    			}
    		}
    		
    		return "苍老师";
    	}
    	
    }

现在，我们知道使用Optional类可以很容易地避免控制针异常。那就使用Optional类来试试，首先，我们得重新创建一个新型男人类，即NewMan.java。

package com.meimeixia.java8;
    
    import java.util.Optional;
    
    public class NewMan { 
    	
    	//但是，大家要注意，不给Optional赋值，即Optional没赋值，它默认是什么值？默认是null
    	private Optional<Godness> godness = Optional.empty();//把女神包装进Optional类里面
    	
    	public NewMan() { 
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	
    	public NewMan(Optional<Godness> godness) { 
    		super();
    		this.godness = godness;
    	}
    	
    	public Optional<Godness> getGodness() { 
    		return godness;
    	}
    
    	public void setGodness(Optional<Godness> godness) { 
    		this.godness = godness;
    	}
    
    	@Override
    	public String toString() { 
    		return "NewMan [godness=" + godness + "]";
    	}
    	
    }

然后，在OptionalDemo类编写一个如下方法，用于获取一个男人心中女神的名字。

//一顿点，避免了控制针异常
    public String getGodnessName2(Optional<NewMan> man) { 
        return man.orElse(new NewMan())
                  .getGodness()
                  .orElse(new Godness("苍老师"))
                  .getName();
    }

接着，就要对以上方法进行测试了。

*  第一种情况，测试代码如下：
    
        @Test
        public void test1() { 
            Optional<NewMan> op = Optional.ofNullable(null);
            String str = getGodnessName2(op);
            System.out.println(str);
        }
    
    运行以上测试方法，你便可以在Eclipse控制台中看到如下打印内容。  
    ![在这里插入图片描述][20191217122704325.png]
 *  第二种情况，测试代码如下：
    
        @Test
        public void test1() { 
            Optional<NewMan> op = Optional.ofNullable(new NewMan());
            String str = getGodnessName2(op);
            System.out.println(str);
        }
    
    运行以上测试方法，你也可以在Eclipse控制台中看到如下打印内容。  
    ![在这里插入图片描述][20191217122713173.png]
 *  第三种情况，测试代码如下：
    
        @Test
        public void test1() { 
            Optional<Godness> gn = Optional.ofNullable(null);
            Optional<NewMan> op = Optional.ofNullable(new NewMan(gn));
            String str = getGodnessName2(op);
            System.out.println(str);
        }
    
    运行以上测试方法，你依然可以在Eclipse控制台中看到如下打印内容。  
    ![在这里插入图片描述][20191217122725209.png]
 *  第四种情况，测试代码如下：
    
        @Test
        public void test1() { 
            Optional<Godness> gn = Optional.ofNullable(new Godness("波多野结衣老师"));
            Optional<NewMan> op = Optional.ofNullable(new NewMan(gn));
            String str = getGodnessName2(op);
            System.out.println(str);
        }
    
    运行以上测试方法，你便可以在Eclipse控制台中看到如下打印内容。  
    ![在这里插入图片描述][20191217122733235.png]

## 小结 ##

总之这个Optional类其实就是一个封装了一个元素的容器，而这个元素可以是null也可以是其它任意类型的，合理利用Optional类可以很好地避免程序中出现的空指针异常。

[Java8_Stream API]: https://liayun.blog.csdn.net/article/details/103486105
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191217103204305.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191217113409168.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191217113416584.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191217113423397.png]: https://img-blog.csdnimg.cn/20191217113423397.png
[20191217113430361.png]: https://img-blog.csdnimg.cn/20191217113430361.png
[20191217113439348.png]: https://img-blog.csdnimg.cn/20191217113439348.png
[2019121711344654.png]: https://img-blog.csdnimg.cn/2019121711344654.png
[20191217113453628.png]: https://img-blog.csdnimg.cn/20191217113453628.png
[20191217113505197.png]: https://img-blog.csdnimg.cn/20191217113505197.png
[20191217113513849.png]: https://img-blog.csdnimg.cn/20191217113513849.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191217113521217.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191217113527594.png]: https://img-blog.csdnimg.cn/20191217113527594.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191217122846285.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/2019121712264616.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191217122704325.png]: https://img-blog.csdnimg.cn/20191217122704325.png
[20191217122713173.png]: https://img-blog.csdnimg.cn/20191217122713173.png
[20191217122725209.png]: https://img-blog.csdnimg.cn/20191217122725209.png
[20191217122733235.png]: https://img-blog.csdnimg.cn/20191217122733235.png