package tree;

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Node node = new Node("name", null, 0L);
        int foundForName = findByName(node, "name").size();
        int foundForName1 = findByName(node, "name1").size();
        System.out.println("found for name - " + foundForName);
        System.out.println("found for name1 - " + foundForName1);

        Tree tree = new Tree("name", null);
        tree.add(node);
        int foundForNameInTree = findByName(tree, "name").size();
        System.out.println("found for name in tree - " + foundForNameInTree);

        Tree tree2 = new Tree("name", null);
        tree2.add(node);
        tree.add(tree2);
        int foundForNameInTree2 = findByName(tree, "name").size();
        System.out.println("found for name in tree 2 - " + foundForNameInTree2);

    }

    public static List<Entry> findByName(final Entry entry, final String name) {
        final List<Entry> result = new ArrayList<Entry>();
        final Queue<Entry> allFiles = new LinkedList<Entry>();
        allFiles.add(entry);
        while (!allFiles.isEmpty()) {
            final Entry localEntry = allFiles.poll();
            if (localEntry instanceof Tree) {
                final List<Entry> files = ((Tree) localEntry).iterate();
                for (final Entry 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;

public abstract class Entry {
    private final Tree parent;
    private final long created;
    private String name;
    private long lastUpdated;
    private long lastAccessed;

    public Entry(String name, Tree parent) {
        this.name = name;
        this.parent = parent;
        this.created = System.currentTimeMillis();
    }

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

    public abstract long size();

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

    public long getCreationTime() {
        return created;
    }

    public long getLastUpdated() {
        return lastUpdated;
    }

    public long getLastAccessed() {
        return lastAccessed;
    }

    public void setLastUpdated(long lastUpdated) {
        this.lastUpdated = lastUpdated;
    }

    public void setLastAccessed(long lastAccessed) {
        this.lastAccessed = lastAccessed;
    }

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

    public String getName() {
        return name;
    }
}

package tree;

public class Node extends Entry {
    private final java.io.ByteArrayOutputStream stream;
    private final long size;

    public Node(String name, Tree parent, long size) {
        super(name, parent);
        this.size = size;
        this.stream = new java.io.ByteArrayOutputStream();
    }

    public long size() {
        return size;
    }

    public byte[] getContents() {
        setLastAccessed(System.currentTimeMillis());
        return stream.toByteArray();
    }

    public void setContents(byte[] content) {
        this.stream.write(content, 0, content.length);
        setLastUpdated(System.currentTimeMillis());
    }
}

package tree;

import java.util.ArrayList;
import java.util.List;

public class Tree extends Entry {
    private final List<Entry> contents;

    public Tree(String name, Tree tree) {
        super(name, tree);
        contents = new ArrayList<Entry>();
    }

    protected List<Entry> iterate() {
        return contents;
    }

    public long size() {
        long size = 0;
        for (final Entry entry : contents) {
            size += entry.size();
        }
        return size;
    }

    public boolean remove(Entry entry) {
        return contents.remove(entry);
    }

    public void add(Entry entry) {
        contents.add(entry);
    }
}

Main.java:

package tree;

public class Main {

    public static void main(String[] args) {
        Node node = new Node("name", null, 0L);
        int foundForName = node.findByName("name").size();
        int foundForName1 = node.findByName("name1").size();
        System.out.println("found for name - " + foundForName);
        System.out.println("found for name1 - " + foundForName1);

        Tree tree = new Tree("name", null);
        tree.add(node);
        int foundForNameInTree = tree.findByName("name").size();
        System.out.println("found for name in tree - " + foundForNameInTree);

        Tree tree2 = new Tree("name", null);
        tree2.add(node);
        tree.add(tree2);
        int foundForNameInTree2 = tree.findByName("name").size();
        System.out.println("found for name in tree 2 - " + foundForNameInTree2);

    }
}

Entry.java:

package tree;

import java.util.*;

public abstract class Entry {
    private final Tree parent;
    private String name;

    public Entry(String name, Tree parent) {
        this.name = name;
        this.parent = parent;
    }

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

    public abstract long size();

    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<Entry> findByName(final String name) {
        final List<Entry> result = new ArrayList<Entry>();
        final Queue<Entry> allFiles = new LinkedList<Entry>();
        allFiles.add(this);
        while (!allFiles.isEmpty()) {
            final Entry localEntry = allFiles.poll();
            if (localEntry instanceof Tree) {
                final List<Entry> files = ((Tree) localEntry).iterate();
                for (final Entry 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;
    }
}

Node.java:

package tree;

public class Node extends Entry {
    private final java.io.ByteArrayOutputStream stream;
    private final long size;

    public Node(String name, Tree parent, long size) {
        super(name, parent);
        this.size = size;
        this.stream = new java.io.ByteArrayOutputStream();
    }

    public long size() {
        return size;
    }

    public byte[] getContents() {
        return stream.toByteArray();
    }

    public void setContents(byte[] content) {
        this.stream.write(content, 0, content.length);
    }
}

Tree.java:

package tree;

import java.util.ArrayList;
import java.util.List;

public class Tree extends Entry {
    private final List<Entry> contents;

    public Tree(String name, Tree tree) {
        super(name, tree);
        contents = new ArrayList<Entry>();
    }

    protected List<Entry> iterate() {
        return contents;
    }

    public long size() {
        long size = 0;
        for (final Entry entry : contents) {
            size += entry.size();
        }
        return size;
    }

    public boolean remove(Entry entry) {
        return contents.remove(entry);
    }

    public void add(Entry entry) {
        contents.add(entry);
    }
}

found for name - 1
found for name1 - 0
found for name in tree - 1
found for name in tree 2 - 2

Main.java

package tree;

public class Main {

    public static void main(String[] args) {
        Directory rootFolder = new Directory("RootFolder", null);
        Directory video = new Directory("Video", null);
        Directory music = new Directory("Music", null);
        Directory picture = new Directory("Picture", null);
        rootFolder.add(video);
        rootFolder.add(music);
        rootFolder.add(picture);
        File terminator = new File("Terminator", null);
        File dieHard = new File("Die Hard", null);
        File rocky = new File("Rocky", null);
        File abba = new File("Abba", null);
        video.add(terminator);
        video.add(dieHard);
        video.add(rocky);
        music.add(abba);
        Directory homePicture = new Directory("Home picture", null);
        Directory workPicture = new Directory("Work picture", null);
        picture.add(homePicture);
        picture.add(workPicture);

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

Entry.java:

package tree;

import java.util.*;

public abstract class Entry {
    private final Directory parent;
    private String name;

    public Entry(String name, Directory parent) {
        this.name = name;
        this.parent = parent;
    }

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

    public abstract long size();

    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<Entry> findByName(final String name) {
        final List<Entry> result = new ArrayList<Entry>();
        final Queue<Entry> allFiles = new LinkedList<Entry>();
        allFiles.add(this);
        while (!allFiles.isEmpty()) {
            final Entry localEntry = allFiles.poll();
            if (localEntry instanceof Directory) {
                final List<Entry> files = ((Directory) localEntry).iterate();
                for (final Entry innerFile : files) {
                    if (innerFile instanceof Directory) {
                        allFiles.add(innerFile);
                    } else if (innerFile.getName().equals(name)) {
                        result.add(innerFile);
                    }
                }
            } else if (localEntry.getName().equals(name)) {
                result.add(localEntry);
            }
        }
        return result;
    }
}

File.java:

package tree;

public class File extends Entry {
    private final java.io.ByteArrayOutputStream stream;

    public File(String name, Directory parent) {
        super(name, parent);
        this.stream = new java.io.ByteArrayOutputStream();
    }

    public long size() {
        return stream.size();
    }

    public byte[] getContents() {
        return stream.toByteArray();
    }

    public void setContents(byte[] content) {
        this.stream.write(content, 0, content.length);
    }
}

Directory.java:

package tree;

import java.util.ArrayList;
import java.util.List;

public class Directory extends Entry {
    private final List<Entry> contents;

    public Directory(String name, Directory directory) {
        super(name, directory);
        contents = new ArrayList<Entry>();
    }

    protected List<Entry> iterate() {
        return contents;
    }

    public long size() {
        long size = 0;
        for (final Entry entry : contents) {
            size += entry.size();
        }
        return size;
    }

    public boolean remove(Entry entry) {
        return contents.remove(entry);
    }

    public void add(Entry entry) {
        contents.add(entry);
    }
}