¿Cuál es la mejor manera de saber si todas las variables en una clase son nulas?

Esto significaría que la clase se inicializó, pero las variables no se establecieron.

Una clase de muestra:

public class User {

    String id = null;
    String name = null;

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

La clase real es enorme que prefiero no comprobar. if(xyz == null) para cada una de las variables.

Otra solución no reflectante para Java 8, en la línea de la respuesta de paxdiabo pero sin usar una serie de if‘s, sería transmitir todos los campos y verificar la nulidad:

return Stream.of(id, name)
        .allMatch(Objects::isNull);

Esto sigue siendo bastante fácil de mantener mientras evita la reflexión. martillo.

Prueba algo como esto:

public boolean checkNull() throws IllegalAccessException {
    for (Field f : getClass().getDeclaredFields())
        if (f.get(this) != null)
            return false;
    return true;            
}

Aunque probablemente sería mejor verificar cada variable si es factible.

Esto se puede hacer con bastante facilidad utilizando un Lombok generado equals y una estática EMPTY objeto:

import lombok.Data;

public class EmptyCheck {
    public static void main(String[] args) {
        User user1 = new User();

        User user2 = new User();
        user2.setName("name");

        System.out.println(user1.isEmpty()); // prints true
        System.out.println(user2.isEmpty()); // prints false
    }

    @Data
    public static class User {
        private static final User EMPTY = new User();

        private String id;
        private String name;
        private int age;

        public boolean isEmpty() {
            return this.equals(EMPTY);
        }
    }
}

requisitos previos:

• El constructor predeterminado no debe implementarse con un comportamiento personalizado, ya que se usa para crear el EMPTY objeto
• Todos los campos de la clase deben tener un implementado equals (Los tipos de Java incorporados generalmente no son un problema, en el caso de tipos personalizados, puede usar Lombok)

Ventajas:

• No hay reflexión involucrada
• Como se agregaron nuevos campos a la clase, esto no requiere ningún mantenimiento ya que debido a Lombok, se verificarán automáticamente en el equals implementación
• A diferencia de otras respuestas, esto funciona no solo para comprobaciones nulas, sino también para tipos primitivos que tienen un valor predeterminado no nulo (por ejemplo, si el campo es int lo comprueba 0en caso de boolean por falseetc.)

Si quieres esto para pruebas unitarias, solo uso el hasNoNullFieldsOrProperties() método de assertj

assertThat(myObj).hasNoNullFieldsOrProperties();

¿Qué hay de las corrientes?

public boolean checkFieldsIsNull(Object instance, List<String> fieldNames) {

    return fieldNames.stream().allMatch(field -> {
        try {
            return Objects.isNull(instance.getClass().getDeclaredField(field).get(instance));
        } catch (IllegalAccessException | NoSuchFieldException e) {
            return true;//You can throw RuntimeException if need.
        }
    });
}

“Mejor” es un término tan subjetivo 🙂

Simplemente usaría el método de verificar cada variable individual. Si su clase ya tiene muchos de estos, el aumentar en tamaño no va a ser tanto si haces algo como:

public Boolean anyUnset() {
    if (  id == null) return true;
    if (name == null) return true;
    return false;
}

Siempre que mantenga todo en el mismo orden, los cambios de código (y la verificación automática con un script si está paranoico) serán relativamente sencillos.

Alternativamente (asumiendo que son todas cadenas), básicamente podría poner estos valores en un mapa de algún tipo (por ejemplo, HashMap) y solo mantenga una lista de los nombres clave para esa lista. De esa manera, podría iterar a través de la lista de claves, verificando que los valores estén configurados correctamente.

Creo que esta es una solución que resuelve su problema fácilmente: (devuelve verdadero si alguno de los parámetros no es nulo)

  public boolean isUserEmpty(){ 
boolean isEmpty;
isEmpty =  isEmpty = Stream.of(id,
            name)
        .anyMatch(userParameter -> userParameter != null);

return isEmpty;}

Otra solución para la misma tarea es: (puede cambiarlo a if (isEmpty==0) comprueba si todos los parámetros son nulos.

public boolean isUserEmpty(){  
       long isEmpty;
            isEmpty = Stream.of(id,
                    name)
                    .filter(userParameter -> userParameter != null).count();
    
          return  isEmpty > 0

    }