用java 编写一个程序,在命令行中以树状结构展现特定的文件夹及其子文件(夹)!

当然在理论上是可以实现的，可以将所有的子文件都以树形结构出来，但是文件很多的时候就会非常纠结

创新互联公司服务项目包括东西湖网站建设、东西湖网站制作、东西湖网页制作以及东西湖网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，东西湖网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到东西湖省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

我理解中的树形结构大概是这样(不知道这样的图形是不是你想要的)

a

|

------------------

| | |

b c d

以下是代码，找了系统盘下子文件较少的文件夹 C:/Windows/AppPatch，当然也可以换成你自己的路径来测试

import java.io.File;

public class FileTree {

/**

* @param args

*/

public static void main(String[] args) {

try{

File file = new File("C:\\Windows\\AppPatch");

if(file.isDirectory()){

String[] fileList = file.list();

String fileName = file.getName();

int allLength = 0;

for(int i=0;ifileList.length;i++){

allLength += (fileList[i]+" ").length();

}

for(int i=0;iallLength/2;i++){

System.out.print(" ");

}

System.out.println(fileName);

for(int i=0;iallLength/2;i++){

System.out.print(" ");

}

for(int i=0;ifileName.length()/2;i++){

System.out.print(" ");

}

System.out.println("|");

for(int i=0;iallLength;i++){

System.out.print("-");

}

System.out.println("");

for(int i=0;ifileList.length;i++){

int tmpLength = fileList[i].length();

int subLength = tmpLength/2;

int lastLength = tmpLength - subLength - 1;

for(int j=0;jsubLength;j++){

System.out.print(" ");

}

System.out.print("|");

for(int j=0;jlastLength;j++){

System.out.print(" ");

}

System.out.print(" ");

}

System.out.println("");

for(int i=0;ifileList.length;i++){

System.out.print(fileList[i]+" ");

}

}

else{

System.out.println("对不起，你提供的路径不是文件夹");

}

}

catch (Exception e) {

e.printStackTrace();

}

}

}

这时可以发现输出每一个子文件/子文件夹的名字已经比较长，要是再想输出这些子文件夹里面的文件，那幅图个人觉得相当纠结，也许是我水平没够吧或是我理解错了你说的树形结构

希望以上代码对你有帮助

哪位大神可以帮帮忙啊，我想用Java读取Excel的数据并做成树状图，横坐标

下面是一个简单的读取例子，如果报“java.io.IOException: Invalid header signature; read 4503608217567241, expected -2226271756974174256”之类的异常请用Excel打开（如果能打的开的话）然后另存为一下。

import java.io.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.text.DecimalFormat;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.List;

import org.apache.poi.hssf.usermodel.HSSFCell;

import org.apache.poi.hssf.usermodel.HSSFDateUtil;

import org.apache.poi.hssf.usermodel.HSSFRow;

import org.apache.poi.hssf.usermodel.HSSFSheet;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class Test0 {

/**

* @param args

* @throws IOException

* @throws FileNotFoundException

*/

public static void main(String[] args) throws FileNotFoundException,

IOException {

File file = new File("C://test01.xls");// Excel文件路径

String[][] result = getData(file, 1);

int rowLength = result.length;

for (int i = 0; i  rowLength; i++) {

for (int j = 0; j  result[i].length; j++) {

System.out.print(result[i][j] + "\t\t");

}

System.out.println();

}

}

/**

* 读取Excel的内容，第一维数组存储的是一行中格列的值，二维数组存储的是多少个行

* 

* @param file

*            读取数据的源Excel

* @param ignoreRows

*            读取数据忽略的行数，比喻行头不需要读入 忽略的行数为1

* @return 读出的Excel中数据的内容

* @throws FileNotFoundException

* @throws IOException

*/

public static String[][] getData(File file, int ignoreRows)

throws FileNotFoundException, IOException {

ListString[] result = new ArrayListString[]();

int rowSize = 0;

BufferedInputStream in = new BufferedInputStream(new FileInputStream(

file));

// 打开HSSFWorkbook

POIFSFileSystem fs = new POIFSFileSystem(in);

HSSFWorkbook wb = new HSSFWorkbook(fs);

HSSFCell cell = null;

for (int sheetIndex = 0; sheetIndex  wb.getNumberOfSheets(); sheetIndex++) {

HSSFSheet st = wb.getSheetAt(sheetIndex);

// 第一行为标题，不取

for (int rowIndex = ignoreRows; rowIndex = st.getLastRowNum(); rowIndex++) {

HSSFRow row = st.getRow(rowIndex);

if (row == null) {

continue;

}

int tempRowSize = row.getLastCellNum() + 1;

if (tempRowSize  rowSize) {

rowSize = tempRowSize;

}

String[] values = new String[rowSize];

Arrays.fill(values, "");

boolean hasValue = false;

for (short columnIndex = 0; columnIndex = row.getLastCellNum(); columnIndex++) {

String value = "";

cell = row.getCell(columnIndex);

if (cell != null) {

// 注意：一定要设成这个，否则可能会出现乱码

cell.setEncoding(HSSFCell.ENCODING_UTF_16);

switch (cell.getCellType()) {

case HSSFCell.CELL_TYPE_STRING:

value = cell.getStringCellValue();

break;

case HSSFCell.CELL_TYPE_NUMERIC:

if (HSSFDateUtil.isCellDateFormatted(cell)) {

Date date = cell.getDateCellValue();

if (date != null) {

value = new SimpleDateFormat("-MM-dd")

.format(date);

} else {

value = "";

}

} else {

value = new DecimalFormat("0").format(cell

.getNumericCellValue());

}

break;

case HSSFCell.CELL_TYPE_FORMULA:

// 导入时如果为公式生成的数据则无值

if (!cell.getStringCellValue().equals("")) {

value = cell.getStringCellValue();

} else {

value = cell.getNumericCellValue() + "";

}

break;

case HSSFCell.CELL_TYPE_BLANK:

break;

case HSSFCell.CELL_TYPE_ERROR:

value = "";

break;

case HSSFCell.CELL_TYPE_BOOLEAN:

value = (cell.getBooleanCellValue() == true ? "Y"

: "N");

break;

default:

value = "";

}

}

if (columnIndex == 0  value.trim().equals("")) {

break;

}

values[columnIndex] = rightTrim(value);

hasValue = true;

}

if (hasValue) {

result.add(values);

}

}

}

in.close();

String[][] returnArray = new String[result.size()][rowSize];

for (int i = 0; i  returnArray.length; i++) {

returnArray[i] = (String[]) result.get(i);

}

return returnArray;

}

/**

* 去掉字符串右边的空格

* 

* @param str

*            要处理的字符串

* @return 处理后的字符串

*/

public static String rightTrim(String str) {

if (str == null) {

return "";

}

int length = str.length();

for (int i = length - 1; i = 0; i--) {

if (str.charAt(i) != 0x20) {

break;

}

length--;

}

return str.substring(0, length);

}

}

用Java实现一个树形结构，并对其进行遍历

import java.util.Iterator;

import java.util.Random;

import java.util.TreeSet;

public class Demo{

public static void main(String[] args) throws Exception {

TreeSetInteger ts = new TreeSetInteger();

for(int i = 0; i  10; i++){

ts.add(new Random().nextInt(999));

}

for(IteratorInteger it = ts.iterator(); it.hasNext();){

System.out.println(it.next());

}

}

}

//上面是利用TreeSet进行简单的二叉树实现，另有遍历，当然遍历是自然顺序。

//如有需要请自行修改吧。

如何用Java实现树形结构啊？

package tree;

import java.util.LinkedList;

import java.util.List;

/**

* 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历

*

* 参考资料0:数据结构(C语言版)严蔚敏

*

* 参考资料1：

*

* 参考资料2：

*

* @author ocaicai@yeah点虐 @date: 2011-5-17

*

*/

public class BinTreeTraverse2 {

private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

private static ListNode nodeList = null;

/**

* 内部类：节点

*

* @author ocaicai@yeah点虐 @date: 2011-5-17

*

*/

private static class Node {

Node leftChild;

Node rightChild;

int data;

Node(int newData) {

leftChild = null;

rightChild = null;

data = newData;

}

}

public void createBinTree() {

nodeList = new LinkedListNode();

// 将一个数组的值依次转换为Node节点

for (int nodeIndex = 0; nodeIndex array.length; nodeIndex++) {

nodeList.add(new Node(array[nodeIndex]));

}

// 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树

for (int parentIndex = 0; parentIndex array.length / 2 - 1; parentIndex++) {

// 左孩子

nodeList.get(parentIndex).leftChild = nodeList

.get(parentIndex * 2 + 1);

// 右孩子

nodeList.get(parentIndex).rightChild = nodeList

.get(parentIndex * 2 + 2);

}

// 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理

int lastParentIndex = array.length / 2 - 1;

// 左孩子

nodeList.get(lastParentIndex).leftChild = nodeList

.get(lastParentIndex * 2 + 1);

// 右孩子,如果数组的长度为奇数才建立右孩子

if (array.length % 2 == 1) {

nodeList.get(lastParentIndex).rightChild = nodeList

.get(lastParentIndex * 2 + 2);

}

}

/**

* 先序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void preOrderTraverse(Node node) {

if (node == null)

return;

System.out.print(node.data + " ");

preOrderTraverse(node.leftChild);

preOrderTraverse(node.rightChild);

}

/**

* 中序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void inOrderTraverse(Node node) {

if (node == null)

return;

inOrderTraverse(node.leftChild);

System.out.print(node.data + " ");

inOrderTraverse(node.rightChild);

}

/**

* 后序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void postOrderTraverse(Node node) {

if (node == null)

return;

postOrderTraverse(node.leftChild);

postOrderTraverse(node.rightChild);

System.out.print(node.data + " ");

}

public static void main(String[] args) {

BinTreeTraverse2 binTree = new BinTreeTraverse2();

binTree.createBinTree();

// nodeList中第0个索引处的值即为根节点

Node root = nodeList.get(0);

System.out.println("先序遍历：");

preOrderTraverse(root);

System.out.println();

System.out.println("中序遍历：");

inOrderTraverse(root);

System.out.println();

System.out.println("后序遍历：");

postOrderTraverse(root);

}

}

本文标题：改为树状结构java代码 改为树状结构java代码是什么
标题来源：http://scyanting.com/article/ddigpdd.html