vacio - validar si un objeto es null java

¿La mejor manera de verificar valores nulos en Java?

Question

Antes de llamar a una función de un objeto, necesito verificar si el objeto es nulo, para evitar arrojar una NullPointerException .

¿Cuál es la mejor manera de hacerlo? He considerado estos métodos.
¿Cuál es la mejor práctica de programación para Java?

// Method 1
if (foo != null) {
    if (foo.bar()) {
        etc...
    }
}

// Method 2
if (foo != null ? foo.bar() : false) {
    etc...
}

// Method 3
try {
    if (foo.bar()) {
        etc...
    }
} catch (NullPointerException e) {
}

// Method 4 -- Would this work, or would it still call foo.bar()?
if (foo != null && foo.bar()) {
    etc...
}

Answer 1

El Método 4 es de lejos el mejor ya que indica claramente lo que sucederá y utiliza el mínimo de código.

El Método 3 es simplemente incorrecto en todos los niveles. Usted sabe que el artículo puede ser nulo, por lo que no es una situación excepcional, es algo que debe verificar.

El Método 2 simplemente lo está haciendo más complicado de lo necesario.

El Método 1 es solo el método 4 con una línea adicional de código.

Answer 2

El método 4 es mi método preferido. El cortocircuito del operador && hace que el código sea más legible. El Método 3, Capturar NullPointerException, está mal visto la mayor parte del tiempo cuando una simple comprobación nula sería suficiente.

Answer 3

Si controlas que se llame a la API, considera usar la clase opcional de Guava

Más información aquí . Cambie su método para devolver un Optional<Boolean> lugar de un Boolean .

Esto informa al código de llamada que debe tener en cuenta la posibilidad de nulo, llamando a uno de los métodos útiles en Optional

Answer 4

Tu última propuesta es la mejor.

if (foo != null && foo.bar()) {
    etc...
}

Porque:

1. Es más fácil de leer
2. Es seguro: foo.bar () nunca se ejecutará si foo == null.
3. Evita las malas prácticas, como la captura de NullPointerExceptions (la mayoría de las veces debido a un error en tu código)
4. Debería ejecutarse tan rápido o incluso más rápido que otros métodos (aunque creo que debería ser casi imposible notarlo).

Answer 5

Yo diría que el método 4 es la expresión más general del código que he visto. Pero esto siempre se siente un poco mal para mí. Asume que foo == null es lo mismo que foo.bar () == false.

Eso no siempre me parece correcto.

Answer 6

El método 4 es el mejor.

if(foo != null && foo.bar()) {
   someStuff();
}

usará la evaluación de cortocircuito , lo que significa que finaliza si la primera condición de un logical AND es falsa.

Answer 7

• No atrape NullPointerException . Esa es una mala práctica. Es mejor asegurarse de que el valor no sea nulo.
• El método # 4 funcionará para usted. No evaluará la segunda condición, porque Java tiene un cortocircuito (es decir, las condiciones posteriores no se evaluarán si no cambian el resultado final de la expresión booleana). En este caso, si la primera expresión de un AND lógico se evalúa como falsa, las expresiones subsiguientes no necesitan ser evaluadas.

Answer 8

En Java 7 , puede usar Objects.requireNonNull() . Agregue una importación de la clase Objects de java.util .

public class FooClass {
    //...
    public void acceptFoo(Foo obj) {
        //If obj is null, NPE is thrown
        Objects.requireNonNull(obj).bar(); //or better requireNonNull(obj, "obj is null");
    }
    //...
}

Answer 9

Como otros han dicho, # 4 es el mejor método cuando no se usa un método de biblioteca. Sin embargo, siempre debe poner null en el lado izquierdo de la comparación para asegurarse de no asignar accidentalmente null a foo en caso de error tipográfico. En ese caso, el compilador captará el error.

// You meant to do this
if(foo != null){

// But you made a typo like this which will always evaluate to true
if(foo = null)

// Do the comparison in this way
if(null != foo)

// So if you make the mistake in this way the compiler will catch it
if(null = foo){

// obviously the typo is less obvious when doing an equality comparison but it''s a good habit either way
if(foo == null){
if(foo =  null){

Answer 10

si no tiene acceso a la biblioteca commons apache, lo siguiente probablemente funcione bien

if(null != foo && foo.bar()) {
//do something
}

Answer 11

En Java 8, la mejor forma de comprobar si hay nulo es:

Objects.isNull(obj) //returns true if the object is null

Objects.nonNull(obj) //returns true if object is not-null

if(Objects.nonNull(foo) && foo.something()) // Uses short-circuit as well. No Null-pointer Exceptions are thrown.

Aparte de esto ... También puedes ir con la clase opcional de Guava

Reduce los errores tipológicos como (obj=null) que siempre devuelve true como se discutió en las respuestas anteriores.

Answer 12

Podemos usar el método estático Object.requireNonNull de la clase Object. La implementación está debajo

public void someMethod(SomeClass obj) {
    Objects.requireNonNull(obj, "Validation error, obj cannot be null");
}

Answer 13

El último y el mejor. es decir, LÓGICO Y

  if (foo != null && foo.bar()) {
    etc...
}

Porque en lógica &&

no es necesario saber cuál es el lado derecho, el resultado debe ser falso

Prefiero leer: cortocircuito operador lógico Java

Answer 14

Código simple de una línea para verificar nulo:

namVar == null ? codTdoForNul() : codTdoForFul();

Answer 15

También puede usar StringUtils.isNoneEmpty("") para que la verificación sea nula o esté vacía.

Answer 16

Si va a verificar con doble igual "==", entonces marque nulo con objeto ref como

if(null == obj) 

en lugar de

if(obj == null)

porque si escribe mal single igual if (obj = null) devolverá true (la asignación del objeto devuelve success (que es ''verdadero'' en valor).