大写下划线转驼峰工具

package fool.liyc.common.bean;

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 大写下划线转驼峰工具
 */
public class LiCamelCaseUtils {

    public static Object underLineToCamelCase(Object underLineObject) {
        if (isArray(underLineObject)) {
            Object[] objects = doParseCamelCaseOnArray((Object[]) underLineObject);
            return  objects;
        }

        else if (isList(underLineObject)) {
            List list = doParseCamelCaseOnList((List) underLineObject);
            return  list;
        }

        else if (isMap(underLineObject)) {
            Map map = doParseCamelCaseOnMap((Map) underLineObject);
            return  map;
        }

        else if(isBasicType(underLineObject)) {
            return underLineObject;
        }

        else if (isString(underLineObject)) {
            String camelCase = doParseCamelCase(underLineObject.toString());
            return  camelCase;
        }

        return null;
    }

    private static Map doParseCamelCaseOnMap(Map map) {
        Map result = new HashMap();
        for (Object o : map.keySet()) {
            // HashMap可能存在nullKey和nullVal
            if (o!=null) {
                Object val = map.get(o);
                String camelKey = doParseCamelCase(o.toString());
                if (isList(val)) {
                    List camelList = doParseCamelCaseOnList((List)val);
                    result.put(camelKey,camelList);
                }

                else if (isArray(val)) {
                    Object[] objects = doParseCamelCaseOnArray((Object[]) val);
                    result.put(camelKey,objects);
                }

                else if (isMap(val)) {
                    Map parse = doParseCamelCaseOnMap((Map) val);
                    result.put(camelKey,parse);
                }

                else if (isBasicType(val)) {
                    result.put(camelKey,val);
                }

                else if (isString(val)) {
                    Object parse = doParseCamelCaseOnString(val.toString());
                    result.put(camelKey,parse);
                }

                else  {

                }
            }
        }

        return result;
    }

    private static Object doParseCamelCaseOnString(String str) {
        Map parseMap = null;
        if (null != (parseMap = canParseMap(str))) {
            Map res = doParseCamelCaseOnMap(parseMap);
            return res;
        }else {
            return str;
        }
    }

    private static List doParseCamelCaseOnList(List list) {
        List result = new ArrayList();
        for (Object o : list) {
            if (isList(o)) {
                List parseList = doParseCamelCaseOnList((List) o);
                result.add(parseList);
            }

            else if (isArray(o)) {
                Object[] parse = doParseCamelCaseOnArray((Object[]) o);
                result.add(parse);
            }

            else if (isMap(o)) {
                Map map = doParseCamelCaseOnMap((Map) o);
                result.add(map);
            }

            else if (isBasicType(o)) {
                result.add(o);
            }

            else if (isString(o)) {
                Object parse = doParseCamelCaseOnString(o.toString());
                result.add(parse);
            }

            else {

            }
        }
        return result;
    }

    private static Object[] doParseCamelCaseOnArray(Object[] objects) {
        Object[] result = new Object[objects.length];
        for (int i=0; i < objects.length; i++) {
            Object o = objects[i];
            if (isList(o)) {
                List parseList = doParseCamelCaseOnList((List) o);
                result[i] = parseList;
            }

            else if (isArray(o)) {
                Object[] parse = doParseCamelCaseOnArray((Object[]) o);
                result[i] = parse;
            }

            else if (isMap(o)) {
                Map map = doParseCamelCaseOnMap((Map) o);
                result[i] = map;
            }

            else if (isBasicType(o)) {
                result[i] = o;
            }

            else if (isString(o)) {
                Object parse = doParseCamelCaseOnString(o.toString());
                result[i] = parse;
            }

            else {

            }
        }
        return result;
    }

    /**
     * 将形如LIYC_TEST转为liycTest
     * @param string
     * @return
     */
    private static String doParseCamelCase(String string) {
        StringBuilder stringBuilder = new StringBuilder();
        if (string.contains("_")) {
            String[] split = string.split("_");
            stringBuilder.append(split[0].trim().toLowerCase());
            for(int i=1;i<split.length;i++) {
                String origin = split[i].trim();
                if (StringUtils.isBlank(origin))
                    continue;
                String upperChar = String.valueOf(origin.charAt(0)).toUpperCase();
                String after = upperChar + origin.substring(1).toLowerCase();
                stringBuilder.append(after);
            }
        }else {
            stringBuilder.append(string.toLowerCase().trim());
        }
        return stringBuilder.toString();
    }


    private static boolean isString(Object underLineObject) {
        return underLineObject instanceof String;
    }

    public static void main(String[] args) {
        String s = "LIYC_TEST";
        String s1 = (String) underLineToCamelCase(s);
        System.out.println(s1);

        JSONObject arrMap = JSONObject.parseObject("{\n" +
                "    \"APPLE_CASE\":[\n" +
                "        {\n" +
                "            \"APPLE_ONE\":\"AAA\",\n" +
                "            \"APPLIE_two\":\"vvv\"\n" +
                "        }\n" +
                "    ]\n" +
                "}");
        Object o = underLineToCamelCase(arrMap);
        System.out.println(o);

    }

    /**
     * 判断对象是否数组
     * 1. 可能是普通的对象，直接用{@link Class#isArray()} 判断即可
     * 2. 可能是Type对象，通过 {@link Method#getGenericReturnType()}或{@link Method#getGenericParameterTypes()} 而获取的泛型数组，需要用{@link GenericArrayType} 判断
     * @param o
     * @return
     */
    public static boolean isArray(Object o) {
        if (o instanceof Type)
            return o instanceof GenericArrayType;
        return o.getClass().isArray();
    }

    /**
     * 判断对象是否列表
     */
    public static boolean isList(Object o) {
        return o instanceof List;
    }

    /**
     * 判断对象是否map
     */
    public static boolean isMap(Object o) {
        return o instanceof Map;
    }

    /**
     * 判断对象是int,float,double,boolean,char,short,long,void 或 其包装类
     */
    public static boolean isBasicType(Object o) {
        return o.getClass().isPrimitive();
    }

    /**
     * 有的时候订单喜欢把map转为字符串传过来
     * @param str
     * @return
     */
    public static Map canParseMap(String str) {
        Map map = null;
        try {
            map = JSONObject.parseObject(str);
        }catch (Exception e) {
            // doNothing
        }
        return map;
    }
}