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

public class CamelCaseToUnderscoreConverter {

    public static <T> Map<String, Object> convertToMap(T entity) {
        return convertToMap(entity, new HashSet<>());
    }

    private static <T> Map<String, Object> convertToMap(T entity, Set<Object> visited) {
        Map<String, Object> result = new HashMap<>();

        try {
            if (entity == null || visited.contains(entity)) {
                return result;
            }

            visited.add(entity);

            Class<?> clazz = entity.getClass();
            Field[] fields = clazz.getDeclaredFields();

            for (Field field : fields) {
                field.setAccessible(true);
                String camelCaseName = field.getName();
                String underscoreName = camelCaseToUnderscore(camelCaseName);
                Object value = field.get(entity);

                if (value != null) {
                    if (isSimpleType(value)) {
                        result.put(underscoreName, value);
                    } else if (value instanceof Collection<?>) {
                        Collection<?> collection = (Collection<?>) value;
                        List<Map<String, Object>> collectionList = new ArrayList<>();
                        for (Object item : collection) {
                            collectionList.add(convertToMap(item, visited));
                        }
                        result.put(underscoreName, collectionList);
                    } else if (value.getClass().isArray()) {
                        Object[] array = (Object[]) value;
                        List<Map<String, Object>> arraylist = new ArrayList<>();
                        for (Object item : array) {
                            arraylist.add(convertToMap(item, visited));
                        }
                        result.put(underscoreName, arraylist);
                    } else {
                        result.put(underscoreName, convertToMap(value, visited));
                    }
                }
            }

        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return result;
    }

    private static String camelCaseToUnderscore(String camelCase) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < camelCase.length(); i++) {
            char currentChar = camelCase.charAt(i);
            if (Character.isUpperCase(currentChar)) {
                result.append("_").append(Character.toLowerCase(currentChar));
            } else {
                result.append(currentChar);
            }
        }
        return result.toString();
    }

    private static boolean isSimpleType(Object obj) {
        return obj instanceof String ||
               obj instanceof Number ||
               obj instanceof Boolean ||
               obj instanceof Date;
    }

    public static void main(String[] args) {
        // 示例用法
        YourEntity innerEntity = new YourEntity();
        innerEntity.setInnerField("InnerValue");

        YourEntity entity = new YourEntity();
        entity.setUserName("JohnDoe");
        entity.setAge(25);
        entity.setInnerEntity(innerEntity);

        List<YourEntity> entityList = new ArrayList<>();
        entityList.add(entity);

        Map<String, Object> resultMap = CamelCaseToUnderscoreConverter.convertToMap(entity);
        System.out.println(resultMap);
    }
}