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);
    }
}