Java8特性---关于Null

为了防止无良网站的爬虫抓取文章，特此标识，转载请注明文章出处。LaplaceDemon/SJQ。

http://www.cnblogs.com/shijiaqi1066/p/5713941.html

Objects工具类

Objects工具类提供了一些静态方法，用于支持补充对象的一些基础操作。该类在Java 1.7被引入，部分方法1.8引入。某些方法对对象检查null提供一定的支持。

static <T> int	compare(T a, T b, Comparator<? super T> c) 该方法用于比较两个对象。
static boolean	deepEquals(Object a, Object b) 若参数深度相等，则返回true，否则返回false。
static boolean	equals(Object a, Object b) 如果参数相等，则返回true，否则返回false。
static int	hash(Object... values) 计算函数参数列表的Hash值。
static int	hashCode(Object o) 若参数为null，则返回0。否则返回对象的Hash值。
static boolean	isNull(Object obj) 如果对象为null，则返回true；如果对象不为null，则返回false。
static boolean	nonNull(Object obj) 如果对象不为null，则返回true；如果对象为null，则返回false。
static <T> T	requireNonNull(T obj) 检查对象不为null。
static <T> T	requireNonNull(T obj, String message) 检查对象不为null。若为null，则抛出被定制的过的NullPointerException异常。
static <T> T	requireNonNull(T obj, Supplier<String> messageSupplier) 检查对象不为null。若为null，则抛出被定制的过的NullPointerException异常。
static String	toString(Object o) 返回参数的字符串，如果对象为null，则返回null。
static String	toString(Object o, String nullDefault) 返回参数的字符串，如果对象为null，则返回第二个参数nullDefault。

烦人的NullPointException

Java中经常会遇到这样的表达式：

String version = computer.getSoundcard().getUSB().getVersion(); 

这种表达式很爽，但如果getSoundcard、getUSB、getVersion可能会返回Null指针，那么这段代码就必须这样写：

String version = "UNKNOWN";
if(computer != null){
  Soundcard soundcard = computer.getSoundcard();
  if(soundcard != null){
    USB usb = soundcard.getUSB();
    if(usb != null){
      version = usb.getVersion();
    }
  }
}

所以，如果无法确定方法返回的对象是非空的，则我们需要时时刻刻都需要提防调用的方法是否返回null，以防止NullPointerException。

Optional类

受到Haskell和Scala的启发，Java8引入了java.util.Optional<T>类。这是一个容器类。该容器只包含一个值，要么改值存在，要么不存在。

1.创建Optional对象

空的Optional对象

Optional<Soundcard> sc = Optional.empty();

of 工厂方法

为非null的值创建一个Optional。Optional对象的构造方法。如果传入参数为null，则抛出NullPointerException 。

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

ofNullable 工厂方法

为指定的值创建一个Optional。若值为null，则返回一个空的Optional。ofNullable与of方法相似，唯一的区别是可以接受参数为null的情况。

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

2.Null检查与相应的处理。

isPresent

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

get

可以返回Optional容器里的对象。若Optional有值则将其返回；若没有值，抛出NoSuchElementException。

//执行下面的代码会输出：No value present
try {
  //在空的Optional实例上调用get()，抛出NoSuchElementException
  System.out.println(empty.get());
} catch (NoSuchElementException ex) {
  System.out.println(ex.getMessage());
}

get方法与isPresent方法组合可以这样使用：

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

但是注意，这种组合跟null检测没有什么区别，所以并不提倡这样使用Optional。

ifPresent

如果Optional实例有值则为其调用从参数传入consumer，否则不做处理。

要理解ifPresent方法，首先需要了解Consumer类。简答地说，Consumer类包含一个抽象方法。该抽象方法对传入的值进行处理，但没有返回值。Java8支持不用接口直接通过lambda表达式传入参数。

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

//ifPresent方法接受lambda表达式作为参数。
//lambda表达式对Optional的值调用consumer进行处理。
name.ifPresent((value) -> {
  System.out.println("The length of the value is: " + value.length());
});

orElse

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

//如果值不为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接口的实现用来生成默认值。示例如下：

//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表达式或方法，如果值不存在来抛出异常。示例如下：

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定义如下：

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

如果Optional读写没有值，则该方法直接返回空的Optional对象。

如果Optional对象有值，则对其执行调用mapping函数得到返回值。

如果返回值为null，则返回空Optional对象。

如果返回值不为null，则创建包含mapping返回值的Optional作为map方法返回值。

例：

//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方法的mapping函数必须是Optional。

例：

// 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"));

辨析flatMap方法与map方法

flatMap方法与map方法类似。

区别在于:

• map方法的map函数返回值可以是任何类型T。
• flatMap方法中的map函数返回值必须是Optional。调用结束时，flatMap不会对结果用Optional封装。

filter

该方法通过传入lambda表达式对Optional实例的值进行过滤。如果有值并且满足断言条件返回包含该值的Optional，否则返回空Optional。

例：

//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类的各个方法。以下是一个完整的示例：

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"));

  }

}

上述代码输出如下：

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

最后，让我们解决Null调用这个问题：

String version = computer.getSoundcard().getUSB().getVersion();

首先设计的类，类中方法的需要返回Optional对象。

public class Computer {
  private Optional<Soundcard> soundcard;
  public Optional<Soundcard> getSoundcard() { ... }
  ...
}

public class Soundcard {
  private Optional<USB> usb;
  public Optional<USB> getUSB() { ... }

}

public class USB{
  public String getVersion(){ ... }
}

以下是一种错误的实例。这段代码无法通过编译。

String version = computer.map(Computer::getSoundcard)
                  .map(Soundcard::getUSB)
                  .map(USB::getVersion)
                  .orElse("UNKNOWN");

首先computer是Optional类型，Optional类型通过Computer:getSoundcard，该方法返回Optional类型，再包装进map方法，所以最后返回了Optional<Optional<T>>类型，该类型进入到下一个map函数中，参数无法匹配。所以编译不过。

使用flatMap方法控制返回类型，以保障链式调用。

String version = computer.flatMap(Computer::getSoundcard)
                   .flatMap(Soundcard::getUSB)
                   .map(USB::getVersion)
                   .orElse("UNKNOWN");

为了防止无良网站的爬虫抓取文章，特此标识，转载请注明文章出处。LaplaceDemon/SJQ。

http://www.cnblogs.com/shijiaqi1066/p/5713941.html