package tree;

import java.util.List;

import tree.Tree.Node;

public class TreePrint {

    public static void main(String[] args) {

        Tree<String> rootFolder = new Tree<>("RootFolder");

        Node<String> video = new Node<>("Video", null);
        Node<String> music = new Node<>("Music", null);
        Node<String> picture = new Node<>("Picture", null);
        rootFolder.add(video);
        rootFolder.add(music);
        rootFolder.add(picture);

        video.add(new Node<>("Terminator", video));
        video.add(new Node<>("Die Hard", video));
        video.add(new Node<>("Rocky", video));
        music.add(new Node<>("Eminem", music));
        picture.add(new Node<>("Picasso", picture));

        printCatalog(rootFolder);
    }

    private static <T> void printCatalog(Tree<T> tree) {
        printNode(tree.getNode());
        List<Node<T>> kids = tree.iterate();
        printTree(kids);

    }

    private static <T> void printTree(List<Node<T>> kids) {
        if (kids.isEmpty()) {
            return;
        }
        for (Node<T> kid : kids) {
            printNode(kid);
            printTree(kid.iterate());
        }
    }

    private static <T> void printNode(Node<T> kid) {
        System.out.println(kid.getData());

    }
}

package tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Tree<T> {
    private Node<T> root;

    public Tree(T rootData) {
        root = new Node<T>(rootData, null);
        root.data = rootData;
        root.children = new ArrayList<Node<T>>();
    }

    public static class Node<T> {
        private T data;
        private Node<T> parent;
        private List<Node<T>> children;

        public Node(T data, Node<T> parent) {
            this.data = data;
            this.parent = parent;
            this.children = new ArrayList<Node<T>>();
        }

        public void add(Node<T> node) {
            children.add(node);
        }

        public T getData() {
            return data;
        }

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

        public Node<T> getRoot() {
            if (parent == null) {
                return null;
            }
            Node<T> localParent = parent;
            while (localParent.parent != null) {
                localParent = parent.parent;
            }
            return localParent;
        }

    }

    public Node<T> getNode() {
        return root;
    }

    public List<Node<T>> iterate() {
        return root.children;
    }

    public boolean remove(Node<T> node) {
        return root.children.remove(node);
    }

    public void add(Node<T> node) {
        root.children.add(node);
    }

    public List<Node<T>> findByName(final String name) {
        final List<Node<T>> result = new ArrayList<>();
        final Queue<Node<T>> allFiles = new LinkedList<>();
        allFiles.add(getNode());
        while (!allFiles.isEmpty()) {
            final Node<T> localEntry = allFiles.poll();
            final List<Node<T>> files = localEntry.iterate();
            for (final Node<T> innerFile : files) {
                if (innerFile.getData().equals(name)) {
                    result.add(innerFile);
                }
                allFiles.add(innerFile);
            }
        }
        return result;
    }
}