处理空指针Optional

Optional可以看作是一个存放对象的容器

	@Test
	public void createOptional() {
		//empty() 给Optional中放入一个null对象
		Optional<Object> empty = Optional.empty();
		System.out.println(empty);
		System.out.println("====================");
		//of(T value) 创建了一个Optional对象并且包含一个value的对象，如果value为空，报异常。
		Optional<Employee> of = Optional.of(new Employee());
		System.out.println(of);
		//Optional<Employee> of2 = Optional.of(null);
		//System.out.println(of2);
		System.out.println("====================");
		/*
		 * ofNullable(T value)方法，与of()方法不同的是在向Optional对象中存放对象时先进行判断
		 *   如果value不为null的话，创建一个Optional对象并且包含一个value的对象，
	     *   如果value为null,  创建一个Optional.empty()对象
		 */
		Optional<Employee> ofNullable = Optional.ofNullable(new Employee());
		System.out.println(ofNullable);
		Optional<Employee> ofNullable2 = Optional.ofNullable(null);
		System.out.println(ofNullable2);
	}
	输出：
	Optional.empty
	====================
	Optional[Employee [name=null, salary=null, age=null, hireDay=null]]
	====================
	Optional[Employee [name=null, salary=null, age=null, hireDay=null]]
	Optional.empty


	//T get() 取出Optional中的对象，如果Optional中的对象为null,抛出异常
	@Test
	public void getTest() {
		Optional<Employee> of = Optional.of(new Employee());
		System.out.println(of.get());
		//Optional<Object> empty = Optional.empty();
		//System.out.println(empty.get());
	}
	输出：
	Employee [name=null, salary=null, age=null, hireDay=null]


	/*
	*   T orElse(T other) 取出Optional中的对象，设置一个默认对象（默认值）,	
	*    如果Optional中的对象为null的时候，就返回默认对象
	*/
	@Test
	public void orElseTest() {
		Optional<Object> empty = Optional.empty();
		System.out.println(empty.orElse(new Employee()));
	}
	输出：
	Employee [name=null, salary=null, age=null, hireDay=null]


	/*
	*  T orElseGet(Supplier<? extends T> other) 与orElse()方法作用相同，
	*  区别在于参数，orElseGet()方法 使用了函数式接口,设置一个默认对象
	*/
	@Test
	public void orElseGetTest() {
		Optional<Object> empty = Optional.empty();
		System.out.println(empty.orElseGet(Employee::new));
	}
	输出：
	Employee [name=null, salary=null, age=null, hireDay=null]


	/*
	*  <X extends Throwable> orElseThrow(Supplier<? extends X> exceptionSupplier)方法
	*  设置一个默认的异常对象， 当取出Optional中的对象时，
	*  如果Optional中的对象为null的时候，抛出指定的默认异常
	*/
	@Test
	public void orElseThrowTest() throws Exception {
		Optional<Object> empty = Optional.empty();
		System.out.println(empty.orElseThrow(Exception::new));
	}
	输出：
	无输出，Optional中是null对象，报Exception异常。


	// boolean isPresent() 判断Optional是否存在对象，如果存在返回true,否则false
	@Test
	public void isPresentTest() {
		Optional<Object> empty = Optional.empty();
		System.out.println(empty.isPresent());
	}
	输出：
	false


	/*
	* void ifPresent(Consumer<? super T> consumer) 判断Optional是否存在对象,
	* 如果存在执行Consumer中的accept()方法
	*/
	@Test
	public void ifPresentTest() {
		Optional<Object> empty = Optional.of(new Employee());
		empty.ifPresent(System.out::println);
	}
	输出：
	Employee [name=null, salary=null, age=null, hireDay=null]
	

	/*
	* Optional<T> filter(Predicate<? super T> predicate) 
	* 把Optional中的对象传入Predicate的方法中,返回值为true，就返回包含该对象的Optional，
	* 如果为false，返回Optional.empty();
	*/
	@Test
	public void filterTest() {
		Optional<Object> optional = Optional.of(new Employee());
		Optional<Object> filter = optional.filter((e)->{
			return e !=null;
		});
		System.out.println(filter);
	}
	输出：
	Optional[Employee [name=null, salary=null, age=null, hireDay=null]]


	/*
	* <U> Optional<U> map(Function<? super T, ? extends U> mapper)
	* 把返回的对象放入Optional中
	*/
	@Test
	public void mapTest() {
		Optional<Employee> optional = Optional.of(new Employee());
		Optional<Employee> map = optional.map((x)->{
			return x;
		});
		System.out.println(map.get());
	}
	输出：
	Employee [name=null, salary=null, age=null, hireDay=null]


	/*
	* <U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper)
	* 返回Optional的对象
	*/
	@Test
	public void flatMapTest() {
		Optional<Employee> optional = Optional.of(new Employee());
		Optional<String> flatMap = optional.flatMap((x)->{
			Optional<String> optional2=Optional.of("abc");
			return optional2;
		});
		System.out.println(flatMap);
	}
	输出：
	Optional[abc]