JTable表头合并实现-优快云博客

转载: 表头合并单元格. JTable Groupable TableHeader

http://blog.youkuaiyun.com/bradwoo8621/article/details/1541835

表头合并单元格. 照例不多说了, 看代码吧.
首先需要定义一个接口, 看看表头是怎么合并的
package jtble;

/**
* 列头组
*/
public interface Group {
/**
* 获取所在行
*
* @return
*/
public int getRow();

/**
* 获取所在列
*
* @return
*/
public int getColumn();

/**
* 获取占列个数
*
* @return
*/
public int getColumnSpan();

/**
* 获取占行个数
*
* @return
*/
public int getRowSpan();

/**
* 获取文字
*
* @return
*/
public Object getHeaderValue();
}

这个和HTML的写法其实一样的. 主要就是每个Cell所在的位置, 占的行列数以及

文字.
接下来是一个默认的实现. 其实不写接口也可以, 因为通常不会对表头做动作的.
package jtble;

/**
* 默认Group实现
*/
public class DefaultGroup implements Group {
private int row = 0;

private int column = 0;

private int rowSpan = 1;

private int columnSpan = 1;

private Object headerValue = null;

/**
* @see com.eplat.realty.view.component.table.Group#getRow()
*/
public int getRow() {
return this.row;
}

/**
* @param row
* 要设置的 row。
*/
public void setRow(int row) {
this.row = row;
}

/**
* @see com.eplat.realty.view.component.table.Group#getColumn()
*/
public int getColumn() {
return this.column;
}

/**
* @param column
* 要设置的 column。
*/
public void setColumn(int column) {
this.column = column;
}

/**
* @see

com.eplat.realty.view.component.table.Group#getColumnSpan()
*/
public int getColumnSpan() {
return this.columnSpan;
}

/**
* @param columnSpan
* 要设置的 columnSpan。
*/
public void setColumnSpan(int columnSpan) {
this.columnSpan = columnSpan;
}

/**
* @see com.eplat.realty.view.component.table.Group#getRowSpan

()
*/
public int getRowSpan() {
return this.rowSpan;
}

/**
* @param rowSpan
* 要设置的 rowSpan。
*/
public void setRowSpan(int rowSpan) {
this.rowSpan = rowSpan;
}

/**
* @see

com.eplat.realty.view.component.table.Group#getHeaderValue()
*/
public Object getHeaderValue() {
return this.headerValue;
}

/**
* @param headerValue
* 要设置的 headerValue。
*/
public void setHeaderValue(Object headerValue) {
this.headerValue = headerValue;
}
}

重写一个表头组件
package jtble;

import java.awt.Component;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JTable;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumnModel;

/**
* 可以合并的列头
*/
@SuppressWarnings("serial")
public class GroupableTableHeader extends JTableHeader {
private int rowCount = 0;

private int columnCount = 0;

private List<Group> groups = new ArrayList<Group>();

public GroupableTableHeader() {
// 这个是必须的, 因为如果可以拖动列的位置, 那么一切都完

蛋了.
// 如果你想实现这个功能, 那么只能你自己去做了, 我可不想

做这个, 看上去超烦的
this.setReorderingAllowed(false);
}

/**
* @see javax.swing.table.JTableHeader#updateUI()
*/
@Override
public void updateUI() {
setUI(new GroupableTableHeaderUI());
}

/**
* 获取指定行列的位置
*/
public Rectangle getHeaderRect(int row, int column) {
Rectangle r = new Rectangle();
TableColumnModel cm = getColumnModel();

Group group = this.getGroup(row, column);
r.height = getHeight();

if (column < 0) {
 // x = width = 0;
 if (!getComponentOrientation().isLeftToRight()) {
 r.x = getWidthInRightToLeft();
 }
 } else if (column >= cm.getColumnCount()) {
 if (getComponentOrientation().isLeftToRight()) {
 r.x = getWidth();
 }
 } else {
 for (int i = 0; i < group.getColumn(); i++) {
 r.x += cm.getColumn(i).getWidth();
 }
 for (int i = group.getColumn(), j =

group.getColumn() +

group.getColumnSpan() - 1; i < j; i++) {
 r.width += cm.getColumn(i).getWidth();
 }
 if (!getComponentOrientation().isLeftToRight()) {
 r.x = getWidthInRightToLeft() - r.x -

r.width;
   }
   // r.width = cm.getColumn(column).getWidth();
  }
  return r;
}

/**
* 获取Group的Y位置
*
* @param group
* @return
*/
public int getYOfGroup(Group group) {
  int row = group.getRow();
  TableCellRenderer renderer = this.getDefaultRenderer();
  Component comp =

renderer.getTableCellRendererComponent(getTable

(), group.getHeaderValue(), false, false, group.getRow(),

group
.getColumn());
return row * comp.getPreferredSize().height;
}

/**
* 获取Group的高度
*
* @param group
* @return
*/
public int getHeightOfGroup(Group group) {
  int rowSpan = group.getRowSpan();
  TableCellRenderer renderer = this.getDefaultRenderer();
  Component comp =

renderer.getTableCellRendererComponent(getTable

(), group.getHeaderValue(), false, false, group.getRow(),

group
.getColumn());
return rowSpan * comp.getPreferredSize().height;
}

private int getWidthInRightToLeft() {
if ((table != null) && (table.getAutoResizeMode() !=

  JTable.AUTO_RESIZE_OFF)) {
   return table.getWidth();
  }
  return super.getWidth();
}

/**
* 增加Group
*
* @param group
*/
public void addGroup(Group group) {
  groups.add(group);
  int row = group.getRow();
  int rowSpan = group.getRowSpan();
  rowCount = Math.max(rowCount, row + rowSpan);
  int column = group.getColumn();
  int columnSpan = group.getColumnSpan();
  columnCount = Math.max(columnCount, column +

columnSpan);
}

/**
* 移除所有Group
*/
public void removeAllGroups() {
groups.clear();
}

/**
* 获取所有的Group
*
* @return
*/
public List<Group> getGroups() {
 List<Group> list = new ArrayList<Group>();
 list.addAll(groups);
 return list;
}

/**
* 获取指定列上的Group
*
* @param columnIndex
* @return
*/
public List<Group> getGroupsAtColumn(int columnIndex) {
 List<Group> list = new ArrayList<Group>();
 for (Group group : groups) {
 int minColumnIndex = group.getColumn();
 int maxColumnIndex = minColumnIndex +

group.getColumnSpan() -

1;
if (minColumnIndex <= columnIndex &&

maxColumnIndex >=

   columnIndex) {
    list.add(group);
   }
  }
  return list;
}

/**
* 获取指定行上的所有Group
*
* @param rowIndex
* @return
*/
public List<Group> getGroupsAtRow(int rowIndex) {
 List<Group> list = new ArrayList<Group>();
 for (Group group : groups) {
 int minRowIndex = group.getRow();
 int maxRowIndex = minRowIndex +

group.getRowSpan() - 1;
if (minRowIndex <= rowIndex && maxRowIndex

>= rowIndex) {
    list.add(group);
   }
  }
  return list;
}

/**
* 获取行数
*
* @return
*/
public int getRowCount() {
return this.rowCount;
}

/**
* @return Returns the columnCount.
*/
public int getColumnCount() {
return this.columnCount;
}

/**
* @see javax.swing.table.JTableHeader#setTable

(javax.swing.JTable)
*/
@Override
public void setTable(JTable table) {
super.setColumnModel(table.getColumnModel());
super.setTable(table);
}

/**
* 获取指定行列的Group
*
* @param row
* @param column
* @return
*/
public Group getGroup(int row, int column) {
 for (Group group : groups) {
 int rowIndex = group.getRow();
 int columnIndex = group.getColumn();
 int rowSpan = group.getRowSpan();
 int columnSpan = group.getColumnSpan();
 if (rowIndex <= row && rowIndex + rowSpan >

row &&

columnIndex <= column && columnIndex +

columnSpan > column)
    return group;
  }
  return null;
}

/**
* @see javax.swing.table.JTableHeader#createDefaultRenderer()
*/
@Override
protected TableCellRenderer createDefaultRenderer() {
return new TableHeaderRenderer();
}
}

常量类:
package jtble;

public class Constants {

static int TABLE_ROW_HEIGHT = 20;
}

里面用到的TableHeaderRenderer, 没什么花头的, 贴出来看看
package jtble;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.io.Serializable;

import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.UIManager;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;

/**
* 表头描述器
*/
@SuppressWarnings("serial")
public class TableHeaderRenderer extends JLabel implements

TableCellRenderer,
  Serializable {
/**
* Creates a default table cell renderer.
*/
public TableHeaderRenderer() {
  setOpaque(true);
  setHorizontalAlignment(JLabel.CENTER);
}

// implements javax.swing.table.TableCellRenderer
/**
* Returns the default table cell renderer.
*
* @param table
* the <code>JTable</code>
* @param value
* the value to assign to the cell at <code>[row, column]

</code>
* @param isSelected
* true if cell is selected
* @param hasFocus
* true if cell has focus
* @param row
* the row of the cell to render
* @param column
* the column of the cell to render
* @return the default table cell renderer
*/
public Component getTableCellRendererComponent(JTable table,

Object value,
boolean isSelected, boolean hasFocus, int row,

int column) {

  if (table != null) {
   JTableHeader header = table.getTableHeader();
   if (header != null) {
    setForeground(header.getForeground

());
setBackground(header.getBackground

());
    setFont(header.getFont());
   }
  }

setBorder(UIManager.getBorder

("TableHeader.cellBorder"));

setValue(value);

Dimension dim = getPreferredSize();
 if (dim.height < Constants.TABLE_ROW_HEIGHT)
 setPreferredSize(new Dimension

(getPreferredSize().width,

Constants.TABLE_ROW_HEIGHT));
return this;
}

/*
* The following methods are overridden as a performance measure

to to prune
* code-paths are often called in the case of renders but which we

know are
* unnecessary. Great care should be taken when writing your own

renderer to
* weigh the benefits and drawbacks of overriding methods like

these.
*/