统计对象中包含属性值和对象，所有空值数量

要统计一个Java实体类中所有空值（包括对象属性和基本类型/包装器类型的值）的数量，可以使用反射来遍历类的所有字段，并递归地检查对象属性。下面提供了一个示例代码，展示了如何实现这一功能。

假设我们有一个实体类Person，它包含一些基本类型属性、字符串属性以及另一个对象类型的属性（例如Address）。我们将编写一个方法来统计这些属性中的空值数量。

首先定义实体类：

public class Address {
    private String street;
    private String city;

    // 构造函数、getters 和 setters 省略

    public Address() {}

    public Address(String street, String city) {
        this.street = street;
        this.city = city;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

public class Person {
    private String name;
    private Integer age;
    private Address address;

    // 构造函数、getters 和 setters 省略

    public Person() {}

    public Person(String name, Integer age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}

　　接下来是用于统计空值的方法：

import java.lang.reflect.Field;
import java.util.Objects;

public class NullFieldCounter {

    public static int countNullFields(Object obj) throws IllegalAccessException {
        if (obj == null) {
            return 1; // 如果传入的对象本身就是null，则直接返回1
        }

        int nullCount = 0;
        Class<?> clazz = obj.getClass();
        
        while (clazz != null) {
            for (Field field : clazz.getDeclaredFields()) {
                field.setAccessible(true);
                Object fieldValue = field.get(obj);

                if (fieldValue == null) {
                    nullCount++;
                } else if (fieldValue instanceof Iterable) {
                    // 如果是集合类型，可以进一步处理
                    for (Object item : (Iterable<?>) fieldValue) {
                        nullCount += countNullFields(item); // 递归处理集合中的每个元素
                    }
                } else if (field.getType().isPrimitive() || isWrapperType(field.getType())) {
                    continue; // 基本类型或其包装类，不为空
                } else {
                    nullCount += countNullFields(fieldValue); // 递归处理对象属性
                }
            }
            clazz = clazz.getSuperclass(); // 处理父类
        }

        return nullCount;
    }

/**
 * 判断是否是基本类型
 * @param clazz
 * @return
 */

private static boolean isWrapperType(Class<?> clazz) { return clazz.equals(Boolean.class) || clazz.equals(Integer.class) || clazz.equals(Character.class) || clazz.equals(Byte.class) || clazz.equals(Short.class) || clazz.equals(Double.class) || clazz.equals(Long.class) || clazz.equals(Float.class) || clazz.equals(Void.class); } public static void main(String[] args) throws IllegalAccessException { Address address = new Address(null, "New York"); Person person = new Person("John", null, address); System.out.println("Number of null fields: " + countNullFields(person)); } }

这段代码实现了以下功能：

使用反射获取并访问类及其父类的所有字段。
检查每个字段是否为null。
对于非null的复杂对象字段，递归调用countNullFields方法继续检查。
对于集合类型，递归处理集合中的每个元素。
提供了对基本类型及其包装类的特殊处理。
通过这种方式，你可以有效地统计出一个实体类及其关联对象中所有空值的数量。