Map list深层嵌套访问增强工具，可以像js 对象一样访问

import java.util.*;

import static com.alibaba.druid.sql.ast.SQLPartitionValue.Operator.List;

public class Mapt {
    /*
     * Map与list相互深层嵌套处理工具。在投放与获取数据时非常快捷方便。
     * 获取或投放数据，必须有k。k 是一个字符串，由小数点分隔成多部份，
     * 每部份对应着一个嵌套层。任意部份如果首尾由中括号括着，对应着List,
     * 否则非最底层部份对应着Map.访问形式类似Js中的对象访问，但是也仅类似，
     * 对于数组（即list)的访问，必须有小数点，比如js中aa[0]是可以的，但
     * 这个工具必须是 aa.[0]的形式访问。
     * Mapt.put(map,"aa.[3].x",2);
     * Object obj = Mapt.get(map,"aa.[3].x");
     * 这是obj是2.
     * Object obj1 = Mapt.get(map,"aa.[3]");
     * 这是obj1是个Map,他只有一个元素。key为x，value为2
     * =============================
     * 注意，put时，如果不存在则创建，如果存在则覆盖。父路径与子路径的数据格式不一致，
     * 且最近操作的key又对应的是父路径时，会以当前操作为准，子路径将被删除。
     * 如： put(aa.bb.[0].dd ,34), 当前执行put("aa.bb",55),那么前一个put会被覆盖即被删除
     *
     */

    /**
     * 注意，在并发环境中，只能在配置阶段进行全局设置，在并发工作状态 禁止设置
     */
    private static String separator = "\\.";

    /**
     * 注意，在并发环境中，只能在配置阶段进行全局设置，在并发工作状态 禁止设置
     */
    private static boolean friendsKeyBL = false;


    public static boolean isExist(Object target, String k){
        return isExist(target,k,separator);
    }
    public static boolean isExist(Object target, String k, String separator){
        if (k == null || target == null) return false;
        if (friendsKeyBL) {
            k = k.replaceAll("(?<=[A-Z|a-z|0-9|\\]])(\\[)", ".[");
        }
        String[] strs = k.split(separator);
        Object rst = target;
        for (int i = 0; i < strs.length; i++) {
            String nextKey = null;
            if (i < strs.length - 1) {
                nextKey = strs[i + 1];
            }
            rst = doingGet(rst, strs[i]);
            if(rst==null) return false;

        }
        return rst==null?false:true;
    }

    public static boolean isChildType(Object target, String k,Class typeClass) {
        return isChildType(target, k, typeClass,separator);
    }

    public static boolean isChildType(Object target, String k,Class typeClass, String separator) {
        if (k == null || target == null) return false;
        if (friendsKeyBL) {
            k = k.replaceAll("(?<=[A-Z|a-z|0-9|\\]])(\\[)", ".[");
        }
        String[] strs = k.split(separator);
        Object rst = target;
        for (int i = 0; i < strs.length; i++) {
            String nextKey = null;
            if (i < strs.length - 1) {
                nextKey = strs[i + 1];
            }
            rst = doingGet(rst, strs[i]);
            if (rst==null) return false;
        }

        if (rst==null) return false;

        return typeClass.isAssignableFrom(rst.getClass());
    }

    public static Object get(Object target, String k) {

        return get(target, k, separator);
    }

    public static Object get(Object target, String k, String separator) {
        if (k == null || target == null) return null;
        if (friendsKeyBL) {
            k = k.replaceAll("(?<=[A-Z|a-z|0-9|\\]])(\\[)", ".[");
        }
        String[] strs = k.split(separator);
        Object rst = target;
        for (int i = 0; i < strs.length; i++) {
            String nextKey = null;
            if (i < strs.length - 1) {
                nextKey = strs[i + 1];
            }
            rst = doingGet(rst, strs[i]);
            if (rst ==null) return null;
        }

        return rst;
    }

    private static Object doingGet(Object target, String key) {
        if (key == null || target == null) return target;
        key = key.trim();
        if (List.class.isAssignableFrom(target.getClass())) {
            key = key.substring(1, key.length() - 1);
            int pos = Integer.parseInt(key);
            List list = (List) target;

            return list.get(pos);
        } else if (Map.class.isAssignableFrom(target.getClass())) {
            if (key.substring(0, 1).equals("[")) return null;
            Map map = (Map) target;

            Object son = map.get(key);
            return son;
        }
        return null;
    }

    public static Object put(Object target, String k, Object v) {
        return put(target, k, v, separator);
    }

    public static Object put(Object target, String k, Object v, String separator) {
        if (k == null) return target;
        if (friendsKeyBL) {
            k = k.replaceAll("(?<=[A-Z|a-z|0-9|\\]])(\\[)", ".[");
        }
        String[] strs = k.split(separator);
        if (target == null) target = createObj(k);
        Object rst = target;
        for (int i = 0; i < strs.length; i++) {
            String nextKey = null;
            if (i < strs.length - 1) {
                nextKey = strs[i + 1];
            }
            rst = doingPut(rst, strs[i], nextKey, v);
        }


        return target;
    }

    private static Object doingPut(Object target, String key, String nextKey, Object v) {
        if (key == null || target == null) return target;
        key = key.trim();
        nextKey = nextKey == null ? null : nextKey.trim();
        if (target == null) target = createObj(key);
        if (nextKey == null) {
            return setVal(target, key, v);
        } else {
            return getNext(target, key, nextKey);
        }

    }

    private static Object getNext(Object target, String key, String nextKey) {
        if (List.class.isAssignableFrom(target.getClass())) {
            key = key.substring(1, key.length() - 1);
            int pos = Integer.parseInt(key);
            List list = (List) target;
            int count = list.size();
            for (int i = 0; count + i <= pos; i++) {
                list.add(null);
            }
            Object obj = list.get(pos);
            if (obj == null) {
                obj = createObj(nextKey);
                list.set(pos, obj);
            } else if (nextKey != null &&  !isSameType(obj,nextKey)) {
                obj = createObj(nextKey);
                list.set(pos, obj);
            }
            return obj;
        } else if (Map.class.isAssignableFrom(target.getClass())) {
            if (key.substring(0, 1).equals("[")) return null;
            Map map = (Map) target;
            Object son = map.get(key);
            if (son == null) {
                son = createObj(nextKey);
                map.put(key, son);
            } if (nextKey != null &&  !isSameType(son,nextKey)) {
                son = createObj(nextKey);
                map.put(key,son);
            }
            return son;
        }
        return null;
    }

    private static boolean isSameType(Object obj,String key){
        String tmp="o";
        if (List.class.isAssignableFrom(obj.getClass())){
            tmp="l";
        } else if (Map.class.isAssignableFrom(obj.getClass())){
            tmp="m";
        }

        String r="";
        if(key.substring(0,1).equals("[")){
            r="l";
        } else {
            r="m";
        }

        return tmp.equals(r);
    }
    private static Object createObj(String key) {
        if (key != null && key.indexOf("[") == 0) {
            return new ArrayList<>();
        } else if (key != null && key.indexOf("[") != 0) {
            return new LinkedHashMap<>();
        }
        return null;
    }

    private static Object setVal(Object target, String key, Object v) {
        if (target == null || key == null) return null;
        if (List.class.isAssignableFrom(target.getClass())) {
            key = key.substring(1, key.length() - 1);
            int pos = Integer.parseInt(key);
            List list = (List) target;
            int count = list.size();
            for (int i = 0; count + i <= pos; i++) {
                list.add(null);
            }
            list.set(pos, v);
            return target;
        } else if (Map.class.isAssignableFrom(target.getClass())) {
            if (key.substring(0, 1).equals("[")) return null;

            Map map = (Map) target;
            map.put(key, v);
            return target;
        }
        return null;
    }


    public static String getString(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return obj.toString();
    }

    public static Integer getInteger(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (Integer) obj;
    }

    public static Long getLong(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (Long) obj;
    }

    public static Boolean getBoolean(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (Boolean) obj;
    }

    public static Date getDate(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (Date) obj;
    }

    public static Double getDouble(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (Double) obj;
    }

    public static Float getFloat(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (Float) obj;
    }

    public static <T> Map<String, T> getMap(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (Map<String, T>) obj;
    }

    public static <T> List<T> getList(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (List<T>) obj;
    }

    public static <T> T getBean(Object target, String k) {
        Object obj = get(target, k);
        if (obj == null) return null;
        return (T) obj;
    }

    public static String getSeparator() {
        return separator;
    }

    public static void setSeparator(String separator) {
        Mapt.separator = separator;
    }

    public static boolean isFriendsKeyBL() {
        return friendsKeyBL;
    }

    public static void setFriendsKeyBL(boolean friendsKeyBL) {
        Mapt.friendsKeyBL = friendsKeyBL;
    }
}