package test;
 
import java.io.File;
 import java.text.SimpleDateFormat;
 
public class Test03 {
     static int dirs = 0;//定义的变量用于存放统计出来的目录数量和文件数量
     static int files = 0;
     static long dirLength = 0 ;//定义的变量用于存放统计出来的目录大小和文件大小
     static long fileLength = 0;
     static String preStr = "";//定义缩进量，用于以树形结构展现层级
     File f = null;
     Test03(File f){
         this.f = f;
     }
 
    public void tree(File f, int level) {
         /**
          * 由于全局变量在程序销毁之前，
         变量就会一直保存在内存中，这样就会导致上一次运算的值保留了下来，
         再次执行方法的时候就会将值累加，
         这样会导致即使在同一级目录下的文件也会呈现树形分级,
         因此，此处要定义一个局部变量，
         每次执行的时候更新相应的全局变量，因为局部变量在方法每次执行完的时候被销毁，
         也就是说每次执行该方法的时，这个局部变量都不一定是相同的值，这样就避免了累加
         */
 
        String preStr = "";
         this.preStr=preStr;
 
        for (int i = 0; i < level; i++) {
 
            //判断level的层级数，每多一层就添加一个间隔
             preStr +="\t";
         }
 
        //定义文件数组，用存放获取到的文件目录和文件
         File[] childs = f.listFiles();
 
        for (int i = 0; i < childs.length; i++) {
 
            //用for 循环一个个取出来
             //childs[i].isDirectory()用于判断取取出来的file是文件还是目录，然后执行相应的操作
             if (childs[i].isDirectory()) {
 
                dirs++;//获取一个目录就自加一次，记录数量           
 
            }else {
 
                files++;//获取一个文件就自加一次，记录数量
                 fileLength=childs[i].length();//该文件的大小（字节数）
                 dirLength += childs[i].length();//将获取到的每个文件的大小（字节数）加起来，记录整个目录字节数
 
            }
 
            if (!childs[i].isDirectory()) {
                 //打印搜索出的文件和目录,如果是文件就显示文件字节数
 
                System.out.println(preStr + childs[i].getName()+"    "+fileLength+"字节");    
             }else{
 
                System.out.println(preStr + childs[i].getName());
                 System.out.println(preStr +"-------------------------");
             }
 
            if (childs[i].isDirectory()) {
                 //判断是否为目录，如果是，再次执行tree（）方法，将子目录里面的文件再次遍历出来
                 tree(childs[i], level + 1);
             }
         }
 
    }
 
    public static void main(String[] args) {
 
        //给出指定目录
         File f = new File("D:/OA需求文档");
 
        Test03 t = new Test03(f);
 
        //打印指定目录，即最顶层目录
         System.out.println("目标目录："+f.getName());
 
        //开始遍历目录
         t.tree(f, 1);
         System.out.println("==============================");
         //打印目录数量和字节数
         System.out.println("这个目录中共:"+dirs+"个目录");
         //打印文件数量和字节数
         System.out.println("这个目录中有:"+files+"个文件"+"  "+"共"+dirLength+"字节");
         //System.out.println("==============================");
     }
 }
  

 
package others;
 
import java.io.*;
 
class FileSystem {
 
public static void main(String[] args) {
 
File f = new File("D:/new");// 指定文件位置
 
System.out.println(f.getName());// 打印在这个文件下地文件夹;
 
tree(f, 1);// 方法!进入子文件夹中 并打印子文件名
 
}
 
private static void tree(File f, int level) {
 
String preStr = "";// 缩进量
 
for (int i = 0; i < level; i++) {
 
if (i == level - 1)
 
preStr = preStr + "┗";
 
else
 
preStr = preStr + "*";// 级别 - 代表这个目下下地子文件夹
 
}
 
File[] childs = f.listFiles();// 返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中地文件
 
for (int i = 0; i < childs.length; i++) {
 
System.out.println(preStr + childs[i].getName());// 打印子文件地名字
 
if (childs[i].isDirectory())  { // 测试此抽象路径名表示地文件能否是一个目录
 
tree(childs[i], level + 1);
 
}// 假如子目录下还有子目录，递归子目录调用此方法
 
}
 
}
 
}

1.环境要求 jdk1.8，略懂lambda表达式的使用,熟悉使用 mybatisPlus框架
 
2.后台响应的数据格式
 
 
3.页面展示效果
 
 
4.代码实现方式
 4.1创建一个保存数据的实体对象
 /**
 
 
<一句话功能简述> 结果展示数据响应实体类型 <功能详细描述>
 
 
@author DENG
 
 
@version [版本号, 2018年11月21日]
 
 
@see [相关类/方法]
 
 
@since [产品/模块版本]
 */
 public class RespMenuScoreDto {
 
/**
 
  
指标名称
 */
 private String indexname;
 
/**
 
  
规则名称
 */
 private String rulename;
 
/**
 
  
指标值
 */
 private String indexval;
 
/**
 
  
指标ID
 */
 private String parentId;
 
/**
 
  
指标父级ID
 */
 private String parentIds;
 
/**
 
  
子级指标信息集合
 */
 private List respMenuScoreDtoList;
 
get和set方法省略
 }
 4.2查询数据库顶级数据
 /**
 
  
查询顶级数据
@author DENG
@param map
@return
 
*/
 private List queryTopData(Map<String, Object> map) {
 
 List<RespMenuScoreDto> list = new ArrayList<>();
 // 构造查询顶级数据条件
 EntityWrapper<RuleInfoIndexScore> ew = new EntityWrapper<RuleInfoIndexScore>();
 ew.eq("INDEXLEVEL", "1").eq("USER_ID", map.get("userId").toString())
 		.eq("RULENAME", map.get("ruleName").toString()).eq("SEMESTER", map.get("semester"));
 // 查询顶级 类型
 List<RuleInfoIndexScore> selectList = tRuleInfoIndexScoreService.selectList(ew);
 // 对象转换
 selectList.forEach(r -> {
 	RespMenuScoreDto rm = new RespMenuScoreDto();
 	BeanUtils.copyProperties(r, rm);
 	list.add(rm);
 });

 return list;
 
}
 4.3查询数据库非顶级数据
 /**
 
  
查询非顶级数据
@author DENG
@param map
@return
 
*/
 private List queryNotData(Map<String, Object> map) {
 
 List<RespMenuScoreDto> list = new ArrayList<>();
 // 构造查询非顶级数据条件
 EntityWrapper<RuleInfoIndexScore> ew2 = new EntityWrapper<RuleInfoIndexScore>();
 ew2.ne("INDEXLEVEL", "1").eq("USER_ID", map.get("userId").toString())
 		.eq("RULENAME", map.get("ruleName").toString()).eq("SEMESTER", map.get("semester"));
 // 查询 非 顶级 类型
 List<RuleInfoIndexScore> selectList = tRuleInfoIndexScoreService.selectList(ew2);
 // 数据对象转换
 selectList.forEach(r -> {
 	RespMenuScoreDto rm = new RespMenuScoreDto();
 	BeanUtils.copyProperties(r, rm);
 	list.add(rm);
 });

 return list;
 
}
 4.4构造数据结构关系
 /**
 
  
查询数据库树形结构数据并构造成树形数据
@author DENG
@param parameMap
@return 返回值
 
*/
 private List queryMenuData(Map<String, Object> parameMap) {
 
 // 查询顶级数据
 List<RespMenuScoreDto> queryTopData = queryTopData(parameMap);
 // 查询非顶级数据
 List<RespMenuScoreDto> queryNotData = queryNotData(parameMap);
 // 判断数据是否存在
 if (!NomalUtil.isNullOrEmpty(queryNotData)) {
 	// 过滤条件Map ，指定Map预期大小非顶级数据 集合size
 	Map<String, String> newHashMapWithExpectedSize = Maps.newHashMapWithExpectedSize(queryNotData.size());
 	// 循环顶级数据 插入子级数据
 	queryTopData.forEach(category -> facdeTree(category, queryNotData, 0, newHashMapWithExpectedSize));
 	// 返回结果集
 	return queryTopData;
 }
 // 返回null 数值 ，避免前台接收数据报错
 return new ArrayList<RespMenuScoreDto>();
 
}
 4.5递归数据
 /**
 
  
迭代插入子级数据
@author DENG
@param respMenuScoreDto 父级数据对象
@param queryNotData 所有子级数据集合
@param flag 迭代的 层级 数 （目录层数 为一层 值为 1 ，两层 值为2 ，以此类推 ，不知层 值为0）
@param map 预期的Map对象
 
*/
 private void facdeTree(RespMenuScoreDto respMenuScoreDto, List queryNotData, int flag,
 Map<String, String> map) {
 
 // 判断层级
 if (flag == 0) {
 	// 创建保存子级数据
 	List<RespMenuScoreDto> newArrayList = Lists.newArrayList();
 	// 遍历查找子级数据
 	queryNotData.stream().filter(c -> !map.containsKey(c.getParentId()))
 			.filter(c -> c.getParentIds().equals(respMenuScoreDto.getParentId())).forEach(c -> {
 				// 放入Map 集合，递归循环时可以跳过这个子级数据，提高执行效率
 				map.put(c.getParentId(), c.getParentIds());
 				// 获取当前目录的子级目录
 				facdeTree(c, queryNotData, flag, map);
 				// 加入子级数据到集合
 				newArrayList.add(c);
 			});
 	// 将子级数据set到父级数据中
 	respMenuScoreDto.setRespMenuScoreDtoList(newArrayList);
 }
 
}
 

是一种特殊结构的二叉树
 
二叉排序树（BinarySortTree），又称二叉查找树、二叉搜索树。
 
二叉搜索树需满足以下四个条件：
 
若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
任意节点的左、右子树也分别为二叉查找树；
没有键值相等的节点。
 
二叉排序树性质
 
按中序遍历二叉排序树，所得到的中序遍历序列是一个递增有序序列。
 
二叉搜索树就是具备上述四种性质的二叉树。 
 
 
下面进行的二叉排序树的增删改查操作都是基于节点Node中key的大小构建二叉排序树
 
二叉排序树的插入
 
在二叉排序树中插入新结点，要保证插入后的二叉树仍符合二叉排序树的定义。 　　 
 插入过程： 
 - 若二叉排序树为空，则待插入结点*S作为根结点插入到空树中； 
 - 当非空时，将待插结点关键字S->key和树根关键字t->key进行比较，若s->key = t->key,则无须插入，若s->key< t->key,则插入到根的左子树中，若s->key> t->key,则插入到根的右子树中。而子树中的插入过程和在树中的插入过程相同，如此进行下去，直到把结点*s作为一个新的树叶插入到二叉排序树中，或者直到发现树已有相同关键字的结点为止。 
 - 插入完成
 
二叉排序树的查找
 
假定二叉排序树的根结点指针为 root ，给定的关键字值为 K ，则查找算法可描述为：
 
① 置初值： q ＝ root ；
② 如果 K ＝ q －＞ key ，则查找成功，算法结束；
③ 否则，如果 K ＜ q －＞ key ，而且 q 的左子树非空，则将 q 的左子树根送 q ，转步骤②；否则，查找失败，结束算法；
④ 否则，如果 K ＞ q －＞ key ，而且 q 的右子树非空，则将 q 的右子树根送 q ，转步骤②；否则，查找失败，算法结束。
 
二叉排序树的删除
 
假设被删结点是*p，其双亲是*f，不失一般性，设*p是*f的左孩子，下面分三种情况讨论： 　　 
 - ⑴ 若结点*p是叶子结点，则只需修改其双亲结点*f的指针即可。 　 
 - ⑵ 若结点*p只有左子树PL或者只有右子树PR，则只要使PL或PR 成为其双亲结点的左子树即可。 　　 
 - ⑶ 若结点*p的左、右子树均非空，先找到*p的中序后继(或前驱)节点*s（注意*s是*p的右子树中的key最小的结点，它的左子树为空），然后步骤如下： 
 - 找到 *p 的节点的直接中序后继节点（即其右子树中key值最小的节点 ），并删除此直接中序后继节点。 
 - 将此后继节点的 key、value 值赋给待删除节点的 key，value值。
 
例如删除上图一中 key 值为 10 的节点，这时就需要用 key 值为 10 的节点的中序后继节点（节点 11）来代替 key 值为 10 的节点，并删除 key 值为 10 的节点的中序后继节点，由中序遍历相关规则可知， key 值为 10 的节点的直接中序后继节点一定是其右子树中 key 值最小的节点，所以此中序后继节点一定不含子节点或者只含有一个右孩子，删除此中序后继节点就属于上述 1,2 所述情况。图一中 key 值为 10 的节点的直接中序后继节点 为 11，节点 11 含有一个右孩子 12。
 
步骤：
 
a、找到 key 值为 10 的节点的直接中序后继节点（即其右子树中值最小的节点 11），并删除此直接中序后继节点。
 
b、将此后继节点的 key、value 值赋给待删除节点的 key，value值。
 
实例demo
 
节点类
 

package org.vincent.strategy.binarysearch;

class Node {
    int key;
    int value;
    Node leftChild;
    Node rightChild;

    public Node(int key, int value) {
        this.key = key;
        this.value = value;
        this.leftChild = null;
        this.rightChild = null;
    }

    public Node(int key, int value, Node leftChild, Node rightChild) {
        super();
        this.key = key;
        this.value = value;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
    }

    public Node() {

    }

    @Override
    public String toString() {
        return "Node [key=" + this.key + ", value=" + this.value + ", leftChild=" + this.leftChild + ", rightChild=" + this.rightChild + "]";
    }

    public int getKey() {
        return this.key;
    }

    public void setKey(int key) {
        this.key = key;
    }

    public int getValue() {
        return this.value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public Node getLeftChild() {
        return this.leftChild;
    }

    public void setLeftChild(Node leftChild) {
        this.leftChild = leftChild;
    }

    public Node getRightChild() {
        return this.rightChild;
    }

    public void setRightChild(Node rightChild) {
        this.rightChild = rightChild;
    }

}
 
二叉排序树接口方法
 

package org.vincent.strategy.binarysearch;

public abstract class AbsBinaryTree {
    public abstract Node find(int key);// 查找指定节点

    public abstract boolean update(int key, int value);

    public abstract void insert(int key, int value); // 插入节点

    public abstract boolean delete(int key); // 删除指定节点

    public abstract Node getDirectPostNode(Node delNode); // 得到待删除节点的直接后继节点

    public abstract void preOrder(Node rootNode); // 先序遍历树

    public abstract void inOrder(Node rootNode); // 中序遍历树

    public abstract void postOrder(Node rootNode); // 后序遍历树
}

 
二叉排序树具体实现
 

package org.vincent.strategy.binarysearch;

public class BinaryTree extends AbsBinaryTree {

    private Node root;

    public Node getRoot() {
        return this.root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    // 二叉排序树查找节点
    // 找到和key相等则返回相应节点，否则返回 null。
    @Override
    public Node find(int key) {
        // TODO Auto-generated method stub
        Node currentNode = this.root;
        // currentNode.key和 key不等才需要循环
        while ((currentNode != null) && (currentNode.key != key)) {
            if (key < currentNode.key) {
                currentNode = currentNode.leftChild;
            } else if (key > currentNode.key) {
                currentNode = currentNode.rightChild;
            }
        }
        return currentNode;

    }

    @Override
    public void insert(int key, int value) {
        // TODO Auto-generated method stub
        if (this.root == null) {
            this.root = new Node(key, value);
            return;
        }
        Node currentNode = this.root;
        Node parentNode = this.root;// 指向currentNode节点的父节点
        boolean isLeftChild = true;
        // 寻找插入位置
        while (currentNode != null) {
            parentNode = currentNode;
            if (key < currentNode.key) {
                currentNode = currentNode.leftChild;
                isLeftChild = true;
            } else if (key > currentNode.key) {
                currentNode = currentNode.rightChild;
                isLeftChild = false;
            } else {
                // 插入的节点key和二叉树中节点key相等无需插入
                // parentNode 和 currentNode两个引用指向相同Node对象，引用变量相等，只需要更改value
                break;
            }
        }
        // 插入节点
        if (parentNode != currentNode) {
            Node newNode = new Node(key, value);
            if (isLeftChild) {
                parentNode.leftChild = newNode;
            } else {
                parentNode.rightChild = newNode;
            }

        } else {
            // 如果待插入节点和二叉树中节点一样；则只要更改值
            currentNode.setValue(value);
        }
    }

    @Override
    public boolean delete(int key) {
        // TODO Auto-generated method stub
        Node currentNode = this.root;// 用来保存待删除节点
        Node parentNode = this.root;// 用来保存待删除节点的父亲节点
        boolean isLeftChild = true;// 用来保存待删除节点是父亲节点的左孩子还是右孩子
        // 寻找删除节点并记录删除节点的父节点以及他是父节点的左孩子还是右孩子
        while ((currentNode != null) && (currentNode.key != key)) {
            parentNode = currentNode;
            if (key < currentNode.key) {
                currentNode = currentNode.leftChild;
                isLeftChild = true;
            } else {
                currentNode = currentNode.rightChild;
                isLeftChild = false;
            }
        }
        if (currentNode == null) return false;// 空树
        // 要删除的节点为叶子节点，删除的第一种情况
        if ((currentNode.leftChild == null) && (currentNode.rightChild == null)) {
            if (currentNode == this.root) {
                this.root = null;
            } else if (isLeftChild) {
                parentNode.leftChild = null;
            } else {
                parentNode.rightChild = null;
            }
            // 要删除的节点只有左孩子 第二种情况
        } else if ((currentNode.rightChild == null) && (currentNode.leftChild != null)) {
            if (currentNode == this.root) {
                this.root = currentNode.leftChild;
            } else if (isLeftChild) {
                parentNode.leftChild = currentNode.leftChild;
            } else {
                parentNode.rightChild = currentNode.leftChild;
            }
            // 要删除的节点只有右孩子 第三种情况
        } else if ((currentNode.leftChild == null) && (currentNode.rightChild != null)) {
            if (currentNode == this.root) {
                this.root = currentNode.rightChild;
            } else if (isLeftChild) {
                parentNode.leftChild = currentNode.rightChild;
            } else {
                parentNode.rightChild = currentNode.rightChild;
            }
        } // 最后一种情况，待删除节点既有左子树又有右子树
        else {
            // 将待删除节点的右子树最小节点赋值给删除节点的key,value，那么删除后新的二叉树也是二叉排序树
            // 思路：删除右子树中key值最小的节点，并返回，然后用这个节点的值赋值删除节点的key和value
            // 右子树中key最小的节点一定不含左子树,所以删除这个key最小的节点一定是属于叶子节点或者只有右子树的节点
            Node directPostNode = this.getDirectPostNode(currentNode);
            currentNode.key = directPostNode.key;
            currentNode.value = directPostNode.value;
        }

        return true;
    }

    // 获取到待删除节点的中序直接后继节点。将该后继节点从二叉树中删除并返回
    @Override
    public Node getDirectPostNode(Node delNode) {
        // TODO Auto-generated method stub
        // 方法作用为得到待删除节点的直接后继节点

        Node parentNode = delNode;// 用来保存待删除节点的直接后继节点的父亲节点
        Node direcrPostNode = delNode;// 用来保存待删除节点的直接后继节点
        Node currentNode = delNode.rightChild;// 待删除节点右子树
        while (currentNode != null) {
            parentNode = direcrPostNode;
            direcrPostNode = currentNode;
            currentNode = currentNode.leftChild;
        }
        if (direcrPostNode != delNode.rightChild) {// 从树中删除此直接后继节点
            parentNode.leftChild = direcrPostNode.rightChild;// 后继节点的父节点指向后继节点的右孩子
            direcrPostNode.rightChild = null;// 直接后继节点右孩子为空
        }
        return direcrPostNode;// 返回此直接后继节点
    }

    @Override
    public void preOrder(Node rootNode) {
        // TODO Auto-generated method stub
        if (rootNode != null) {
            System.out.println(rootNode.key + " " + rootNode.value);
            this.preOrder(rootNode.leftChild);
            this.preOrder(rootNode.rightChild);
        }
    }

    @Override
    public void inOrder(Node rootNode) {
        // TODO Auto-generated method stub
        if (rootNode != null) {
            this.inOrder(rootNode.leftChild);
            System.out.println(rootNode.key + " " + rootNode.value);
            this.inOrder(rootNode.rightChild);
        }
    }

    @Override
    public void postOrder(Node rootNode) {
        // TODO Auto-generated method stub
        if (rootNode != null) {
            this.postOrder(rootNode.leftChild);
            this.postOrder(rootNode.rightChild);
            System.out.println(rootNode.key + " " + rootNode.value);
        }
    }

    /**
     * // 基于二叉排序树查找find查找节点，然后通过Node的setValue将新值赋值过去。
     */
    @Override
    public boolean update(int key, int value) {
        // TODO Auto-generated method stub
        Node node = this.find(key);
        node.setValue(value);
        return true;
    }

}
 
测试用例
 
package org.vincent.strategy.binarysearch;

public class BinaryTreeTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BinaryTree tree = new BinaryTree();
        tree.insert(6, 6);// 插入操作,构造图一所示的二叉树
        tree.insert(3, 3);
        tree.insert(14, 14);
        tree.insert(16, 16);
        tree.insert(10, 10);
        tree.insert(9, 9);
        tree.insert(13, 13);
        tree.insert(11, 11);
        tree.insert(12, 12);
        System.out.println("删除前中序遍历结果，结果是一个递增有序序列");
        tree.inOrder(tree.getRoot());// 中序遍历操作
        tree.update(12, 200);
        System.out.println("更新节点值中序遍历结果  key=12的值");
        tree.inOrder(tree.getRoot());
        System.out.println("删除节点10之后遍历结果");

        tree.delete(10);// 删除操作
        tree.inOrder(tree.getRoot());
    }

}

 
参考文献：
 
参考博文
 
Java二叉排序树