sure you can...

this is an example taken out of the "generative-gestaltung.de" book that shows you how to read the files and folder structure from a certain folder...

1. // M_5_2_01.pde
   // FileSystemItem.pde
   // http://www.generative-gestaltung.de
    
   // CREDITS
   // part of the FileSystemItem class is based on code from Visualizing Data, First Edition
   // by Ben Fry. Copyright 2008 Ben Fry, 9780596514556.
   
   /**
    * press 'o' to select an input folder!
    * console output only!
    * take care of very big folders, loading will take up to several minutes.
    *
    * program takes a file directory (hierarchical tree) on harddisk
    * as input and prints all filenames to the console.
    *
    * and shows also how to traverse a hierarchical tree in two
    * different ways: Depth First Search + Breadth First Search
    *
    * KEYS
    * o                  : select an input folder
    */
   
   // ------ default folder path ------
   String defaultFolderPath = System.getProperty("user.home")+"/Desktop";
   //String defaultFolderPath = "/Users/admin/Desktop";
   //String defaultFolderPath = "C:\\windows";
   
   // ------ program logic ------
   int fileCounter = 0;
   
   void setup() {
     size(128,128);
     setInputFolder(defaultFolderPath);
   }
   
   void draw() {
     // keep the app running
   }
   
   // ------ folder selection dialog + init visualization ------
   void setInputFolder(String theFolderPath) {
     // get files on harddisk
     println("\n"+theFolderPath);
     FileSystemItem selectedFolder = new FileSystemItem(new File(theFolderPath));
     selectedFolder.printDepthFirst();
     println("\n");
     selectedFolder.printBreadthFirst();
   }
   
   void keyReleased() {
     if (key == 'o' || key == 'O') {
       setInputFolder(selectFolder("please select a folder"));
     }
   }
   
   
   class FileSystemItem {
     File file;
     FileSystemItem[] children;
     int childCount;
   
     // ------ constructor ------
     FileSystemItem(File theFile) {
       file = theFile;
   
       if (file.isDirectory()) {
         String[] contents = file.list();
         if (contents != null) {
           // Sort the file names in case insensitive order
           contents = sort(contents);
   
           children = new FileSystemItem[contents.length];
           for (int i = 0 ; i < contents.length; i++) {
             // skip the . and .. directory entries on Unix systems
             if (contents[i].equals(".") || contents[i].equals("..")
               || contents[i].substring(0,1).equals(".")) {
               continue;
             }
             File childFile = new File(file, contents[i]);
             // skip any file that appears to be a symbolic link
             try {
               String absPath = childFile.getAbsolutePath();
               String canPath = childFile.getCanonicalPath();
               if (!absPath.equals(canPath)) continue;
             }
             catch (IOException e) {
             }
             FileSystemItem child = new FileSystemItem(childFile);
             children[childCount] = child;
             childCount++;
           }
         }
       }
     }
   
   
   
     // ------ print and debug functions ------
     // Depth First Search
     void printDepthFirst() {
       println("printDepthFirst");
       // global fileCounter
       fileCounter = 0;
       printDepthFirst(0,-1);
       println(fileCounter+" files");
     }
     void printDepthFirst(int depth, int indexToParent) {
       // print four spaces for each level of depth + debug println
       for (int i = 0; i < depth; i++) print("    "); 
       println(fileCounter+" "+indexToParent+"<-->"+fileCounter+" ("+depth+") "+file.getName());
   
       indexToParent = fileCounter;
       fileCounter++;
       // now handle the children, if any
       for (int i = 0; i < childCount; i++) {
         children[i].printDepthFirst(depth+1,indexToParent);
       }
     }
   
   
     // Breadth First Search
     void printBreadthFirst() {
       println("printBreadthFirst");
   
       // queues for pushing and saving all elements in "breadth first search" style
       ArrayList items = new ArrayList(); 
       ArrayList depths = new ArrayList();
       ArrayList indicesParent = new ArrayList();
   
       // add first elements and startingpoint
       items.add(this);
       depths.add(0);
       indicesParent.add(-1);
   
       // tmp vars for running in while loop
       int index = 0;
       int itemCount = 1;
   
       while (itemCount > index) {
         FileSystemItem item = (FileSystemItem) items.get(index);
         int depth = (Integer) depths.get(index);
         int indexToParent = (Integer) indicesParent.get(index);
   
         // print four spaces for each level of depth + debug println
         for (int i = 0; i < depth; i++) print("    ");
         println(index+" "+indexToParent+"<-->"+index+" ("+depth+") "+item.file.getName());
   
         // is current node a directory?
         // yes -> push all children to the end of the items
         if (item.file.isDirectory()) {     
           for (int i = 0; i < item.childCount; i++) {
             items.add(item.children[i]); 
             depths.add(depth+1);
             indicesParent.add(index);   
           }
           itemCount += item.childCount;
         }
         index++;
       }
       println(index+" files");
     }
   }