Clase Java.util.Objects en Java

Java 7 ha creado una nueva clase Objetos que tiene 9 métodos de utilidad estáticos para operar en objetos. Estas utilidades incluyen métodos a prueba de nulos para calcular el código hash de un objeto, devolver una string para un objeto y comparar dos objetos.

Usando los métodos de la clase Objects, uno puede manejar inteligentemente NullPointerException y también puede mostrar un mensaje NullPointerException personalizado (si ocurre una excepción).

String toString(Object o) : este método devuelve el resultado de llamar al método toString() para un argumento no nulo y «null» para un argumento nulo.

Syntax : 
public static String toString(Object o)
Parameters : 
o - an object
Returns :
the result of calling toString() method for a non-null argument and 
"null" for a null argument

String toString(Object o, String nullDefault) : este método es una versión sobrecargada del método anterior. Devuelve el resultado de llamar al método toString() en el primer argumento si el primer argumento no es nulo y, de lo contrario, devuelve el segundo argumento.

Syntax : 
public static String toString(Object o, String nullDefault)
Parameters : 
o - an object
nullDefault - string to return if the first argument is null
Returns :
the result of calling toString() method on the first argument if it is not null and
the second argument otherwise.

// Java program to demonstrate Objects.toString(Object o) 
// and Objects.toString(Object o, String nullDefault) methods
  
import java.util.Objects;
  
class Pair<K, V> 
{
    public K key;
    public V value;
  
    public Pair(K key, V value) 
    {
        this.key = key;
        this.value = value;
    }
      
    @Override
    public String toString() {
        return "Pair {key = " + Objects.toString(key) + ", value = " + 
                    Objects.toString(value, "no value") + "}";
          
        /* without Objects.toString(Object o) and 
         Objects.toString(Object o, String nullDefault) method
         return "Pair {key = " + (key == null ? "null" : key.toString()) + 
     ", value = " + (value == null ? "no value" : value.toString()) + "}"; */
    }
}
  
class GFG
{
    public static void main(String[] args) 
    {
        Pair<String, String> p1 = 
                        new Pair<String, String>("GFG", "geeksforgeeks.org");
        Pair<String, String> p2 = new Pair<String, String>("Code", null);
          
        System.out.println(p1);
        System.out.println(p2);
    }
}

Producción:

Pair {key = GFG, value = geeksforgeeks.org}
Pair {key = Code, value = no value}

boolean equals(Object a,Object b) : este método es verdadero si los argumentos son iguales entre sí y falso en caso 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.

Syntax : 
public static boolean equals(Object a,Object b)
Parameters : 
a - an object
b - an object to be compared with a for equality
Returns :
true if the arguments are equal to each other and false otherwise

// Java program to demonstrate equals(Object a, Object b) method
  
import java.util.Objects;
  
class Pair<K, V> 
{
    public K key;
    public V value;
  
    public Pair(K key, V value) 
    {
        this.key = key;
        this.value = value;
    }
  
    @Override
    public boolean equals(Object o)
    {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair<?, ?> p = (Pair<?, ?>) o;
        return Objects.equals(p.key, key) && Objects.equals(p.value, value);
          
    }
}
  
class GFG
{
    public static void main(String[] args) 
    {
        Pair<String, String> p1 = 
                new Pair<String, String>("GFG", "geeksforgeeks.org");
          
        Pair<String, String> p2 = 
                new Pair<String, String>("GFG", "geeksforgeeks.org");
          
        Pair<String, String> p3 = 
                new Pair<String, String>("GFG", "www.geeksforgeeks.org");
          
        System.out.println(p1.equals(p2));
        System.out.println(p2.equals(p3));
          
    }
}

Producción:

true
false

boolean deepEquals(Object a,Object b) : este método devuelve verdadero si los argumentos son profundamente iguales entre sí y falso en caso contrario. Dos valores nulos son profundamente iguales. Si ambos argumentos son arrays, se utiliza el algoritmo de Arrays.deepEquals para determinar la igualdad. De lo contrario, la igualdad se determina utilizando el método equals del primer argumento.
```
Syntax : 
public static boolean deepEquals(Object a,Object b)
Parameters : 
a - an object
b - an object to be compared with a for equality
Returns :
true if the arguments are deeply equals to each other and false otherwise
```
T requireNonNull(T obj) : este método verifica que la referencia del objeto especificado no sea nula. Este método está diseñado principalmente para realizar la validación de parámetros en métodos y constructores, como se demuestra en el siguiente ejemplo:
```
Syntax : 
public static  T requireNonNull(T obj)
Type Parameters:
T - the type of the reference
Parameters : 
obj - the object reference to check for nullity
Returns :
obj if not null
Throws:
NullPointerException - if obj is null
```

T requireNonNull(T obj,String message) : este método es una versión sobrecargada del método anterior con impresión de mensajes personalizados si obj es nulo, como se muestra en el siguiente ejemplo:

Syntax : 
public static  T requireNonNull(T obj,String message)
Type Parameters:
T - the type of the reference
Parameters : 
obj - the object reference to check for nullity
message - detail message to be used in the event that a NullPointerException is thrown
Returns :
obj if not null
Throws:
NullPointerException - if obj is null

// Java program to demonstrate Objects.requireNonNull(Object o) 
// and Objects.requireNonNull(Object o, String message) methods
  
import java.util.Objects;
  
class Pair<K, V> 
{
    public K key;
    public V value;
  
    public Pair(K key, V value) 
    {
        this.key = key;
        this.value = value;
    }
  
    public void setKey(K key) {
        this.key = Objects.requireNonNull(key);
    }
      
    public void setValue(V value) {
        this.value = Objects.requireNonNull(value, "no value");
    }
}
  
class GFG
{
    public static void main(String[] args) 
    {
        Pair<String, String> p1 = 
                    new Pair<String, String>("GFG", "geeksforgeeks.org");
          
        p1.setKey("Geeks");
          
        // below statement will throw NPE with customized message
        p1.setValue(null);
          
    }
}

Producción:

Exception in thread "main" java.lang.NullPointerException: no value
    at java.util.Objects.requireNonNull(Objects.java:228)
    at Pair.setValue(GFG.java:22)
    at GFG.main(GFG.java:36)

int hashCode(Object o) : este método devuelve el código hash de un argumento no nulo y 0 para un argumento nulo.

Syntax : 
public static int hashCode(Object o)
Parameters : 
o - an object
Returns :
the hash code of a non-null argument and 0 for a null argument

// Java program to demonstrate Objects.hashCode(Object o) object
  
import java.util.Objects;
  
class Pair<K, V> 
{
    public K key;
    public V value;
  
    public Pair(K key, V value) 
    {
        this.key = key;
        this.value = value;
    }
  
    @Override
    public int hashCode()
    {
        return (Objects.hashCode(key) ^ Objects.hashCode(value));
          
        /* without Objects.hashCode(Object o) method
        return (key == null ? 0 : key.hashCode()) ^ 
        (value == null ? 0 : value.hashCode()); */
    }
}
  
class GFG
{
    public static void main(String[] args) 
    {
        Pair<String, String> p1 = 
                new Pair<String, String>("GFG", "geeksforgeeks.org");
        Pair<String, String> p2 = 
                new Pair<String, String>("Code", null);
        Pair<String, String> p3 = new Pair<String, String>(null, null);
          
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());
    }
}

Producción:

450903651
2105869
0

int hash(Objeto… valores) : Este método genera un código hash para una secuencia de valores de entrada. El código hash se genera como si todos los valores de entrada se colocaran en una array, y esa array se codificara llamando a Arrays.hashCode(Object[]).
Este método es útil para implementar Object.hashCode() en objetos que contienen varios campos. Por ejemplo, si un objeto que tiene tres campos, x, y y z, uno podría escribir:

@Override 
public int hashCode() {
     return Objects.hash(x, y, z);
}

Nota : cuando se proporciona una única referencia de objeto, el valor devuelto no es igual al código hash de esa referencia de objeto. Este valor se puede calcular llamando a hashCode(Object).

Syntax : 
public static int hash(Object... values)
Parameters : 
values - the values to be hashed
Returns :
a hash value of the sequence of input values

// Java program to demonstrate Objects.hashCode(Object o) object
  
import java.util.Objects;
  
class Pair<K, V> 
{
    public K key;
    public V value;
  
    public Pair(K key, V value) 
    {
        this.key = key;
        this.value = value;
    }
  
    @Override
    public int hashCode()
    {
        return (Objects.hash(key,value));
    }
}
  
class GFG
{
    public static void main(String[] args) 
    {
        Pair<String, String> p1 = 
                new Pair<String, String>("GFG", "geeksforgeeks.org");
        Pair<String, String> p2 = 
                new Pair<String, String>("Code", null);
        Pair<String, String> p3 = new Pair<String, String>(null, null);
          
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());
    }
}

Producción:

453150372
65282900
961

int compare(T a,T b,Comparator c) : Como de costumbre, este método devuelve 0 si los argumentos son idénticos y c.compare(a, b) en caso contrario. En consecuencia, si ambos argumentos son nulos, se devuelve 0.
Tenga en cuenta que si uno de los argumentos es nulo, se puede lanzar o no una NullPointerException dependiendo de la política de ordenación, si la hay, que Comparator elige tener para los valores nulos.
```
Syntax : 
public static  int compare(T a,T b,Comparator c)
Type Parameters:
T - the type of the objects being compared
Parameters : 
a - an object
b - an object to be compared with a
c - the Comparator to compare the first two arguments
Returns :
0 if the arguments are identical and c.compare(a, b) otherwise.
```

Nota: en Java 8, la clase Objects tiene 3 métodos más. Dos de ellos ( isNull(Object o) y nonNull(Object o) ) se utilizan para comprobar la referencia nula . La tercera es una versión más sobrecargada del método requireNonNull. Consulte aquí .

Publicación traducida automáticamente

Artículo escrito por gaurav miglani y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta