一个JTree的Model

自从去年的JTree后，这一段时间对JTree又研究了一下。这次的方向是树的数据模型的生成。能够创建一个较为通用的树模型。

 

package  commonUtil;

import  java.util.ArrayList;
import  java.util.HashMap;
import  java.util.List;
import  java.util.Map;

import  javax.swing.tree.DefaultMutableTreeNode;

public   class  TreeNode  ... {

    /** *//**
     * 解析编码规则，例如：2-2-2<p>
     * @param String 2-2-2
     * @return int[] { 2，4，6 }
     * */
    public static int[] getRule(String rule) ...{
        String[] strRule = rule.split("-");
        int[] intRule = new int[strRule.length];
        for( int i = 0 ; i < strRule.length ; i++ ) ...{
            if( i == 0 )
                intRule[i] = Integer.parseInt(strRule[i]);
            else
                intRule[i] = intRule[i - 1] + Integer.parseInt(strRule[i]);
        }
        return intRule;
    }
    
    /** *//**
     * 获取父级Code<p>
     * @param code 子接口点code 如：01、11
     * @param int[] intNode 解析后的编码规则数组
     * @return 父节点code 如：01、12
     * */
    public static String getFatherCode(String code,int[] intNode) ...{
        //int[] intNode = getRule(rule);
        int codeSize = code.length();
        //一级节点没有父节点，因此i从1开始
        for( int i = 1 ; i < intNode.length ; i++ ) ...{
            if( intNode[i] == codeSize ) ...{
                return code.substring( 0 , codeSize - (intNode[i] - intNode[i - 1]));
            }
        }
        return "";
    }
    
    /** *//**
     * 构建树节点信息，方便主方法生成树的时候调用<p>
     * @param treeList 传入的数据列表，其中每个单元都是HashMap对象，
     *                  对象中都有name和code的对象。
     * @param rule 传入构建树的规则，如"2-2-2"
     * @return 返回构建好的树节点信息
     * */
    public static Map createTreeNodeInfo(List treeList,String rule)...{
        
        //初始化编码规则
        if( isNull(rule) == true )
            rule = "2-2-2";
        //获得解析后的编码规则
        int[] intNode = getRule(rule);
        //队列大小
        int treeSize = treeList.size();
        
        //数据
        Map data = new HashMap();
        List list = new ArrayList();
        String code = "";
        String codeName = "";
        String fatherCode = "";
        //node哈希表
        Map node = new HashMap();
        
        for( int i = 0 ; i < treeSize ; i++ )...{
            data = new HashMap();
            data = (Map)treeList.get(i);
            list = new ArrayList();
            //数据名称
            codeName = (String)data.get("name");
            //数据code
            code = (String)data.get("code");
            //父级code
            fatherCode = getFatherCode(code,intNode);
            
            list.add(code);
            list.add(codeName);
            list.add(fatherCode);  
            node.put(code,list);
        }
        
        return node;
    }
    
    /** *//**
     * 创建辅助录入树的数据模型，这个方法是对外使用的主方法。创建树调用此方法即可<p>
     * @param treeList 传入的数据列表，其中每个单元都是HashMap对象，
     *                  对象中都有name和code的对象。
     * @param rule 传入构建树的规则，如"2-2-2"
     * @return DefaultMutableTreeNode 返回树模型
     * */
    public static DefaultMutableTreeNode createTreeNode(List treeList,String rule)...{
        //创建根节点
        DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode("我的树");
        //根据传入的数据列表，生成节点数据，为生成树做准备
        Map node = createTreeNodeInfo(treeList,rule);
        //读取数据列表的大小
        int listSize = treeList.size();
        //创建树节点，并初始化
        DefaultMutableTreeNode treeNode = new DefaultMutableTreeNode();
        //创建树节点哈希表，存放树节点数据
        Map treeNodes = new HashMap();
        //list循环使用节点
        List list = new ArrayList();
        //创建Map对象，为数据列表中每一条数据使用
        Map data = new HashMap();
        //节点编码、节点名称、节点父级编码
        String[] code = new String[listSize];
        String[] codeName = new String[listSize];
        String[] fatherCode = new String[listSize];
        
        //循环生成树节点
        for( int i = 0 ; i < listSize ; i++ ) ...{
            data = new HashMap();
            data = (Map)treeList.get(i);
            list = (List)node.get(data.get("code"));
            code[i] = (String)list.get(0);
            codeName[i] = (String)list.get(1);
            fatherCode[i] = (String)list.get(2);
            treeNodes.put(code[i],new DefaultMutableTreeNode(code[i] + " " + codeName[i]));
        }
        
        //根据父子关系，生成完整的树
        for( int i = 0 ; i < listSize ; i++ ) ...{
            treeNode = (DefaultMutableTreeNode)treeNodes.get(code[i]);
            if( isNull(fatherCode[i]) == true ) ...{
                rootNode.add(treeNode);
            } else ...{
                ((DefaultMutableTreeNode)treeNodes.get(fatherCode[i])).add(treeNode);
            }            
        }
        
        return rootNode;
    }
    
    /** *//**
     * 验证传入的对象是否为空
     * @param obj 传入Object对象
     * @return true 是空值 false 不是空值
     * */
    public static boolean isNull(Object obj) ...{
        if(obj == null)
            return true;
        else if("".equals(obj) == true)
            return true;
        else if("null".equals(obj) == true)
            return true;
        return false;
    }
}

 下面是调用方法：

 

JTree tree  =   new  JTree();
List list  =  service.getList();
String strRule  =   " 2-2-2 " ;
tree.setModel( new  DefaultTreeModel(TreeNode.createTreeNode(list,strRule)));