Convertir la estructura de directorios de rutas de cadena en un objeto JSON con Java.

Estoy intentando crear una vista de árbol anidada con Custom Pojo Node en Spring MVC, la entrada que tengo de la biblioteca JSch después de ejecutar command1="find $(pwd) -maxdepth 1 -type f -not -path '*/\\.*' | sort" será una lista de Strings que contiene rutas absolutas de archivos bajo el directorio de trabajo actual, como se muestra en el ejemplo a continuación.

 `List<String> paths = [
"/Sample Dir/sample.cpp",
"/Sample Dir/New Folder",
"/Sample Dir/New Folder/Sample.txt"];`

Necesito crear un objeto JSON jerárquico con el siguiente modelo:

public class Node {
    private String name;
    private String location;
    private List<Node> children;
}

Estoy tratando de averiguar el algoritmo, cómo representar las rutas de archivo como una clase Node que proporciona el siguiente JSON. A continuación se muestra el código que intenté, que tiene algunos problemas que no puedo solucionar.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

import org.apache.commons.lang3.StringUtils;
import org.codehaus.jackson.map.ObjectMapper;

public class DemoMainClass {

    public static void main(String[] args) throws Exception{
        Node root = new Node("/");
        AddNode("/Sample Dir/sample.cpp", root);
        AddNode("/Sample Dir/New Folder", root);
        AddNode("/Sample Dir/New Folder/Sample.txt", root);
        AddNode("/Sample Dir/New Folder/demo.txt", root);
        ObjectMapper Obj = new ObjectMapper(); 
        String jsonStr = Obj.writeValueAsString(root);
        System.out.println(jsonStr);
    }

    public static Node AddNode(String filePath, Node rootNode) {
        // Método de conveniencia. Esto crea la cola que necesitamos para la recursión a partir del archivo de ruta para usted
        if(filePath.startsWith("/")) {
            filePath = filePath.split("/",2)[1];
        }
        List<String> tokenList = Arrays.asList(filePath.split("/"));
        tokenList.remove(" ");
        // si divide una carpeta que termina con / deja una cadena vacía al final y queremos eliminar eso
        if (StringUtils.isBlank(tokenList.get(tokenList.size() - 1))) {
            tokenList.remove(tokenList.size() - 1);
        }

        PriorityQueue<String> queue = new PriorityQueue<String>();
        queue.addAll(tokenList);
        return AddNode(queue, rootNode);
    }

    private static Node AddNode(Queue<String> tokens, Node rootNode) {
        // caso base -> el nodo no se encontró y se han ido los tokens :(
        if (tokens == null || tokens.isEmpty()) {
            return null;
        }

        // Obtener el token actual, dejando solo los que no se han buscado en el objeto tokens
        String current = tokens.remove();

        // crear el nodo si aún no existe
        Node foundNode = rootNode.FindNode(current);
        if (foundNode != null) {
            // el nodo existe! recursión
            return AddNode(tokens, foundNode);
        } else {
            // el nodo no existe! agréguelo manualmente y recurse
            Node newNode = new Node(current);
            rootNode.getChildren().add(newNode);
            return AddNode(tokens, newNode);
        }
    }
}

class Node {
    public String name;
    public List<Node> children;
    public String location;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Node> getChildren() {
        return children;
    }

    public void setChildren(List<Node> children) {
        this.children = children;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

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

    public Node(String fileName) {
        this.children = new ArrayList<Node>();
        this.name = fileName;
    }
    public Node FindNode(String data) {
        if (this.children == null || this.children.isEmpty()) {
            return null;
        }
        // compruebe la lista de nodos para ver si ya existen
        return this.children.stream().filter(node -> node.getName().equalsIgnoreCase(data)).findFirst().orElse(null);
    }
}

A continuación se muestra la salida que estoy obteniendo:

{"name":"/","children":[{"name":"Sample Dir","children":[{"name":"sample.cpp","children":[],"location":null}],"location":null},{"name":"New Folder","children":[{"name":"Sample Dir","children":[{"name":"Sample.txt","children":[],"location":null},{"name":"demo.txt","children":[],"location":null}],"location":null}],"location":null}],"location":null}

El resultado deseado es el siguiente:

[
  {
    "name": "Sample Dir",
    "location": "Sample Dir",
    "children": [
      {
        "name": "New Folder",
        "location": "Sample Dir/New Folder",
        "children": [
          {
            "name": "Sample.txt",
            "location": "Sample Dir/New Folder/Sample.txt",
            "children": "null"
          }
        ]
      },
      {
        "name": "sample.cpp",
        "location": "Sample Dir/sample.cpp",
        "children": "null"
      }
    ]
  }
]

¿Podría ayudarme a ver dónde estoy equivocado? Se agradece cualquier ayuda, gracias de antemano.