Java中的文件树

Question

我需要列出目录中的所有文件，例如tree /F /AC:/somedir/命令...但是Runtime.getRuntime().exec("tree /F /A /C:/somedir/"); 没有输出。 所以我尝试了java File类和java.nio类，但是有了它，我能够从File.list（）获取AccessDeniedException或空数组...我的朋友建议我使用递归dir /B命令...代码：

public static class TreeNode<T> implements Iterable<TreeNode<T>> {

    public T data;
    public TreeNode<T> parent;
    public List<TreeNode<T>> children;

    public boolean isRoot() {
        return parent == null;
    }

    public boolean isLeaf() {
        return children.size() == 0;
    }

    private List<TreeNode<T>> elementsIndex;

    public TreeNode(T data) {
        this.data = data;
        this.children = new LinkedList<TreeNode<T>>();
        this.elementsIndex = new LinkedList<TreeNode<T>>();
        this.elementsIndex.add(this);
    }

    public TreeNode<T> addChild(T child) {
        TreeNode<T> childNode = new TreeNode<T>(child);
        childNode.parent = this;
        this.children.add(childNode);
        this.registerChildForSearch(childNode);
        return childNode;
    }

    public int getLevel() {
        if (this.isRoot())
            return 0;
        else
            return parent.getLevel() + 1;
    }

    private void registerChildForSearch(TreeNode<T> node) {
        elementsIndex.add(node);
        if (parent != null)
            parent.registerChildForSearch(node);
    }

    public TreeNode<T> findTreeNode(Comparable<T> cmp) {
        for (TreeNode<T> element : this.elementsIndex) {
            T elData = element.data;
            if (cmp.compareTo(elData) == 0)
                return element;
        }
        return null;
    }

    @Override
    public String toString() {
        return data != null ? data.toString() : "[data null]";
    }

    @Override
    public Iterator<TreeNode<T>> iterator() {
        TreeNodeIter<T> iter = new TreeNodeIter<T>(this);
        return iter;
    }

    public static TreeNode<File> createDirTree(File folder) {
        if (!folder.isDirectory()) {
            throw new IllegalArgumentException("folder is not a Directory");
        }
        TreeNode<File> DirRoot = new TreeNode<File>(folder);
        for (File file : folder.listFiles()) {
            if (file.isDirectory()) {
                appendDirTree(file, DirRoot);
            } else {
                appendFile(file, DirRoot);
            }
        }
        return DirRoot;
    }

    public static void appendDirTree(File folder, TreeNode<File> DirRoot) {
      DirRoot.addChild(folder);
      //String path = folder.getAbsolutePath();
      //path = Arrays.toString(path.getBytes(Charset.forName("UTF8")));
      for (String s : Utils.clean(Utils.executeCommand("cmd /C dir /B",null,folder))) {
        File f = new File(folder.getAbsolutePath()+"/"+s);
        if (f.isDirectory()) {
          appendDirTree(f, DirRoot.children.get(DirRoot.children.size() - 1));
        } else {
          appendFile(f, DirRoot.children.get(DirRoot.children.size() - 1));
        }
        f = null;
      }
    }

    public static void appendFile(File file, TreeNode<File> filenode) {
      filenode.addChild(file);
    }

    public static String renderDirectoryTree(TreeNode<File> 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<File> tree) {
            List<StringBuilder> result = new LinkedList<StringBuilder>();
            result.add(new StringBuilder().append(tree.data.getName()));
            Iterator<TreeNode<File>> iterator = tree.children.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();
            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();
            result.add(iterator.next().insert(0, "+-- "));
        while (iterator.hasNext()) {
            result.add(iterator.next().insert(0, "    "));
        }
    }
    public static class TreeNodeIter<T> implements Iterator<TreeNode<T>> {
      enum ProcessStages {
        ProcessParent, ProcessChildCurNode, ProcessChildSubNode
      }
      private TreeNode<T> treeNode;

      public TreeNodeIter(TreeNode<T> treeNode) {
        this.treeNode = treeNode;
        this.doNext = ProcessStages.ProcessParent;
        this.childrenCurNodeIter = treeNode.children.iterator();
      }

      private ProcessStages doNext;
      private TreeNode<T> next;
      private Iterator<TreeNode<T>> childrenCurNodeIter;
      private Iterator<TreeNode<T>> childrenSubNodeIter;

      @Override
      public boolean hasNext() {

        if (this.doNext == ProcessStages.ProcessParent) {
          this.next = this.treeNode;
          this.doNext = ProcessStages.ProcessChildCurNode;
          return true;
        }

        if (this.doNext == ProcessStages.ProcessChildCurNode) {
          if (childrenCurNodeIter.hasNext()) {
            TreeNode<T> childDirect = childrenCurNodeIter.next();
            childrenSubNodeIter = childDirect.iterator();
            this.doNext = ProcessStages.ProcessChildSubNode;
            return hasNext();
          }

          else {
            this.doNext = null;
            return false;
          }
        }

        if (this.doNext == ProcessStages.ProcessChildSubNode) {
          if (childrenSubNodeIter.hasNext()) {
            this.next = childrenSubNodeIter.next();
            return true;
          }
          else {
            this.next = null;
            this.doNext = ProcessStages.ProcessChildCurNode;
            return hasNext();
          }
        }

        return false;
      }

      @Override
      public TreeNode<T> next() {
        return this.next;
      }

      @Override
      public void remove() {
        throw new UnsupportedOperationException();
      }

    }
}

Utils.executeCommand（）和Utils.clean（）方法：

static public String[] executeCommand(String command,String[] env,File folder) {
    try{
      String[] ret = new String[0];
      Process p = Runtime.getRuntime().exec(command,env,folder);
      p.waitFor();
      try{
        BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
        while (input.ready()) {
          ret = append(ret,input.readLine());
        }
        input.close();
      } catch(Exception e) {
        e.printStackTrace(System.out);
      }
    //  try{
    //    Object myObj = new BufferedOutputStream(p.getOutputStream());
    //    Class myClass = myObj.getClass();
    //    Field myField = getField(myClass, "buf");
    //    myField.setAccessible(true);
    //    byte[] byteArray = (byte[])myField.get(myObj);
    //    BufferedReader output = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(byteArray)));
    //    while (output.ready()) {
    //      ret = append(ret,output.readLine());
    //    }
    //    output.close();
    //  } catch(Exception e) {
    //    e.printStackTrace(System.out);
    //  }
    //  InputStream err = p.getErrorStream();
    //  err.skip(err.available());
    //  err.close();
      return ret;
    } catch(Exception e) {
      e.printStackTrace(System.out);
    }
    return new String[]{""};
  }

static public String[] clean(String[] arr) {
    List<String> list = new ArrayList<String>(Arrays.asList(arr));
    for(int i = 0;i < list.size();i++) {
      //list.set(i,list.get(i).replaceAll("[^\\x00-\\x7F]", ""));
      list.set(i,list.get(i).replaceAll("[\\p{Cntrl}&&[^\r\n\t]]", ""));
      list.set(i,list.get(i).replaceAll("\\p{C}", ""));
    }
    list.removeAll(Arrays.asList("", null));
    return list.toArray(new String[list.size()]);
  }

当我在大型目录中使用此方法时，花费太多时间来构建树。 我大约在20-25分钟前运行了程序，此刻，当我写这篇文章时，它仍在构建文件树。

有一个更好的方法吗？ 还是一种优化我的方法的方法？