Java: Turning Strings into a tree

Hope that helps. Builds entire structure of catalogs. Sry for short names and lack of generics. Hope it would be more readable.

public static void main(String[] args) {
    ArrayList<String> listOfPaths = new ArrayList<String>();
    listOfPaths.add("folder a/folder b/file 1");
    listOfPaths.add("folder a/folder b/file 2");
    listOfPaths.add("folder a/folder c");

    TreeMap structure = new TreeMap();
    for (String path : listOfPaths) {
        String[] tmp = path.split("/", 2); // [ "folder a/", "folder b/file 1"]  for first loops step
        put(structure, tmp[0], tmp[1]);
    }

    print(structure, "");
}
private static void put(TreeMap structure, String root, String rest) {
    String[] tmp = rest.split("/", 2);

    TreeMap rootDir = (TreeMap) structure.get(root);

    if (rootDir == null) {
        rootDir = new TreeMap();
        structure.put(root, rootDir);
    }
    if (tmp.length == 1) { // path end
        rootDir.put(tmp[0], null);
    } else {
        put(rootDir, tmp[0], tmp[1]);
    }
}
private static void print(TreeMap map, String delimeter) {
    if (map == null || map.isEmpty())
        return;
    for (Object m : map.entrySet()) {
        System.out.println(delimeter + "-" + ((Map.Entry)m).getKey());
        print((TreeMap)((Map.Entry)m).getValue(), " |" + delimeter);
    }
}

I think a lot depends on what your final goal is. If it is just to print out the data, or if you need to process the data, or if you need to manipulate it algorithmically.

My gut instinct would be to do it all using LinkedHashMap and basically make it a map of a map of a map, etc... It can get a little tricky though to do this cleanly since you have two different possible values for your map - folder and file. Note that the use of the LinkedHashMap is to maintain the order of the data as you insert it. If you want it sorted, or random order, then you can choose other implementations.

Essentially, I would see it as something like the following (pseudo-code)

public interface DirectoryEntry{
  boolean isFile;
  boolean isFolder;
}

public class Folder implements DirectoryEntry{
    public boolean isFile(){ return false;}
    public boolean isFolder(){ return true;}

    private Map<String, DirectoryEntry> entries = new LinkedHashMap<String, DriectoyrEntry>();

    public Map<String, DirectoryEntry>getEntries(){ return entries;}
    public void addFile( String filename ){ entries.put( filename, new File();}
    public void addFolder( String foldername){entries.put(foldername, new Folder();}
}

public class File implements DirectoryEntry{
    public boolean isFile(){ return true;}
    public boolean isFolder(){ return false;}
 }

Then build the tree (you can do this recursively as well):

Map<String, DirectoryEntry> entries = new LinkedHashMap<String, DirectoryEntry>()

while( !end of list){
  Map entry = entries;

  1. Split string on '/'
  2. foreach( token ){
         if file
        entries.put( token, new File() );
         else{
        if( !entry.containsKey( token ) )
           entry.put(token, new Folder );

        // use the folder map for any sub-folders/files
        entry = ((Folder)entry.get( token )).getEntries();
         }
  }
}

Then you can scan through your final list and play with it as you like. I've created File and Folder intentionally basic, but you can add additional metadata/info there if you have/need.

Keep in mind that this is just an option to give you an idea as to how to parse/map the files/folders, but not meant as a functional solution as is.

As for if it is easier to parse first and print, like I said, it all depends what you hope to achieve with a final data set. But my gut instinct would be to parse it all and then display what you have parsed to ensure that what you are showing is what you have "understood" and will be manipulating.

Basically, it all starts from a 'Root'. What you could do is:

while(!End of List)
{
    tempNode = Root;
    1. Resolve each line into tokens (with '/' as delimiter)
    2. while(hasMoreTokens())
       {
           3. Check if nextToken() is the child of tempNode
           4. If not, create node with nextToken(), continue till all tokens of line are exhausted.
           5. If yes, go to tempNode.nextToken(). Go to step 3.
       }
}

This way you create the tree every time you go through each line of the list.

Its better to build the tree first and then display since this can accomodate any changes later. You can create a Node object like

class Node{
  // level deep of this node, can use to format the display like
  // 4 level deep will have four leading spaces
  private int level;
  // the actual text
  private String text;
  // Parent Node for this, can be null if this is the root node, set this when creating
  private Node parent;
  // children of this Node
  private List<Node> children; 
  // Getters and setters for the above properties....
}

I have a tree implementation which can do it with a code as simple as this:

PathTreeBuilder.Funnel<String, String> urlFunnel = new PathTreeBuilder.Funnel<String, String>() {
    @Override
    public List<String> getPath(String value) {
        return Lists.newArrayList(value.split("/"));
    }
};
PathTreeBuilder<String, String> builder = new PathTreeBuilder<String, String>(urlFunnel);
List<Tree<String>> build = builder.build(urls);
build.toStringTree();

Hope it will be helpful to somebody.