in

¿La mejor manera de verificar valores nulos en Java?

apple touch icon@2

¿La mejor manera de verificar valores nulos en Java? – Desbordamiento de pila


















Pedido

Visto218k veces

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

¿Cuál es la mejor forma 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...
}

8

El método 4 es el mejor.

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

utilizará evaluación de cortocircuito, lo que significa que termina si la primera condición de un logical AND Es falso.

3

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

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

Porque en logico &&

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

Prefiero leer:Cortocircuito del operador lógico Java

1

  • No atrapar NullPointerException. Esa es una mala práctica. Es mejor asegurarse de que el valor no sea nulo.
  • El método n. ° 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, no es necesario evaluar las expresiones posteriores.

4

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. Sabe que el elemento puede ser nulo, por lo que no es una situación excepcional, es algo que debe verificar.

El método 2 lo hace más complicado de lo necesario.

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

4

En Java 7, puedes usar Objects.requireNonNull(). Agregar una importación de Objects clase 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");
    }
    //...
}

3

Yo diría que el método 4 es el modismo más general del código que he visto. Pero esto siempre me huele un poco. Se asume que foo == null es lo mismo que foo.bar () == false.

Eso no siempre me parece bien.

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, captura de NullPointerException, está mal visto la mayor parte del tiempo cuando una simple verificación nula sería suficiente.

Si controla la API que se llama, considere usar Clase opcional de guayaba

Más información aquí. Cambie su método para devolver un Optional<Boolean> en 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 prácticos en Optional

Como han dicho otros, el número 4 es el mejor método cuando no se utiliza 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 detectará 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){

1

También puedes usar StringUtils.isNoneEmpty("") porque el cheque es nulo o está vacío.

Si va a verificar con doble igual «==», verifique nulo con objeto ref como

if(null == obj) 

en lugar de

if(obj == null)

porque si escribe mal single equal if (obj = null) devolverá verdadero (la asignación de objeto devuelve éxito (que es ‘verdadero’ en valor).

2

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 su 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).

si no tiene acceso a la biblioteca apache de commons, lo siguiente probablemente funcionará bien

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

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

tklabel

Python – Etiqueta Tkinter

gfg 200x200 min

Operadores de Python – GeeksforGeeks

Back to Top
close