.
 +---A
 |   +---IMAGES
 |       +---BACKUP
 +---ADOKS
 |   +---ROZDZIAL_2
 |   +---ROZDZIAL_3
 |   +---ROZDZIAL_4
 +---AMSC2005
 |   +---AMSC2004
 +---FCCS2005
 |   +---source
 |   +---TMP
 +---LODZ2004
 +---ZAKOPANE2004
 +---DYDAKTYKA
 |   +---DYDAKTYKA_ISI
 |   |   +---COLLS
 |   |   |   +---Q1
 |   |   |   +---Q2
 |   |   |   +---RAZEM
 |   |   |       +---RYSUNKI_COLL1
 |   |   |       +---RYSUNKI_COLL2
 |   |   +---IMAGES
 |   |   +---src
 |   |   +---WYKLAD5
 |   +---DYDAKTYKA_PRG
 |       +---images
 |       +---POMOC
 +---DYDAKTYKA_KST
 |   +---images
 |   +---src
 +---DYDAKTYKA_WPR
     +---images
     +---src

private static void getInto(String p, int n) {
    File path = new File(p);
    File[] list = path.listFiles();

    for (int i = 0; i < list.length; i++) {
        if (list[i].isDirectorhowny()) {
            for (int j = 0; j < n; j++)
                if (WHAT HERE?)
                    System.out.print("|  ");
                else
                    System.out.print("   ");

            System.out.println("+--" + list[i].getName().toString());

            getInto(list[i].getPath(), n + 1);
        }
    }
}

import java.io.File;
public class FileAssert {

/**
 * Pretty print the directory tree and its file names.
 *
 * @param folder
 *            must be a folder.
 * @return
 */
public static String printDirectoryTree(File folder) {
    if (!folder.isDirectory()) {
        throw new IllegalArgumentException("folder is not a Directory");
    }
    int indent = 0;
    StringBuilder sb = new StringBuilder();
    printDirectoryTree(folder, indent, sb);
    return sb.toString();
}

private static void printDirectoryTree(File folder, int indent,
        StringBuilder sb) {
    if (!folder.isDirectory()) {
        throw new IllegalArgumentException("folder is not a Directory");
    }
    sb.append(getIndentString(indent));
    sb.append("+--");
    sb.append(folder.getName());
    sb.append("/");
    sb.append("n");
    for (File file : folder.listFiles()) {
        if (file.isDirectory()) {
            printDirectoryTree(file, indent + 1, sb);
        } else {
            printFile(file, indent + 1, sb);
        }
    }

}

private static void printFile(File file, int indent, StringBuilder sb) {
    sb.append(getIndentString(indent));
    sb.append("+--");
    sb.append(file.getName());
    sb.append("n");
}

private static String getIndentString(int indent) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < indent; i++) {
        sb.append("|  ");
    }
    return sb.toString();
}
}

+--folder1/
|  +--a.txt
|  +--folder2/
|  |  +--b1.txt
|  |  +--b2.txt
|  |  +--b3.txt
|  |  +--folder3/
|  +--folder4/

import static org.junit.Assert.*;

import java.io.File;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

@RunWith(JUnit4.class)
public class FileAssertTest {

@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
private File folder1;

@Before
public void setUp() {
    folder1 = temporaryFolder.newFolder("folder1");
}

@Test
public void testPrintDirectoryTreeWhenFolderIsEmpty() {
    // Invoke
    String actual = FileAssert.printDirectoryTree(folder1);
    // Verify
    assertEquals("+--folder1/n", actual);
}

private static final String EXPECTED_FCOF = "" + "+--folder1/n"
        + "|  +--a.txtn";

@Test
public void testPrintDirectoryTreeWhenFolderContainsOneFile()
        throws Exception {
    // Setup
    File aFile = new File(folder1, "a.txt");
    assertTrue(aFile.createNewFile());
    // Invoke
    String actual = FileAssert.printDirectoryTree(folder1);
    // Verify
    assertEquals(EXPECTED_FCOF, actual);
}

private static final String EXPECTED_COMPLEX = "+--folder1/n"
        + "|  +--a.txtn" + "|  +--folder2/n" + "|  |  +--b1.txtn"
        + "|  |  +--b2.txtn" + "|  |  +--b3.txtn" + "|  |  +--folder3/n"
        + "|  +--folder4/n";

@Test
public void testPrintDirectoryTreeComplex() throws Exception {
    // Setup
    File aFile = new File(folder1, "a.txt");
    assertTrue(aFile.createNewFile());
    File folder2 = new File(folder1, "folder2");
    assertTrue(folder2.mkdir());
    File b1File = new File(folder2, "b1.txt");
    assertTrue(b1File.createNewFile());
    File b2File = new File(folder2, "b2.txt");
    assertTrue(b2File.createNewFile());
    File folder3 = new File(folder2, "folder3");
    assertTrue(folder3.mkdir());
    File b3File = new File(folder2, "b3.txt");
    assertTrue(b3File.createNewFile());
    File folder4 = new File(folder1, "folder4");
    assertTrue(folder4.mkdir());

    // Invoke
    String actual = FileAssert.printDirectoryTree(folder1);
    // Verify
    assertEquals(EXPECTED_COMPLEX, actual);
}

}

public static String renderDirectoryTree(TreeNode<FileInformation> tree) {
    List<StringBuilder> lines = renderDirectoryTreeLines(tree);
    String newline = System.getProperty("line.separator");
    StringBuilder sb = new StringBuilder(lines.size() * 20);
    for (StringBuilder line : lines) {
        sb.append(line);
        sb.append(newline);
    }
    return sb.toString();
}

public static List<StringBuilder> renderDirectoryTreeLines(TreeNode<FileInformation> tree) {
    List<StringBuilder> result = new LinkedList<>();
    result.add(new StringBuilder().append(tree.getData().getPath().getFileName()));
    Iterator<TreeNode<FileInformation>> iterator = tree.getChildren().iterator();
    while (iterator.hasNext()) {
        List<StringBuilder> subtree = renderDirectoryTreeLines(iterator.next());
        if (iterator.hasNext()) {
            addSubtree(result, subtree);
        } else {
            addLastSubtree(result, subtree);
        }
    }
    return result;
}

private static void addSubtree(List<StringBuilder> result, List<StringBuilder> subtree) {
    Iterator<StringBuilder> iterator = subtree.iterator();
    //subtree generated by renderDirectoryTreeLines has at least one line which is tree.getData()
    result.add(iterator.next().insert(0, "├── "));
    while (iterator.hasNext()) {
        result.add(iterator.next().insert(0, "│   "));
    }
}

private static void addLastSubtree(List<StringBuilder> result, List<StringBuilder> subtree) {
    Iterator<StringBuilder> iterator = subtree.iterator();
    //subtree generated by renderDirectoryTreeLines has at least one line which is tree.getData()
    result.add(iterator.next().insert(0, "└── "));
    while (iterator.hasNext()) {
        result.add(iterator.next().insert(0, "    "));
    }
}

import java.io.File;

public class MainEntry {
public static void main(String[] args) {
    walkin(new File("/home/user")); //Replace this with a suitable directory
}

/**
 * Recursive function to descend into the directory tree and find all the files
  @param dir A file object defining the top directory
 **/
public static void walkin(File dir) {

    File listFile[] = dir.listFiles();
    if (listFile != null) {
        for (int i=0; i<listFile.length; i++) {
            if (listFile[i].isDirectory()) {
              System.out.println("|tt");
              walkin(listFile[i]);
            } else {

                System.out.println("+---"+listFile[i].getName().toString());

            }
        }
    }
}

procedure printOutput(file, depth):
    print "|   " depth times;
    print "+---" + file name;
    print new line
    if(file is a directory):
        for(each file inside file, say innerFile):
            call printOutput(innerFile, depth + 1);

import java.io.File;

  public class Tree
  {
    public static void main(String[] args) throws Exception
    {
      File folder = new File((args.length >= 1 && args[0].length() > 0)
        ? args[0]
        : ".");

      if (!folder.isDirectory())
      {
        throw new IllegalArgumentException("Invalid directory: " + folder.getName());
      }

      int level = 0;
      System.out.println(renderFolder(folder, level, new StringBuilder(), false));
    }

    private static StringBuilder renderFolder(File folder, int level, StringBuilder sb, boolean isLast)
    {
      indent(sb, level, isLast).append("[D] ").append(folder.getName()).append("n");

      File[] objects = folder.listFiles();

      for (int i = 0; i < objects.length; i++)
      {
        boolean last = ((i + 1) == objects.length);

        if (objects[i].isDirectory())
        {
          renderFolder(objects[i], level + 1, sb, last);
        }
        else
        {
          renderFile(objects[i], level + 1, sb, last);
        }
      }

      return sb;
    }

    private static StringBuilder renderFile(File file, int level, StringBuilder sb, boolean isLast)
    {
      return indent(sb, level, isLast).append("--- ").append(file.getName()).append("n");
    }

    private static StringBuilder indent(StringBuilder sb, int level, boolean isLast)
    {
      for (int i = 1; i < level; i++)
      {
        sb.append("|  ");
      }

      if (level > 0)
      {
        sb.append(isLast
          ? "`-"
          : "|-");
      }

      return sb;
    }

  }




  [D] .
  |-[D] classes
  |  |-[D] .data
  |  |  `---- Play.cdi_javac
  |  |---- ArrayListTest$Pair.class
  |  |---- ArrayListTest.class
  |  |---- ArrayTest.class
  |  |-[D] fruit
  |  |  |---- Apple.class
  |  |  `---- GrannySmith.class
  |  |---- IfTest.class
  |  |-[D] interview
  |  |  |---- Q1.class
  |  |  |---- Q2.class
  |  |  |---- Q3.class
  |  |  |---- Q3Sub.class
  |  |  |---- Q9Sub.class
  |  |  `---- Q9Super.class
  |  |---- IntOverflowTest.class
  |  |---- LinkedMapTest.class
  |  |-[D] log
  |  |  `---- Logger.class
  |  |---- log.properties
  |  |---- StringCaseTest.class
  |  |-[D] test
  |  |  |-[D] cache
  |  |  |  |-[D] test1
  |  |  |  |  |---- Cache.class
  |  |  |  |  |---- CacheEntry.class
  |  |  |  |  `---- RevisedCacheTest.class
  |  |  |  |-[D] test2
  |  |  |  |  |---- Cache.class
  |  |  |  |  |---- Log.class
  |  |  |  |  `---- RevisedCacheTest.class
  |  |  |  `-[D] test3
  |  |  |  |  |---- ConcurrentCache.class
  |  |  |  |  `---- ConcurrentCacheTest.class
  |  |  |---- Test.class
  |  |  `---- Test2.class
  |  |---- Test.class
  |  |---- Test2.class
  |  `---- ZipTest.class
  `---- Play.jpr

import java.io.File;

public class MostrarArbol {

    public static void main(String args[]) {
        File carpeta = new File(args[0]);
        // File carpeta = new File(".");
        if (!carpeta.exists()) {
            System.out.println(args[0] + " NO existe.");
            return;
        }
        imprimeArbol(carpeta, "");
    }

    public static void imprimeArbol(File carpeta, String tabulador) {
        File contenido[] = carpeta.listFiles();
        if (contenido != null) {
            for (int i = 0; i < contenido.length; i++)
                if (contenido[i].isDirectory()) {
                    System.out.println(tabulador + "|-" + contenido[i].getName());
                    imprimeArbol(contenido[i], tabulador + "|  ");
                } else {
                    System.out.println(tabulador + "+-" + contenido[i].getName().toString());
                }
        }
    }
}

package DIRS;

import java.io.File;

public class LISTDIR
{
    public static void main(String[] args)
    {
        String path = System.getProperty("user.dir")+File.separator;

        File file[] = new File(path).listFiles();

        for(int i = 0 ; i < file.length ; i++)
        {
            if(file[i].isDirectory())
            {
                System.out.println("->"+file[i].getName());
                new LISTDIR().listfiles(file[i],"--");
            }
            else
            {
                System.out.println("-> "+file[i].getName());
            }
        }
    }

    public void listfiles(File f,String sprtr)
    {
        File file[] = f.listFiles();
        for(int i = 0 ; i < file.length ; i++)
        {
            if(file[i].isDirectory())
            {
                System.out.println(sprtr+file[i].getName());

                new LISTDIR().listfiles(file[i],"--"+sprtr);
            }
            else
            {
                System.out.println(sprtr+file[i].getName());
            }
        }
    }
}