Группировка списка строк, разделенных точками

В приведенном ниже коде класс Node представляет каждый node в дереве. buildTree() метод создает дерево из входных данных, разделяя каждую строку точками для получения частей. А HashMap предназначен для отслеживания nodes по их полному пути. Для каждой части мы проверяем, существует ли node на карте, если нет, создаем новую. Внутри метода generatePaths() мы рекурсивно обходим дерево, чтобы создать ожидаемый результат.

package org.example;

import java.util.*;

public class GroupString {
    static class Node {
        String value;
        List<Node> children;

        Node(String value) {
            this.value = value;
            this.children = new ArrayList<>();
        }
    }

    public static void main(String[] args) {
        String[] input = {
                "323-060",
                "323-060.040",
                "323-060.040.030",
                "323-060.088",
                "323-060.088.020",
                "323-060.010",
                "323-060.010.080",
                "323-060.010.080.020",
                "323-060.010.080.060"
        };

        Node root = buildTree(input);
        List<String> result = new ArrayList<>();
        generatePaths(root, new ArrayList<>(), result);

        for (String path : result) {
            System.out.println(path);
        }
    }

    private static Node buildTree(String[] input) {
        Map<String, Node> nodeMap = new HashMap<>();
        Node root = null;

        for (String path : input) {
            String[] parts = path.split("\\.");
            StringBuilder currentPath = new StringBuilder();
            Node parent = null;

            for (String part : parts) {
                if (currentPath.length() > 0) {
                    currentPath.append(".");
                }
                currentPath.append(part);
                String key = currentPath.toString();

                Node currentNode = nodeMap.getOrDefault(key, new Node(key));
                nodeMap.putIfAbsent(key, currentNode);

                if (parent != null) {
                    if (!parent.children.contains(currentNode)) {
                        parent.children.add(currentNode);
                    }
                } else {
                    root = currentNode;
                }

                parent = currentNode;
            }
        }

        return root;
    }

    private static void generatePaths(Node node, List<String> path, List<String> result) {
        if (node == null) return;

        path.add(node.value);

        if (node.children.isEmpty()) {
            result.add(String.join("\\", path));
        } else {
            for (Node child : node.children) {
                generatePaths(child, new ArrayList<>(path), result);
            }
        }
    }
}

Сначала я сгруппировал пути по их общему корню и сделал это с помощью Map<String, List<>, где ключом является корень, а значением — список путей, начинающийся с этого корня.

Для генерации и печати этих путей я создал еще одну функцию с именемgeneratePaths:

Метод GeneratePaths вызывается для каждого корня, и этот метод создает древовидную структуру. Он разбивает каждый путь по точкам и строит иерархию, создавая вложенную структуру.

import java.util.*;

public class TreeStructure {
    public static void main(String[] args) {
        List<String> input = Arrays.asList(
            "323-060",
            "323-060.040",
            "323-060.040.030",    
            "323-060.088",
            "323-060.088.020",    
            "323-060.010",
            "323-060.010.080",
            "323-060.010.080.020",
            "323-060.010.080.060"
        );

        // Group paths by their common roots
        Map<String, List<String>> groupedPaths = new TreeMap<>();
        for (String path : input) {
            String[] parts = path.split("\\.");
            String root = parts[0];
            groupedPaths.putIfAbsent(root, new ArrayList<>());
            groupedPaths.get(root).add(path);
        }

        // Generate and print the formatted output
        for (String root : groupedPaths.keySet()) {
            generatePaths(groupedPaths.get(root), root);
        }
    }

    private static void generatePaths(List<String> paths, String root) {
        Map<String, List<String>> tree = new TreeMap<>();
        for (String path : paths) {
            String[] parts = path.split("\\.");
            String currentPath = parts[0];
            for (int i = 1; i < parts.length; i++) {
                currentPath += "\\" + parts[i];
                tree.putIfAbsent(currentPath, new ArrayList<>());
                if (i + 1 < parts.length) {
                    tree.get(currentPath).add(currentPath + "\\" + parts[i + 1]);
                }
            }
        }

        for (String key : tree.keySet()) {
            System.out.println(root + "\\" + key);
        }
    }
}

Я надеюсь, что этот код разрешит ваши вопросы.