package tree;



public class Main {

    public static void main(String[] args) {
        Tree rootFolder = new Tree("RootFolder", null);----------- только она может быть Tree
        Node video = new Node("Video", rootFolder);------------- В вашем коде оно Tree, нужно чтобы было Node, чтобы одно дерево было и от него должны идти ноды
         Node music = new Node("Music", rootFolder);---------- В вашем коде оно Tree, нужно чтобы было Node, чтобы одно дерево было
        Node picture = new Node("Picture", rootFolder);---------- В вашем коде оно Tree, нужно чтобы было Node, чтобы одно дерево было
        rootFolder.add(video);
        rootFolder.add(music);
        rootFolder.add(picture);
        Node terminator = new Node("Terminator", video);
        Node dieHard = new Node("Die Hard", video);
        Node rocky = new Node("Rocky", video);
        Node abby = new Node("Abby", music);
        video.add(terminator);
        video.add(dieHard);
        video.add(rocky);
        music.add(abby);
        Tree homePicture = new Tree("Home picture", picture);
        Tree workPicture = new Tree("Work picture", picture);
        picture.add(homePicture);
        picture.add(workPicture);

        int foundForNameInDirectory = rootFolder.findByName("Terminator").size();
        System.out.println("found for name in directory - " + foundForNameInDirectory);
    }
}

package tree;


public class Tree extends Node { -------------------------------Tree не должно наследоватся от Node, типа основное дерево ни от кого не должно наследоваться только все ноды должны идти от него. Плюс нужно Get написать

    public Tree(String name, Node node) {
        super(name, node);
    }

    public Node getRoot() {

        if (getParent() == null) {
            return null;
        }
        Node parent = getParent();
        while (parent.getParent() != null) {
            parent = parent.getParent();
        }
        return parent;
    }
}

   

    

package tree;


import java.util.*;

public class Node {
    private final Node parent;
    private String name;
    private final List<Node> contents;
    protected Node getParent() {
        return parent;
     
    
    public Node(String name, Node parent) {
        this.name = name;
        this.parent = parent;
        contents = new ArrayList<>();
    }
        
    
    
    public void add(Node node) {
        contents.add(node);
    }
    public boolean remove(Node node) {
        return contents.remove(node);
    }
    
    protected List<Node> iterate() {
        return contents;
    }

    public boolean delete() {
        if (parent == null) {
            return false;
        }
        return parent.remove(this);
    }

   
    
    
    public String getFullPath() {
        if (parent == null) { 
            return name;
        } else {
            return parent.getFullPath() + "/" + name;
        }
    }

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

    public String getName() {
        return name;
    }

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

package tree;



class Main {

	public static TreeNode<String> getSet1() {
		TreeNode<String> root = new TreeNode<String>("root");
		{
			TreeNode<String> node0 = root.addChild("Video");
                        TreeNode<String> node1 = root.addChild("Music");
                        TreeNode<String> node2 = root.addChild("Pictures");
			{
				
                                
				{
					TreeNode<String> node00 = node0.addChild("Terminator");
                                        TreeNode<String> node01 = node0.addChild("Batman");
                                        TreeNode<String> node02 = node0.addChild("Harry Potter");
                                        TreeNode<String> node03 = node1.addChild("Kendrick Lamar");
                                        TreeNode<String> node04 = node1.addChild("Oxxxymiron");
                                        TreeNode<String> node05 = node1.addChild("Lana Del Rey");
                                        TreeNode<String> node06 = node2.addChild("Comics");
                                        TreeNode<String> node07 = node2.addChild("Mona Lisa");
                                        TreeNode<String> node08 = node2.addChild("Picasso");
                                        
                                        
                                        
                                        
					
				} 
		return root;
	}
                }
        }
}
        

package tree;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class TreeNode<T> implements Iterable<TreeNode<T>> {

	public T data;
	public TreeNode<T> parent;
	public List<TreeNode<T>> children;

	public boolean isRoot() {
		return parent == null;
	}

	public boolean isLeaf() {
		return children.size() == 0;
	}

	private List<TreeNode<T>> elementsIndex;

	public TreeNode(T data) {
		this.data = data;
		this.children = new LinkedList<TreeNode<T>>();
		this.elementsIndex = new LinkedList<TreeNode<T>>();
		this.elementsIndex.add(this);
	}

	public TreeNode<T> addChild(T child) {
		TreeNode<T> childNode = new TreeNode<T>(child);		
		this.children.add(childNode);
                
                childNode.parent = this;
                
		//this.registerChildForSearch(childNode);
		return childNode;
	}

	public int getLevel() {
		if (this.isRoot())
			return 0;
		else
			return parent.getLevel() + 1;
	}

	private void registerChildForSearch(TreeNode<T> node) {
		elementsIndex.add(node);
		if (parent != null)
			parent.registerChildForSearch(node);
	}

	public TreeNode<T> findTreeNode(Comparable<T> cmp) {
		for (TreeNode<T> element : this.elementsIndex) {
			T elData = element.data;
			if (cmp.compareTo(elData) == 0)
				return element;
		}

		return null;
	}

	@Override
	public String toString() {
		return data != null ? data.toString() : "[data null]";
	}

	@Override
	public Iterator<TreeNode<T>> iterator() {
		TreeNodeIter<T> iter = new TreeNodeIter<T>(this);
		return iter;
	}

}

package tree;


import java.util.Iterator;

public class TreeNodeIter<T> implements Iterator<TreeNode<T>> {

	enum ProcessStages {
		ProcessParent, ProcessChildCurNode, ProcessChildSubNode
	}

	private TreeNode<T> treeNode;

	public TreeNodeIter(TreeNode<T> treeNode) {
		this.treeNode = treeNode;
		this.doNext = ProcessStages.ProcessParent;
		this.childrenCurNodeIter = treeNode.children.iterator();
	}

	private ProcessStages doNext;
	private TreeNode<T> next;
	private Iterator<TreeNode<T>> childrenCurNodeIter;
	private Iterator<TreeNode<T>> childrenSubNodeIter;

	@Override
	public boolean hasNext() {

		if (this.doNext == ProcessStages.ProcessParent) {
			this.next = this.treeNode;
			this.doNext = ProcessStages.ProcessChildCurNode;
			return true;
		}

		if (this.doNext == ProcessStages.ProcessChildCurNode) {
			if (childrenCurNodeIter.hasNext()) {
				TreeNode<T> childDirect = childrenCurNodeIter.next();
				childrenSubNodeIter = childDirect.iterator();
				this.doNext = ProcessStages.ProcessChildSubNode;
				return hasNext();
			}

			else {
				this.doNext = null;
				return false;
			}
		}
		
		if (this.doNext == ProcessStages.ProcessChildSubNode) {
			if (childrenSubNodeIter.hasNext()) {
				this.next = childrenSubNodeIter.next();
				return true;
			}
			else {
				this.next = null;
				this.doNext = ProcessStages.ProcessChildCurNode;
				return hasNext();
			}
		}

		return false;
	}

	@Override
	public TreeNode<T> next() {
		return this.next;
	}

	@Override
	public void remove() {
		throw new UnsupportedOperationException();
	}

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package tree;

class SampleSearching {

	public static void main(String[] args) {
		
		Comparable<String> searchCriteria = new Comparable<String>() {
			@Override
			public int compareTo(String treeData) {
				if (treeData == null)
					return 1;
				boolean nodeOk = treeData.contains("210");
				return nodeOk ? 0 : 1;
			}
		};

		TreeNode<String> treeRoot = Main.getSet1();
		TreeNode<String> found = treeRoot.findTreeNode(searchCriteria);

		System.out.println("Found: " + found);
	}

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package tree;

class SampleIterating {

	public static void main(String[] args) {
		TreeNode<String> treeRoot = Main.getSet1();
		for (TreeNode<String> node : treeRoot) {
			String indent = createIndent(node.getLevel());
			System.out.println(indent + node.data);
		}
	}

	private static String createIndent(int depth) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < depth; i++) {
			sb.append(' ');
		}
		return sb.toString();
	}

}