Java8特性---关于Null

最新推荐文章于 2024-07-22 14:15:06 发布

weixin_30677475

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量101

点赞数

文章标签： java 爬虫 scala

原文链接：http://www.cnblogs.com/shijiaqi1066/p/5713941.html

版权

为了防止无良网站的爬虫抓取文章，特此标识，转载请注明文章出处。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

转载于:https://www.cnblogs.com/shijiaqi1066/p/5713941.html