sheadertree.java

JTable复杂表头的实现代码 JTable复杂表头的实现代码

package cn.com.table;

import java.util.Vector;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.JTable;
import javax.swing.table.TableColumnModel;

/**
 *
 * <p>Title: </p>
 * <p>表头的树状结构</p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author
 * @version 1.0
 */
public class SHeaderTree {
  /* 叶子节点列表 */
  Vector leafList;
  /* 根节点 */
  DefaultMutableTreeNode root;

  /**
   * 构造方法，生成一个根节点以及叶子节点的列表
   * @param name String
   */
  public SHeaderTree(String name) {
    root = new DefaultMutableTreeNode(name);
    leafList = new Vector();
  }
  /**
   * 取得根节点
   * @return DefaultMutableTreeNode
   */
  public DefaultMutableTreeNode getRoot() {
    return root;
  }
  /**
   * 设置根节点
   * @param root DefaultMutableTreeNode
   */
  public void setRoot(DefaultMutableTreeNode root) {
    this.root = root;
  }
  /**
   * 根据传入的字符串参数到所有的表头节点数据
   * @param header String
   * @return Node[]
   */
  private Node[] getNode(String header) {
    Node[] node = null;
    if (header == null || header.trim().equals("")) return null;
    int count = 0;
    for (int i = 0; i < header.length(); i++) {
      if (header.charAt(i) == '|') count++;
    }
    if (count == 0) return null;
    node = new Node[count];
    int from = 0;
    count = 0;
    for (int i = 0; i < header.length(); i++) {
      if (header.charAt(i) == '|') {
        String s = header.substring(from, i);
        String[] temp = new String[3];
        int tempCount = 0;
        int tempFrom = 0;
        for (int j = 0; j < s.length(); j++) {
          if (s.charAt(j) == ':') {
            temp[tempCount++] = s.substring(tempFrom, j);
            tempFrom = j + 1;
          }
        }
        temp[tempCount] = s.substring(tempFrom);
        node[count] = new Node();
        node[count].setIndex(Integer.parseInt(temp[0]));
        node[count].setParent(Integer.parseInt(temp[1]));
        node[count].setName(temp[2]);
        count++;
        from = i+1;
      }
    }
    return node;
  }
  /**
   * 生成表头的树状结构
   * @param header String
   */
  public void setRoot(String header) {
    Node[] node = getNode(header);
    if (node == null) return;
    Vector vec = new Vector();
    root = new DefaultMutableTreeNode("根");
    vec.add(root);
    for (int i = 0; i < node.length; i++) {
      int parent = node[i].getParent();
      DefaultMutableTreeNode leaf = new DefaultMutableTreeNode();
      leaf.setUserObject(node[i].getName());
      ((DefaultMutableTreeNode)vec.get(parent+1)).add(leaf);
      vec.add(leaf);
    }
  }
  /**
   * 取得叶子节点列表
   * @return Vector
   */
  public Vector getLeafList() {
    leafList = new Vector();
    leaf(root);
    return leafList;
  }
  /**
   * 设置叶子节点列表
   * @param root DefaultMutableTreeNode
   */
  private void leaf(DefaultMutableTreeNode root) {
    if (root == null) return;
    if (root.isLeaf()) leafList.add(root);
    for (int i = 0; i < root.getChildCount(); i++) {
      leaf((DefaultMutableTreeNode)root.getChildAt(i));
    }
  }
  /**
   * 得到表头的列组合
   * @param table JTable
   * @return Vector
   */
  public Vector getColumnGroupS(JTable table) {
    Vector vec = new Vector();
    if (root == null || root.isLeaf()) return vec;
    TableColumnModel cm = table.getColumnModel();
    int childCount = root.getChildCount();
    for (int i1 = 0; i1 < childCount; i1++) {
      if (!root.getChildAt(i1).isLeaf()) {
        DefaultMutableTreeNode node = (DefaultMutableTreeNode)root.getChildAt(i1);
        ColumnGroup columnGroup = new ColumnGroup(node.getUserObject().toString());
        vec.add(columnGroup);
        Vector vNode = new Vector();
        Vector vGroup = new Vector();
        vNode.add(node);
        vGroup.add(columnGroup);
        while(vNode.size() > 0) {
          DefaultMutableTreeNode n = (DefaultMutableTreeNode)vNode.get(0);
          ColumnGroup column = (ColumnGroup)vGroup.get(0);
          vNode.remove(0);
          vGroup.remove(0);
          for (int j = 0; j < n.getChildCount(); j++) {
            DefaultMutableTreeNode nodej = (DefaultMutableTreeNode)n.getChildAt(j);
            if (nodej.isLeaf()) {
              leafList = this.getLeafList();
              for (int i2 = 0; i2 < leafList.size(); i2++) {
                if (nodej == (DefaultMutableTreeNode)leafList.get(i2)) column.add(cm.getColumn(i2));
              }
            } else {
              ColumnGroup columnGroupj = new ColumnGroup(nodej.getUserObject().toString());
              column.add(columnGroupj);
              vGroup.add(columnGroupj);
              vNode.add(nodej);
            }
          }

        }
      }
    }
    return vec;
  }
  /**
   * 把表头的树状结构转换成字符串
   * @return String
   */
  public String toString() {
    String treeString = "";
    Vector queue = new Vector();
    queue.add(root);
    int index = 0;
    int nodeSum = 0;
    while (index <= nodeSum) {
      DefaultMutableTreeNode parent = (DefaultMutableTreeNode)queue.get(index);
      if (parent != null || !parent.isLeaf()) {
        int childCount = parent.getChildCount();
        DefaultMutableTreeNode node;
        for (int i = 0; i < childCount; i++) {
          node = (DefaultMutableTreeNode)parent.getChildAt(i);
          String name = (String)node.getUserObject();
          System.out.print(name + ",");
          treeString+=nodeSum + ":" + (index-1) + ":" + name + "|";
          nodeSum++;
          queue.add(node);
        }
      }
      index++;
    }
    return treeString;
  }
}
/**
 *
 * <p>Title: 合生创展</p>
 * <p>节点的结构</p>
 * <p>Copyright: Copyright (c) 2001</p>
 * <p>Company: 东软股份</p>
 * @author 王迎彬
 * @version 1.0
 */
class Node {
  /* 节点的索引 */
  private int index;
  /* 父节点的索引 */
  private int parent;
  /* 节点的信息 */
  private String name;
  public int getIndex() {
    return index;
  }
  public int getParent() {
    return parent;
  }
  public String getName() {
    return name;
  }
  public void setIndex(int index) {
    this.index = index;
  }
  public void setParent(int parent) {
    this.parent = parent;
  }
  public void setName(String name) {
    this.name = name;
  }
}