本章包括 18 个涉及对象、不变性和switch表达式的问题。本章从处理null引用的几个问题入手。它继续处理有关检查索引、equals()和hashCode()以及不变性（例如，编写不可变类和从不可变类传递/返回可变对象）的问题。本章的最后一部分讨论了克隆对象和 JDK12switch表达式。本章结束时，您将掌握对象和不变性的基本知识。此外，你将知道如何处理新的switch表达式。在任何 Java 开发人员的武库中，这些都是有价值的、非可选的知识。

问题

使用以下问题来测试您的对象、不变性和switch表达式编程能力。我强烈建议您在转向解决方案和下载示例程序之前，尝试一下每个问题：

使用命令式代码检查null函数式引用：编写程序，对给定的函数式引用和命令式代码进行null检查。

检查null引用并抛出一个定制的NullPointerException错误：编写一个程序，对给定的引用执行null检查并抛出带有定制消息的NullPointerException。

检查null引用并抛出指定的异常（例如，IllegalArgumentException：编写一个程序，对给定的引用执行null检查并抛出指定的异常。

检查null引用并返回非null默认引用：编写程序，对给定引用执行null检查，如果是非null，则返回；否则返回非null默认引用。

检查从 0 到长度范围内的索引：编写一个程序，检查给定索引是否在 0（含）到给定长度（不含）之间。如果给定索引超出 0 到给定长度的范围，则抛出IndexOutOfBoundsException。

检查从 0 到长度范围内的子范围：编写一个程序，检查给定的开始到给定的结束的给定的子范围，是否在 0 到给定的长度的范围内。如果给定的子范围不在范围内，则抛出IndexOutOfBoundsException。

解释equals()和hashCode()并举例说明equals()和hashCode()方法在 Java 中是如何工作的。

不可变对象概述：解释并举例说明什么是 Java 中的不可变对象。

不可变字符串：解释String类不可变的原因。

编写不可变类：写一个表示不可变类的程序。

向不可变类传递或从不可变类返回可变对象：编写一个程序，向不可变类传递或从不可变类返回可变对象。

通过构建器模式编写一个不可变类：编写一个表示不可变类中构建器模式实现的程序。51. 避免不可变对象中的坏数据：编写防止不可变对象中的坏数据的程序。

克隆对象：编写一个程序，演示浅层和深层克隆技术。

覆盖toString()：解释并举例说明覆盖toString()的实践。

switch表达式：简要概述 JDK12 中的switch表达式。

多个case标签：写一段代码，用多个case标签举例说明 JDK12switch。

语句块：编写一段代码，用于举例说明 JDK12 switch，其中的case标签指向花括号块。

以下各节介绍上述每个问题的解决方案。记住，通常没有一个正确的方法来解决一个特定的问题。另外，请记住，这里显示的解释仅包括解决问题所需的最有趣和最重要的细节。下载示例解决方案以查看更多详细信息，并尝试程序。

40 在函数式和命令式代码中检查空引用

与函数样式或命令式代码无关，检查null引用是一种常用且推荐的技术，用于减少著名的NullPointerException异常的发生。这种检查被大量用于方法参数，以确保传递的引用不会导致NullPointerException或意外行为。

例如，将List<Integer>传递给方法可能需要至少两个null检查。首先，该方法应该确保列表引用本身不是null。其次，根据列表的使用方式，该方法应确保列表不包含null对象：

List<Integer> numbers 
  = Arrays.asList(1, 2, null, 4, null, 16, 7, null);

此列表将传递给以下方法：

public static List<Integer> evenIntegers(List<Integer> integers) {
  if (integers == null) {
    return Collections.EMPTY_LIST;
  }
  List<Integer> evens = new ArrayList<>();
  for (Integer nr: integers) {
    if (nr != null && nr % 2 == 0) {
      evens.add(nr);
    }
  }
  return evens;
}

注意，前面的代码使用依赖于==和!=运算符（integers==null、nr !=null的经典检查。从 JDK8 开始，java.util.Objects类包含两个方法，它们基于这两个操作符包装null检查：object == null包装在Objects.isNull()中，object != null包装在Objects.nonNull()中。

基于这些方法，前面的代码可以重写如下：

public static List<Integer> evenIntegers(List<Integer> integers) {
  if (Objects.isNull(integers)) {
    return Collections.EMPTY_LIST;
  }
  List<Integer> evens = new ArrayList<>();
  for (Integer nr: integers) {
    if (Objects.nonNull(nr) && nr % 2 == 0) {
      evens.add(nr);
    }
  }
  return evens;
}

现在，代码在某种程度上更具表现力，但这并不是这两种方法的主要用法。实际上，这两个方法是为了另一个目的（符合 API 注解）而添加的——在 Java8 函数式代码中用作谓词。在函数式代码中，null检查可以如下例所示完成：

public static int sumIntegers(List<Integer> integers) {
  if (integers == null) {
    throw new IllegalArgumentException("List cannot be null");
  }
  return integers.stream()
    .filter(i -> i != null)
    .mapToInt(Integer::intValue).sum();
}
public static boolean integersContainsNulls(List<Integer> integers) {
  if (integers == null) {
    return false;
  }
  return integers.stream()
    .anyMatch(i -> i == null);
}

很明显，i -> i != null和i -> i == null的表达方式与周围的代码不一样。让我们用Objects.nonNull()和Objects.isNull()替换这些代码片段：

public static int sumIntegers(List<Integer> integers) {
  if (integers == null) {
    throw new IllegalArgumentException("List cannot be null");
  }
  return integers.stream()
    .filter(Objects::nonNull)
    .mapToInt(Integer::intValue).sum();
}
public static boolean integersContainsNulls(List<Integer> integers) {
  if (integers == null) {
    return false;
  }
  return integers.stream()
    .anyMatch(Objects::isNull);
}

或者，我们也可以使用Objects.nonNull()和Objects.isNull()方法作为参数：

public static int sumIntegers(List<Integer> integers) {
  if (Objects.isNull(integers)) {
    throw new IllegalArgumentException("List cannot be null");
  }
  return integers.stream()
    .filter(Objects::nonNull)
    .mapToInt(Integer::intValue).sum();
}
public static boolean integersContainsNulls(List<Integer> integers) {
  if (Objects.isNull(integers)) {
    return false;
  }
  return integers.stream()
    .anyMatch(Objects::isNull);
}

令人惊叹的！因此，作为结论，无论何时需要进行null检查，函数式代码都应该依赖于这两种方法，而在命令式代码中，这是一种偏好。

41 检查空引用并引发自定义`NullPointerException`

检查null引用并用定制消息抛出NullPointerException可以使用以下代码完成（此代码执行这四次，在构造器中执行两次，在assignDriver()方法中执行两次）：

public class Car {
  private final String name;
  private final Color color;
  public Car(String name, Color color) {
    if (name == null) {
      throw new NullPointerException("Car name cannot be null");
    }
    if (color == null) {
      throw new NullPointerException("Car color cannot be null");
    }
    this.name = name;
    this.color = color;
  }
  public void assignDriver(String license, Point location) {
    if (license == null) {
      throw new NullPointerException("License cannot be null");
    }
    if (location == null) {
      throw new NullPointerException("Location cannot be null");
    }
  }
}

因此，这段代码通过结合==操作符和NullPointerException类的手动实例化来解决这个问题。从 JDK7 开始，这种代码组合隐藏在一个名为Objects.requireNonNull()的static方法中。通过这种方法，前面的代码可以用表达的方式重写：

public class Car {
  private final String name;
  private final Color color;
  public Car(String name, Color color) {
    this.name = Objects.requireNonNull(name, "Car name cannot be 
      null");
    this.color = Objects.requireNonNull(color, "Car color cannot be 
      null");
  }
  public void assignDriver(String license, Point location) {
    Objects.requireNonNull(license, "License cannot be null");
    Objects.requireNonNull(location, "Location cannot be null");
  }
}

因此，如果指定的引用是null，那么Objects.requireNonNull()将抛出一个包含所提供消息的NullPointerException。否则，它将返回选中的引用。

在构造器中，当提供的引用是null时，有一种典型的抛出NullPointerException的方法。但在方法上（例如，assignDriver()），这是一个有争议的方法。一些开发人员更喜欢返回一个无害的结果或者抛出IllegalArgumentException。下一个问题，检查空引用并抛出指定的异常（例如，IllegalArgumentException），解决了IllegalArgumentException方法。

在 JDK7 中，有两个Objects.requireNonNull()方法，一个是以前使用的，另一个是抛出带有默认消息的NullPointerException，如下例所示：

this.name = Objects.requireNonNull(name);

从 JDK8 开始，还有一个Objects.requireNonNull()。这个将NullPointerException的自定义消息封装在Supplier中。这意味着消息创建被推迟，直到给定的引用是null（这意味着使用+操作符连接消息的各个部分不再是一个问题）。

举个例子：

this.name = Objects.requireNonNull(name, () 
  -> "Car name cannot be null ... Consider one from " + carsList);

如果此引用不是null，则不创建消息。

42 检查空引用并引发指定的异常

当然，一种解决方案需要直接依赖于==操作符，如下所示：

if (name == null) {
  throw new IllegalArgumentException("Name cannot be null");
}

因为没有requireNonNullElseThrow()方法，所以这个问题不能用java.util.Objects的方法来解决。抛出IllegalArgumentException或其他指定的异常可能需要一组方法，如下面的屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ure4cICg-1657077359609)(img/fcd54997-7ebf-46d7-8eea-c80bb23be82a.png)]

让我们关注一下requireNonNullElseThrowIAE()方法。这两个方法抛出IllegalArgumentException，其中一个自定义消息被指定为String或Supplier（在null被求值为true之前避免创建）：

public static <T> T requireNonNullElseThrowIAE(
    T obj, String message) {
  if (obj == null) {
    throw new IllegalArgumentException(message);
  }
  return obj;
}
public static <T> T requireNonNullElseThrowIAE(T obj,
    Supplier<String> messageSupplier) {
  if (obj == null) {
    throw new IllegalArgumentException(messageSupplier == null 
      ? null : messageSupplier.get());
  }
  return obj;
}

所以，投掷IllegalArgumentException可以通过这两种方法来完成。但这还不够。例如，代码可能需要抛出IllegalStateException、UnsupportedOperationException等。对于这种情况，最好采用以下方法：

public static <T, X extends Throwable> T requireNonNullElseThrow(
    T obj, X exception) throws X {
  if (obj == null) {
    throw exception;
  }
  return obj;
}
public static <T, X extends Throwable> T requireNotNullElseThrow(
    T obj, Supplier<<? extends X> exceptionSupplier) throws X {
  if (obj != null) {
    return obj;
  } else {
    throw exceptionSupplier.get();
  }
}

考虑将这些方法添加到名为MyObjects的助手类中。如以下示例所示调用这些方法：

public Car(String name, Color color) {
  this.name = MyObjects.requireNonNullElseThrow(name,
    new UnsupportedOperationException("Name cannot be set as null"));
  this.color = MyObjects.requireNotNullElseThrow(color, () ->
    new UnsupportedOperationException("Color cannot be set as null"));
}

此外，我们也可以通过这些例子来丰富MyObjects中的其他异常。

43 检查空引用并返回非空默认引用

通过if-else（或三元运算符）可以很容易地提供该问题的解决方案，如以下示例所示（作为变体，name和color可以声明为非final，并在声明时用默认值初始化）：

public class Car {
  private final String name;
  private final Color color;
  public Car(String name, Color color) {
    if (name == null) {
      this.name = "No name";
    } else {
      this.name = name;
    }
    if (color == null) {
      this.color = new Color(0, 0, 0);
    } else {
      this.color = color;
    }
  }
}

但是，从 JDK9 开始，前面的代码可以通过Objects类的两个方法简化。这些方法是requireNonNullElse()和requireNonNullElseGet()。它们都有两个参数，一个是检查空值的引用，另一个是在检查的引用为null时返回的非null默认引用：

public class Car {
  private final String name;
  private final Color color;
  public Car(String name, Color color) {
    this.name = Objects.requireNonNullElse(name, "No name");
    this.color = Objects.requireNonNullElseGet(color,
      () -> new Color(0, 0, 0));
  }
}

44 检查从 0 到长度范围内的索引

首先，让我们用一个简单的场景来突出这个问题。此场景可能在以下简单类中实现：

public class Function {
  private final int x;
  public Function(int x) {
    this.x = x;
  }
  public int xMinusY(int y) {
    return x - y;
  }
  public static int oneMinusY(int y) {
    return 1 - y;
  }
}

注意，前面的代码片段没有对x和y进行任何范围限制。现在，让我们施加以下范围（这在数学函数中非常常见）：

x必须介于 0（含）和 11（不含）之间，所以x属于[0, 11)。

在xMinusY()方法中，y必须在 0（含）x（不含）之间，所以y属于[0, x)。

在oneMinusY()方法中，y必须介于 0（包含）和 16（排除）之间，所以y属于[0, 16)。

这些范围可以通过if语句在代码中施加，如下所示：

public class Function {
  private static final int X_UPPER_BOUND = 11;
  private static final int Y_UPPER_BOUND = 16;
  private final int x;
  public Function(int x) {
    if (x < 0 || x >= X_UPPER_BOUND) {
      throw new IndexOutOfBoundsException("..."); 
    }
    this.x = x;
  }
  public int xMinusY(int y) {
    if (y < 0 || y >= x) {
      throw new IndexOutOfBoundsException("...");
    }
    return x - y;
  }
  public static int oneMinusY(int y) {
    if (y < 0 || y >= Y_UPPER_BOUND) {
      throw new IndexOutOfBoundsException("...");
    }
    return 1 - y;
  }
}

考虑用更有意义的异常替换IndexOutOfBoundsException（例如，扩展IndexOutOfBoundsException并创建一个类型为RangeOutOfBoundsException的自定义异常）。

从 JDK9 开始，可以重写代码以使用Objects.checkIndex()方法。此方法验证给定索引是否在 0 到长度的范围内，并返回该范围内的给定索引或抛出IndexOutOfBoundsException：

public class Function {
  private static final int X_UPPER_BOUND = 11;
  private static final int Y_UPPER_BOUND = 16;
  private final int x;
  public Function(int x) {
    this.x = Objects.checkIndex(x, X_UPPER_BOUND);
  }
  public int xMinusY(int y) {
    Objects.checkIndex(y, x);
    return x - y;
  }
  public static int oneMinusY(int y) {
    Objects.checkIndex(y, Y_UPPER_BOUND);
    return 1 - y;
  }
}

例如，调用oneMinusY()，如下一个代码片段所示，将导致IndexOutOfBoundsException，因为y可以取[0, 16]之间的值：

int result = Function.oneMinusY(20);

现在，让我们进一步检查从 0 到给定长度的子范围。

45 检查从 0 到长度范围内的子范围

让我们遵循上一个问题的相同流程。所以，这一次，Function类将如下所示：

public class Function {
  private final int n;
  public Function(int n) {
    this.n = n;
  }
  public int yMinusX(int x, int y) {
    return y - x;
  }
}

注意，前面的代码片段没有对x、y和n进行任何范围限制。现在，让我们施加以下范围：

n必须介于 0（含）和 101（不含）之间，所以n属于[0, 101]。

在yMinusX()方法中，由x和y、x、y限定的范围必须是[0, n]的子范围。

这些范围可以通过if语句在代码中施加，如下所示：

public class Function {
  private static final int N_UPPER_BOUND = 101;
  private final int n;
  public Function(int n) {
    if (n < 0 || n >= N_UPPER_BOUND) {
      throw new IndexOutOfBoundsException("...");
    }
    this.n = n;
  }
  public int yMinusX(int x, int y) {
    if (x < 0 || x > y || y >= n) {
      throw new IndexOutOfBoundsException("...");
    }
    return y - x;
  }
}

基于前面的问题，n的条件可以替换为Objects.checkIndex()。此外，JDK9Objects类还提供了一个名为checkFromToIndex(int start, int end, int length)的方法，该方法检查给定的子范围给定的开始、给定的结束是否在 0 到给定的长度的范围内。因此，此方法可应用于yMinusX()方法，以检查x与y所限定的范围是否为 0 到n的子范围：

public class Function {
  private static final int N_UPPER_BOUND = 101;
  private final int n;
  public Function(int n) {
    this.n = Objects.checkIndex(n, N_UPPER_BOUND);
  }
  public int yMinusX(int x, int y) {
    Objects.checkFromToIndex(x, y, n);
    return y - x;
  }
}

例如，由于x大于y，下面的测试将导致IndexOutOfBoundsException：

Function f = new Function(50);
int r = f.yMinusX(30, 20);

除了这个方法之外，Objects还有另一个名为checkFromIndexSize(int start, int size, int length)的方法。该方法检查给定开始时间到给定开始时间加给定大小的子范围，是否在 0 到给定长度的范围内。

Java 编程问题：二、对象、不变性和`switch`表达式

问题

40 在函数式和命令式代码中检查空引用

41 检查空引用并引发自定义`NullPointerException`

42 检查空引用并引发指定的异常

43 检查空引用并返回非空默认引用

44 检查从 0 到长度范围内的索引

45 检查从 0 到长度范围内的子范围

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java 编程问题：二、对象、不变性和`switch`表达式

问题

40 在函数式和命令式代码中检查空引用

41 检查空引用并引发自定义NullPointerException

42 检查空引用并引发指定的异常

43 检查空引用并返回非空默认引用

44 检查从 0 到长度范围内的索引

45 检查从 0 到长度范围内的子范围

热门文章

最新文章

相关课程

相关电子书

相关实验场景

41 检查空引用并引发自定义`NullPointerException`