Forma elegante de código: cómo juzgar vacío en Java

1. Introducción

En el proyecto real, tendremos muchos lugares que necesitan evaluar la verificación nula.Si no se realiza la verificación nula, puede ocurrir una NullPointerException.

Mencionamos el manejo de excepciones en el artículo anterior:

Echemos un vistazo a algunos métodos de juicio vacíos en proyectos reales.

Por lo general, juzgamos si un objeto es nulo, podemos usar Objects.nonNull(obj) en java.util, ObjectUtil en hutool o directamente null != obj

2. Juicio vacío de List

En un proyecto especial como List, no solo se puede juzgar que no está vacío. Para List no igual a nulo y List.size() no igual a 0 son dos cosas diferentes, también hay becarios en la empresa que suelen confundir estas dos, si lista no es igual a nulo significa que se ha inicializado , y hay una parte de la memoria del montón que le pertenece. Site, y un tamaño de 0 significa que no se ha puesto nada. Por ejemplo, si no es igual a nulo, significa que ahora tengo una botella, y un tamaño mayor a 0 significa que he llenado la botella con agua.

En proyectos reales, también se encuentra que list.isEmpty() se usa para juzgar directamente. Echemos un vistazo al código fuente:

Es equivalente a juzgar si hay agua en la botella (la premisa es que la botella ya existe, si la botella no existe, se lanzará una NullPointerException).

Por lo tanto, use list != null && list.size > 0 para juzgar, o use directamente isEmpty de la herramienta CollUtil en HuTool. También hay Conjunto, Mapa, etc.

3. Sentencia nula de String

El concepto de botella y agua todavía se usa aquí.Cuando String es nulo, llamar a equals(String) o length() lanzará java.lang.NullPointerException.

Hay varios métodos para juzgar cadenas vacías:

1. Uno de los métodos utilizados por la mayoría de la gente, intuitivo y conveniente, pero ineficiente:

if(a == null || a.equals(""));

2. Compare la longitud de la cadena, eficiente:

if(a == null || a.length() == 0);

3. Java SE 6.0 acaba de comenzar a proporcionarse y la eficiencia es similar al método 2:

if(a == null || a.isEmpty());

Por supuesto, también puede usar la herramienta org.apache.commons.lang.StringUtils.

StringUtils.no está en blanco(a);

* StringUtils.isNotBlank(null) = false

* StringUtils.isNotBlank("") = false

* StringUtils.isNotBlank(" ") = false

* StringUtils.isNotBlank("bob") = true

* StringUtils.isNotBlank(" bob ") = true

该工具类中还有个isNotEmpty()方法，从注释可以很明显看出二者的差别

StringUtils.isNotEmpty(a);

* StringUtils.isNotEmpty(null) = false

* StringUtils.isNotEmpty("") = false

* StringUtils.isNotEmpty(" ") = true

* StringUtils.isNotEmpty("bob") = true

* StringUtils.isNotEmpty(" bob ") = true

4、Optional

Optional的出现就是用来防止NullpointException的。常见的方法有：

• .empty()：创建一个空的Optional实例
• .of(T t) : 创建一个Optional 实例，为null时报异常
• .ofNullable(T t):若t 不为null,创建Optional 实例,否则创建空实例
• isPresent() : 判断容器中是否有值
• ifPresent(Consume lambda) ：容器若不为空则执行括号中的Lambda表达式
• orElse(T t) : 获取容器中的元素，若容器为空则返回括号中的默认值
• orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回s 获取的值
• orElseThrow() :如果为空，就抛出定义的异常，如果不为空返回当前对象
• map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
• flatMap(Function mapper):与map 类似，要求返回值必须是Optional
• T get() ：获取容器中的元素，若容器为空则抛出NoSuchElement异常

先看个常见的示例：

baseInfo类中有布尔类型的属性，是空返回false，不为空取其值，需要四行。

当使用Optional时，一行搞定，非常的优雅。

4.1 Optional对象的创建

public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();
    private final T value;
    //可以看到两个构造方格都是private 私有的
    //说明 没办法在外面new出来Optional对象
    private Optional() {
        this.value = null;
    }
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    //这个静态方法大致 是创建出一个包装值为空的一个对象因为没有任何参数赋值
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    //这个静态方法大致 是创建出一个包装值非空的一个对象 因为做了赋值
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    //这个静态方法大致是 如果参数value为空，则创建空对象，如果不为空，则创建有参对象
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
}
复制代码

4.2使用场景

场景1：在service层中 查询一个对象，返回之后判断是否为空并做处理

场景2：使用Optional 和函数式编程，一行搞定

5、总结

每种方法的存在必然有适用的场景，有些情况下这种链式编程，虽然代码优雅了。但是，逻辑性没那么明显，可读性有所降低，大家项目中看情况酌情使用。