java中不太常见的东西(3)

引言

上一篇博文我们主要介绍了关于Lambda表达式相关的知识，所以在今天的博文中我想把一个同样还不普及的类介绍给大家，Optional这个类是在Jdk1.8的时候引入的，它的主要功能是判断一个值是否为空，伴随着对数据相应的处理。笔者目前整理的一些blog针对面试都是超高频出现的。大家可以点击链接：http://blog.csdn.net/u012403290

技术点

1、静态工厂
我们在创建一个对象实例的时候，基本上都是靠构造器进行创建的。其实它还有一个更普及，但是你可能没发现的方法。它就是静态工厂方法， 它在类中是以一个静态方法的形态存在，比如说Intger类中有这么一段源码：

 public static Integer valueOf(int i) {//一个静态工厂方法        if (i >= IntegerCache.low && i <= IntegerCache.high)            return IntegerCache.cache[i + (-IntegerCache.low)];        return new Integer(i);    }

从上面的方法中，我们就可以直接返回一个Integer的实例。这种静态工厂方法相对于一般构造器来说有着诸多的优点，这里不一一展开，有兴趣可以参考《effective java》中的第一条。

O**ptional源码解读**

1、类介绍

public final class Optional<T> {}

从类定义上来看，我们可以看出亮点：a、它是一个不可扩展类，和String一样，是用final 修饰的，不能被继承，方法也不能被修改，因为final类中的方法都是默认final的；b、是一个泛型类，这个也是合理的，因为前面说过Optional的核心功能是对数据进行判断，因为对数据的未知，所以泛型的设计显得非常必要。

2、实例创建
以下是Optional的两个构造函数：

    /**     * Constructs an empty instance.     *     * @implNote Generally only one empty instance, {@link Optional#EMPTY},     * should exist per VM.     */    private Optional() {//私有的不带参的构造函数        this.value = null;    }  /**     * Constructs an instance with the value present.     *     * @param value the non-null value to be present     * @throws NullPointerException if value is null     */    private Optional(T value) {//私有的带参构造函数        this.value = Objects.requireNonNull(value);    }

构造函数被定义成private的，说明这个类是不能通过构造函数进行实例化的。但是发现它具有几个可以创建实例等静态工厂方法：

//1    public static<T> Optional<T> empty() {//empty方法，可以反悔一个空的Optional对象        @SuppressWarnings("unchecked")        Optional<T> t = (Optional<T>) EMPTY;        return t;    }/／2  public static <T> Optional<T> of(T value) {//of方法，可以传入一个value值，并返回一个带有value值的Optional对象        return new Optional<>(value);    }//3    public static <T> Optional<T> ofNullable(T value) {//ofNullable方法，如果传入为空就返回一个空的Optional对象，如果传入值不为空就返回一个带有value的Optional对象        return value == null ? empty() : of(value);    }

所以Optional对象不可以通过构造器的方式进行实例化，可以通过静态工厂方法创建一个对应的Optional实例。

3、关键方法

a、get

    /**     * If a value is present in this {@code Optional}, returns the value,     * otherwise throws {@code NoSuchElementException}.     *     * @return the non-null value held by this {@code Optional}     * @throws NoSuchElementException if there is no value present     *     * @see Optional#isPresent()     */    public T get() {//获取Optional的值        if (value == null) {//如果值为null抛出一个错误            throw new NoSuchElementException("No value present");        }        return value;    }

get方法主要就是如果Optional中如果存在值就返回，为null就抛出一个错误。

b、isPresent

     * Return {@code true} if there is a value present, otherwise {@code false}.     *     * @return {@code true} if there is a value present, otherwise {@code false}     */    public boolean isPresent() {        return value != null;//如果值存在返回true，否则返回false    }

是一个boolean的方法，它主要是判Optional中的值是否存在，如果存在就返回true，如果不存在就返回false。

c、ifPresent

    /**     * If a value is present, invoke the specified consumer with the value,     * otherwise do nothing.     *     * @param consumer block to be executed if a value is present     * @throws NullPointerException if value is present and {@code consumer} is     * null     */    public void ifPresent(Consumer<? super T> consumer) {        if (value != null)//如果值是否存在            consumer.accept(value);//值存在就需要调用consumer进行处理    }

关于consumer在昨天的Lambda表达式中我们就介绍过了，它是一个没有返回的函数接口。具体的我们在下面的例子中可以见到。

d、orElse

    /**     * Return the value if present, otherwise return {@code other}.     *     * @param other the value to be returned if there is no value present, may     * be null     * @return the value, if present, otherwise {@code other}     */  public T orElse(T other) {        return value != null ? value : other;//如果值存在则返回这个值，如果值不存在就返回输入    }

这个方法带有一个类型是输入，如果Optional的值不为空，则返回这个值，如果为空那么就返回输入。

e、filter

   /**     * If a value is present, and the value matches the given predicate,     * return an {@code Optional} describing the value, otherwise return an     * empty {@code Optional}.     *     * @param predicate a predicate to apply to the value, if present     * @return an {@code Optional} describing the value of this {@code Optional}     * if a value is present and the value matches the given predicate,     * otherwise an empty {@code Optional}     * @throws NullPointerException if the predicate is null     */    public Optional<T> filter(Predicate<? super T> predicate) {        Objects.requireNonNull(predicate);        if (!isPresent())            return this;        else            return predicate.test(value) ? this : empty();//进行一次判断处理并返回    }

predicate在上一篇博文中也介绍过了，它是一个boolean的参数接口，可以进行条件判断。具体在demo中会掩饰。

f、map

    public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {        Objects.requireNonNull(mapper);        if (!isPresent())            return empty();        else {            return Optional.ofNullable(mapper.apply(value));//用function对value值进行修改        }    }

Function的函数接口在上一篇博文中也介绍过了，它主要是传入一个类型的数据，返回一个类型的数据。在上面的源码种可以看出，返回的类型也是一个Optional的数据。

其实它还有几个方法和Object的方法，因为在上一片博文中没有设计过的东西，这里就不再展开。

一个完整的例子

以下是我写的详细demo：

package com.bw;import java.util.NoSuchElementException;import java.util.Optional;public class OptionalTest {     public static void main(String[] args) {            /**             * 3种静态工厂生产Optional对象             */            //创建一个值为brickworker的Optional对象            Optional<String> o1 = Optional.of("brickworker");            //创建一个空的Optional            Optional<String> o2 = Optional.empty();            //创建一个空的Optional            Optional<String> o3 = Optional.ofNullable(null);            //创建一个值为brickworker的Optional对象            Optional<String> o4 = Optional.ofNullable("brickworker");            //get方法            System.out.println("=========get方法==========");            System.out.println("o1存在值"+o1.get());            try {                 System.out.println("o2存在值"+o2.get());//o2和o3是空，会抛出错误，专门处理            } catch (Exception e) {//不必打印错误            }            try {                 System.out.println("o3存在值"+o3.get());//o2和o3是空，会抛出错误，专门处理            } catch (Exception e) {//不必打印错误            System.out.println("o4存在值"+o4.get());            }            System.out.println("========isPresent方法=========");            if(o1.isPresent()){                System.out.println("o1有数据");            }            if(o2.isPresent()){                System.out.println("o2有数据");            }            if(o3.isPresent()){                System.out.println("o3有数据");            }            if(o4.isPresent()){                System.out.println("o4有数据");            }            System.out.println("===========orElse方法===========");            System.out.println(o1.orElse("o1没值输出这个"));            System.out.println(o2.orElse("o2没值输出这个"));            System.out.println(o3.orElse("o3没值输出这个"));            System.out.println(o4.orElse("o4没值输出这个"));            System.out.println("========map方法=================");            Optional<String> no1 = o1.map(v -> v.toUpperCase());            System.out.println(no1.orElse("new o1如果没值输出这个"));            Optional<String> no2 = o2.map(v -> v.toUpperCase());            System.out.println(no2.orElse("new o2如果没值输出这个"));            Optional<String> no3 = o3.map(v -> v.toUpperCase());            System.out.println(no3.orElse("new o3如果没值输出这个"));            Optional<String> no4 = o4.map(v -> v.toUpperCase());            System.out.println(no4.orElse("new o4如果没值输出这个"));            System.out.println("============filter方法==============");            Optional<String> nno1 = o1.filter(v -> v.indexOf("brick") > -1);//如果字符串中存在brick            System.out.println(nno1.orElse("nnew o1如果没值输出这个"));            Optional<String> nno2 = o2.filter(v -> v.indexOf("brick") > -1);//如果字符串中存在brick            System.out.println(nno2.orElse("nnew o1如果没值输出这个"));            Optional<String> nno3 = o3.filter(v -> v.indexOf("brick") > -1);//如果字符串中存在brick            System.out.println(nno3.orElse("nnew o1如果没值输出这个"));            Optional<String> nno4 = o4.filter(v -> v.indexOf("brick") > -1);//如果字符串中存在brick            System.out.println(nno4.orElse("nnew o1如果没值输出这个"));            System.out.println("==========ifPresent方法==========");            o1.ifPresent(v -> {System.out.println("o1:"+v);});            o2.ifPresent(v -> {System.out.println("o2:"+v);});            o3.ifPresent(v -> {System.out.println("o3:"+v);});            o4.ifPresent(v -> {System.out.println("o4:"+v);});     }}//输出：//=========get方法==========//o1存在值brickworker//o4存在值brickworker//========isPresent方法=========//o1有数据//o4有数据//===========orElse方法===========//brickworker//o2没值输出这个//o3没值输出这个//brickworker//========map方法=================//BRICKWORKER//new o2如果没值输出这个//new o3如果没值输出这个//BRICKWORKER//============filter方法==============//brickworker//nnew o1如果没值输出这个//nnew o1如果没值输出这个//brickworker//==========ifPresent方法==========//o1:brickworker//o4:brickworker

关于Optional类就介绍到这里，如果对于中间出现的Lambda表达式如果有不清楚的，请参考我上一篇博文。

以后大家在对输入值进行判断的时候，就可以用Optional来进行控制，从而防止NPE问题的产生。希望这篇博文对大家所有帮助，如果存在错误请帮忙指出。