null.equals Java (objeto o)

Question

Yo sé que no es posible llamar al método de igual a igual en un objeto nulo así:

//NOT WORKING 
      String s1 = null; 
      String s2 = null; 
      if(s1.equals(s2)) 
      { 
       System.out.println("NOT WORKING :'("); 
      } 

Pero en mi caso quiero comparar dos objetos de la base de datos y estos dos dos objetos pueden tener atributos nulos ...

Entonces, ¿cuál es el método para comparar dos atributos, sabiendo que no estamos seguros de que el valor sea nulo o esté lleno?

Este método es bueno o no?

//WORKING 
      String s1 = "test"; 
      String s2 = "test"; 
      if(s1 == s2 || s1.equals(s2)) 
      { 
       System.out.println("WORKING :)"); 
      } 

      //WORKING 
      String s1 = null; 
      String s2 = null; 
      if(s1 == s2 || s1.equals(s2)) 
      { 
       System.out.println("WORKING :)"); 
      } 

No estoy seguro porque en este caso no funciona ...:

//NOT WORKING 
      String s1 = null; 
      String s2 = null; 
      if(s1.equals(s2)|| s1 == s2 ) 
      { 
       System.out.println("NOT WORKING :'''("); 
      } 

Answer 1

general utilizo una función de utilidad estática que escribí llamado equalsWithNulls para resolver este problema :

class MyUtils { 
    public static final boolean equalsWithNulls(Object a, Object b) { 
    if (a==b) return true; 
    if ((a==null)||(b==null)) return false; 
    return a.equals(b); 
    } 
} 

Uso:

if (MyUtils.equalsWithNulls(s1,s2)) { 
    // do stuff 
} 

Ventajas de este enfoque:

• Concluye la complejidad de la prueba de igualdad completa en una llamada a función única. Creo que esto es mucho mejor que incorporar un conjunto de pruebas booleanas complejas en tu código cada vez que haces esto. Es mucho menos probable que genere errores como resultado.
• Hace que su código sea más descriptivo y, por lo tanto, más fácil de leer.
• Al mencionar explícitamente los nulos en el nombre del método, le comunica al lector que debe recordar que uno o ambos argumentos pueden ser nulos.
• Prueba primero la (a == b) (una optimización que evita la necesidad de llamar a.es igual a (b) en el caso bastante común que a y b son no nulos pero se refieren exactamente al mismo objeto)

Answer 2

La razón por la que está recibiendo una NullPointerException cuando se hace s1.equals(s2) con s1 siendo nula es no porque de s2 es nulo, pero porque intenta invocar el método equals en s1, que es nulo.

Tratar de modificar de esta manera:

if(s1 != null && s1.equals(s2){ /*...*/ } 

También tenga en cuenta que si s1 no es nulo y s2 es, usted obtendrá una false volver de igual a igual, pero sin NullPointerException.

Answer 3

Usted tendrá que comprobar al menos uno no es nula antes de hacer iguales método -

if(s1 == s2 || (s1!=null && s1.equals(s2))) { 
    System.out.println("WORKING :)"); 
} 

aquí s1==s2 funcionará en caso de null==null. Pero si incluso uno no es nulo, entonces necesita verificar atleast s1 antes de hacer iguales.

Actualización: Como editado por @ 'Bernard Paulus, si está utilizando Java 7, puede utilizar java.util.Objects.equals(Object, Object)

Answer 4

 String s1 = null; 
     String s2 = null; 

     if(s1 != null && s2 != null && s1.equals(s2)) { 
      System.out.println("equals"); 
     } else { 
      System.out.println("not equals"); 
     } 

Answer 5

Creo que está comparando dos objetos.

por lo que debe ser como este

if(s1==null & s2 == null) // both null but equal 
    return true; 
else if(s1 != null && s2 != null && s1.equals(s2)) // both not null and equal 
    return true; 
else 
    return false; 

verdad - por igual Falso - para no igual

Answer 6

Si usted quiere saber si algo es 'nulo' se pueden comparar usando:

if(s1==null) 

Si es nulo, le dirá la verdad. Problema, si tiene un String que es nulo, no puede usar los métodos iguales(). Por esta razón, su tercera parte no funciona, porque si es igual no puede usar un puntero nulo.

Primero debe verificar si el objeto es nulo y luego si no es nulo, utilice los métodos iguales.

Por otro lado, tenga cuidado porque tal vez quiera comparar el String vacío, en este caso debe usar equal (""). Si desea comparar la cadena vacía, es mejor que se pone en primer lugar la cadena vacía en este camino:

"".equals(YourStringNotNull); 

Lo siento por mi Inglés espero que le ayuda.

Answer 7

Trate de usar la clase ObjectUtils de org.apache.commons.lang

public static boolean equals(java.lang.Object object1, 
         java.lang.Object object2) 

De la documentación de la API ...

Compara dos objetos para la igualdad, en donde uno o ambos objetos pueden ser nula .

ObjectUtils.equals (null, null) = true

ObjectUtils.equals (null, "") = false

ObjectUtils.equals ("", null) = false

ObjectUtils. es igual a ("", "") = true

ObjectUtils.equals (Boolean.TRUE, null) = false

ObjectUtils.equals (Boolean.TRUE, "true") = false

ObjectUtils.equals (Boolean.TRUE, Boolean.TRUE) = true

ObjectUtils.equals (Boolean.TRUE, Boolean.FALSE) = false

Answer 8

Invocación de un operador de punto (método de llamada o de objetos propiedades) en el objeto nulo será siempre throw RuntimeException (Excepción son los miembros estáticos ya que no pertenecen al objeto sino a la clase).

El fragmento de código funciona solo porque || es un operador de acceso directo:

String s1 = null; 
String s2 = null; 
if(s1 == s2 || s1.equals(s2)) 

que no evalúa el lado derecho si el lado izquierdo es cierto.

Igual para & &: no evalúa el lado derecho si el lado izquierdo es falso.

Answer 9

Otra opción de usar:

Objects.equals(identification, criteria.getIdentification()) 

java.util.Objects

Esta clase consiste de métodos de utilidad estáticas para operar sobre objetos. Estas utilidades incluyen métodos nulos o tolerantes a la nulidad para calcular el código hash de un objeto, devolver una cadena para un objeto y comparar dos objetos.

desde: 1,7

public static boolean equals(Object a, Object b)

devuelve verdadero si los argumentos son iguales entre sí y falso lo contrario. En consecuencia, si ambos argumentos son nulos, se devuelve verdadero y si exactamente un argumento es nulo, se devuelve falso. De lo contrario, la igualdad se determina utilizando el método equals del primer argumento .