File Tree
Description
Build a String representation of directory hierarchy under a given path

Details
Implement tree method in FileTreeImpl class.

Input parameter is a path.

If a given path does not exist, return an empty Optional.

If a given path refers to a file, return a String with its name and size like this:

some-file.txt 128 bytes
IF a given path refers to a directory, return a String with its name, total size and its full hierarchy:

some-dir 100 bytes
├─ some-inner-dir 50 bytes
│  ├─ some-file.txt 20 bytes    
│  └─ some-other-file.txt 30 bytes
└─ some-one-more-file.txt 50 bytes
Use pseudo graphic symbols to format output.
Compute directory size as a sum of all its contents.
Sort content in following way:
directories go first,
directories and files are sorted in lexicographic order (case-insensitive).

import java.io.File;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class FileTreeImpl implements FileTree {

    @Override
    public Optional<String> tree(Path path) {
        File file = new File(String.valueOf(path));
        if ( !file.exists()) return Optional.empty();
        if ( file.isFile()) {
            return Optional.of(file.getName() + " " + file.length() + " bytes");
        }
        if (file.isDirectory()) {
            return Optional.of(directoryTree(file, 0, false));
        }
        return Optional.empty();
    }
    private String directoryTree(File folder, int depth, boolean lastFolder) {
        String directory = folder.getName() + " " + folderSize(folder);
        if (depth != 0) directory = ((!lastFolder) ? "├─ " : "└─ ") + directory;
        File[] files = folder.listFiles();
        int count = files.length;
        files = sortFiles(files);
        for (int i = 0; i < count; i++) {
            directory += "\n";
            if (depth != 0) directory += "│  ";
            if (files[i].isFile()) {
                directory += (lastFolder ? "   " : "│  ") + (i + 1 == count ? "└" : "├") + "─ " +
                        files[i].getName() + " " + files[i].length() + " bytes";
            } else {
                directory += directoryTree(files[i], depth + 1, i + 1 == numberOfFolders(files));
            }
        }
        System.out.println(directory);
        return directory;
    }
    private long getFolderSize(File folder) {
        long size = 0;
        File[] files = folder.listFiles();

        int count = files.length;

        for (int i = 0; i < count; i++) {
            if (files[i].isFile()) {
                size += files[i].length();
            } else {
                size += getFolderSize(files[i]);
            }
        }
        return size;
    }
    private String folderSize(File folder) {
        return getFolderSize(folder) + " bytes";
    }
    private File[] sortFiles(File[] folder) {
        // сортує за іменами
        Arrays.sort(folder);
        List<File> sorted = new ArrayList<>();
        // спочатку вибираю папки
        for (int i = 0; i < folder.length; i++) {
            if (folder[i].isDirectory()) sorted.add(folder[i]);
        }
        // тепер вибираю файли
        for (int i = 0; i < folder.length; i++) {
            if (folder[i].isFile()) sorted.add(folder[i]);
        }
        return sorted.toArray(new File[sorted.size()]);
    }
    private int numberOfFolders(File[] files) {
        int folders = 0;
        for (File file : files)
            if (file.isDirectory()) folders++;
        return folders;
    }
}

import org.junit.Test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Collectors;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class FileTreeTest {

    @Test
    public void testEmptyCases() {
        assertTrue("null case failure", new FileTreeImpl().tree(null).isEmpty());
        assertTrue("nonexistent path case failure", new FileTreeImpl().tree(Paths.get("some", " non", "existent", "path")).isEmpty());
    }

    @Test
    public void testFileCases() {
        testCase("some.txt 0 bytes", tree("test1", "some.txt"));
        testCase("some1.txt 4 bytes", tree("test1", "some1.txt"));
        testCase("some2.txt 8 bytes", tree("test1", "some2.txt"));
    }

    @Test
    public void testDirCase1() throws IOException {
        testDirCase("test1");
    }

    @Test
    public void testDirCase2() throws IOException {
        testDirCase("test2");
    }

    @Test
    public void testDirCase3() throws IOException {
        testDirCase("test3");
    }

    @Test
    public void testDirCase4() throws IOException {
        testDirCase("test4");
    }

    @Test
    public void testDirCase5() throws IOException {
        testDirCase("test5");
    }

    @Test
    public void testDirCase6() throws IOException {
        testDirCase("test6");
    }

    @Test
    public void testDirCase7() throws IOException {
        testDirCase("test7");
    }

    @Test
    public void testDirCase8() throws IOException {
        testDirCase("test8");
    }

    private void testDirCase(final String caseName) throws IOException {
        testCase(expectedFile(caseName), tree(caseName));
    }

    private void testCase(final String expected, final String actual) {
        assertEquals(expected.trim(), actual.trim());
    }

    private String expectedFile(String caseName) throws IOException {
        return Files.lines(Paths.get("src/test/resources", caseName + ".txt"))
                .collect(Collectors.joining("\n"));

    }


    private String tree(final String... subPath) {
        return new FileTreeImpl().tree(Paths.get("src/test/resources", subPath)).orElse(null);
    }

}