将集合转换成具有层级结构的map、写了一天了没想出怎么实现、有没有大lao9⃣️9⃣️我！！

将集合转换成具有层级结构的map、写了一天了没想出怎么实现、有没有大lao9⃣️9⃣️我！！（正文非得30个字么，我上哪儿编30个字去）

public static void main(String[] args) {
        List<String> pathList = Arrays.asList("/etc/hosts", "/etc/kubernetes/ssl/certs", "/root");
        Map<String, Object> resultMap = pathListToMap(pathList);
        System.out.println(resultMap);
    }

    public static Map<String, Object> pathListToMap(List<String> pathList) {
        Map<String, Object> resultMap = new HashMap<>();
        pathList.forEach(path -> {
            String[] pathSplitArray = path.split("/");
            // 每个目录循环时需要记录上层目录的对象
            Map<String, Object> parentObj = null;
            for (int i = 0; i < pathSplitArray.length; i++) {
                if (StringUtils.isEmpty(pathSplitArray[i])) {
                    continue;
                }
                parentObj = parentObj == null ? resultMap : parentObj;
                Object currentObj = parentObj.get(pathSplitArray[i]);
                if (currentObj == null) {
                    currentObj = new HashMap<>();
                    parentObj.put(pathSplitArray[i], currentObj);
                }
                parentObj = (Map) currentObj;
            }
        });
        return resultMap;
    }

    public static void main(String[] args) {
        ArrayList<String> paths = new ArrayList<>();
        paths.add("root/a/b");
        paths.add("w/a/b");
        paths.add("root/1/b");
        HashMap<String, Map> map=new HashMap();
        for (String path : paths) {
            putmap(Arrays.asList(path.split("/")).iterator(),map);
        }
       //用你自己的方法打印
    }
    public static void putmap(Iterator<String> iterator, HashMap<String, Map> map){
        String next = iterator.next();
        if (!map.containsKey(next)) {
            map.put(next,new HashMap<>());
        }
        if (iterator.hasNext()) {
            putmap(iterator,(HashMap)map.get(next));
        }
    }

这样就行了

使用递归

可以参考下面的文章
https://blog.csdn.net/qq_42402854/article/details/104299948

什么层级结构

每一个按 / 拆开 ，遍历

 public static Map<String, Map> pathListToMap(List<String> list) {
        Map<String, Map> map = new TreeMap<>();
        for (String path : list) {
            String[] splitPaths = path.split("/");
            String lastKey = null;
            Map<String, Map> tempMap = new HashMap<>(8);
            for (String curKey : splitPaths) {
                if (curKey == null || curKey.trim().length() == 0) {
                    continue;
                }
                if (lastKey == null) {
                    if (map.containsKey(curKey)) {
                        tempMap = map.get(curKey);
                    } else {
                        map.put(curKey, tempMap);
                    }
                } else {
                    Map<String, Map> value = new HashMap<>(8);
                    tempMap.put(curKey, value);
                    tempMap = value;
                }

                lastKey = curKey;
            }
        }

        return map;
    }

 public static void main(String[] args) {

        List<String> list = Arrays.asList("/etc/hosts", "/etc/kubernetes/ssl/certs", "/root");
        Map<String, Map> pathListToMap = pathListToMap(list);

        System.out.println(JSON.toJSONString(pathListToMap, SerializerFeature.PrettyFormat));

    }

这很简单呀，把集合遍历，将每个元素用/分割开，然后递归往map中放就行了，递归中的逻辑就是，先检查层级是否存在，不存在就创建，存在就往下延申

import com.google.gson.Gson;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test {

    static Map<String, Map<?, ?>> pathListToMap(List<String> list) {
        Map<String, Map<?, ?>> map = new HashMap<>();
        for (String item : list) {
            List<String> parts = Arrays.stream(item.split("/"))
                    .filter(p -> !p.isEmpty())
                    .collect(Collectors.toList());
            insertListToMap(map, parts, 0);
        }
        return map;
    }

    static void insertListToMap(Map<String, Map<?, ?>> map, List<String> list, int ind) {
        if (ind >= list.size()) {
            return;
        }
        String item = list.get(ind);
        Map<?, ?> next = map.get(item);
        if (next == null) {
            next = new HashMap<String, Object>();
            map.put(item, next);
        }
        insertListToMap((Map<String, Map<?, ?>>) next, list, ind + 1);
    }

    public static void main(String[] args) {
        Map<String, ?> map = pathListToMap(Arrays.asList(
                "/etc/hosts",
                "/etc/hosts/file",
                "/root/lib/java",
                "/etc/hosts/trash",
                "/main"
        ));
        System.out.println(new Gson().toJson(map));
    }
}

 public static void main(String[] args) {
        List<String> pathList= Arrays.asList(
                "/etc/hots",
                "/etc/kubernetes/ssl/certs",
                "/root");
        HashMap<String, HashMap> stringHashMap = new HashMap<>();
        for (String path : pathList) {
            String[] stringArray = path.substring(1,path.length()).split("/");
            int i=0;
            buildHashMap(stringArray,stringHashMap,i);
        }

        // 打印组装参数
        for (String key : stringHashMap.keySet()) {
            System.out.println(key+"="+stringHashMap.get(key));
        }
    }


    public static void buildHashMap(String[] split,HashMap<String, HashMap> stringHashMap,int i){


        HashMap<String, HashMap> subStringHashMap = new HashMap<>();
        if(stringHashMap.get(split[i]) == null ){
            stringHashMap.put(split[i],subStringHashMap);
        }else {
            subStringHashMap=stringHashMap.get(split[i]);
        }
        if(i < split.length-1){
            ++i;
            buildHashMap(split,subStringHashMap,i);
        }
    }