Java 如何在jtable单元格中换行？
我正在尝试实现一个自定义TableRenderer，如中所述。 我想让渲染器对给定单元格的每个文本换行。 其思想是，使用TextArea作为渲染器，因为它支持换行。但是，以下代码的行为不符合预期：Java 如何在jtable单元格中换行？,java,swing,jtable,Java,Swing,Jtable,我正在尝试实现一个自定义TableRenderer，如中所述。 我想让渲染器对给定单元格的每个文本换行。 其思想是，使用TextArea作为渲染器，因为它支持换行。但是，以下代码的行为不符合预期： public class LineWrapCellRenderer extends JTextArea implements TableCellRenderer { @Override public Component getTableCellRendererComponent(
public class LineWrapCellRenderer extends JTextArea implements TableCellRenderer {
@Override
public Component getTableCellRendererComponent(
JTable table,
Object value,
boolean isSelected,
boolean hasFocus,
int row,
int column) {
this.setText((String)value);
this.setWrapStyleWord(true);
this.setLineWrap(true);
return this;
}
}
table.setDefaultRenderer(String.class, new LineWrapCellRenderer());
this.setBackground（Color.YELLOW）getTableCellRenderComponent（）GetTableCellRenderComponent（）您可以使用JLabel作为渲染器，将文本插入HTML标记，然后在适当的地方添加
问题在于JTable中的行高度是固定的，因此不仅仅是有一个包装的渲染器；我不知道为什么它没有，但如果它有，包装的文本将被裁剪-或者可能这正是你所看到的。要调整行高，您需要单独设置它们。您好，我也遇到了同样的问题，但我实现的解决方案受到了Java教程中绘制多行文本和使用文本API在单元格上绘制文本的示例的启发
用HTML编写标题。这是一个例子，我有。我遇到的唯一问题是，如果我调整标题的高度，我很难让它们在
JPanel myTable.getColumnModel().getColumn(1).setPreferredWidth(75);
myTable.getColumnModel().getColumn(1).setHeaderValue("<html><b>Day Of<br>Week</b></html>");
myTable.getColumnModel（）.getColumn（1）.setPreferredWidth（75）；
myTable.getColumnModel（）.getColumn（1）.setHeaderValue（“周中的一天”）；
setBoundsimport java.awt.*；
导入java.io.*；
导入java.util.*；
导入javax.swing.*；
导入javax.swing.event.*；
导入javax.swing.table.*；
公共类MultiWrapColDemo{
公共静态void main（字符串[]args）引发FileNotFoundException{
invokeLater（新的ShowIt（））；
}
}
类ShowIt实现可运行{
@凌驾
公开募捐{
JTable table=新的JTable（）；
table.getColumnModel（）.addColumnModelListener（新的WrapColListener（表））；
setDefaultRenderer（Object.class，新的JTPRenderer（））；
//示例：
//表.设置单元间距（新尺寸（40,20））；
//表.设置单元间距（新尺寸（4,2））；
向量数据向量=新向量（）；
String lorem1=“Lorem ipsum door sit amet，concetetur adipising elit，sed do eiusmod temporal incidedut ut laboure”；
字符串lorem2=“这是一个巨大的挑战，但在最小限度内，我们必须在公共事务中履行自己的职责。在法律上，两人或两人之间的冲突是不公平的，但在某些情况下，不可轻视，不可推卸责任。”；
对于（int i=0；i<12；i++）{
向量行=空；
如果（i%4==0）{
行=新向量（Arrays.asList（新字符串[]{“iggle”，lorem1，“poggle”，“poke”}）；
}else if（i%4==1）{
行=新向量（Arrays.asList（新字符串[]{lorem2，“piggle”，“poggle”，lorem1}））；
}else if（i%4==2）{
行=新向量（Arrays.asList（新字符串[]{lorem1，“piggle”，lorem2，“poke”}）；
}否则
行=新向量（Arrays.asList（新字符串[]{“iggle”，lorem2，“poggle”，lorem2}））；
dataVector.add（行）；
}
Vector columnIdentifiers=新向量（Arrays.asList）（新字符串[]{“iggle”、“piggle”、“poggle”，
“戳”}）；
table.getTableHeader（）.setFont（table.getTableHeader（）.getFont（）.deriveFont（20f）.deriveFont（Font.BOLD））；
（（DefaultTableModel）table.getModel（））.setDataVector（dataVector，columnIdentifiers）；
JFrame frame=新JFrame（“多WrapColtable”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
JScrollPane jsp=新的JScrollPane（表）；
frame.getContentPane（）.add（jsp）；
frame.pack（）；
机架立根（50、50、800、500）；
frame.setVisible（true）；
}
}
//如果列（或整个表）上的呈现器不是JTextComponent，则计算其preferredSize将不起作用
//任何包装…但它不会造成任何伤害。。。。
类JTPRenderer扩展了JTextPane，实现了TableCellRenderer{
@凌驾
公共组件GetTableCellRenderComponent（JTable表、对象值、布尔isSelected、布尔hasFocus、，
整数行，整数列）{
setText（value.toString（））；
归还这个；
}
}
类WrapColListener实现TableColumnModelListener{
JTable m_表；
WrapColListener（JTable表格）{
m_表=表；
}
无效刷新\行\高度（）{
int n_rows=m_table.getRowCount（）；
int n_cols=m_table.getColumnCount（）；
int intercell_width=m_table.getIntercellSpacing（）.width；
int intercell_height=m_table.getIntercellSpacing（）.height；
TableColumnModel col_model=m_table.getColumnModel（）；
//这些空检查是由于并发性的考虑…在更改列间距之间可能会有很大的变化
//事件和刷新\u row\u hei的调用
import java.awt.Component;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.font.FontRenderContext;
import java.awt.font.LineBreakMeasurer;
import java.awt.font.TextLayout;
import java.text.AttributedCharacterIterator;
import java.text.AttributedString;
import java.text.BreakIterator;
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
public class MultilineTableCell
implements TableCellRenderer {
class CellArea extends DefaultTableCellRenderer {
/**
*
*/
private static final long serialVersionUID = 1L;
private String text;
protected int rowIndex;
protected int columnIndex;
protected JTable table;
protected Font font;
private int paragraphStart,paragraphEnd;
private LineBreakMeasurer lineMeasurer;
public CellArea(String s, JTable tab, int row, int column,boolean isSelected) {
text = s;
rowIndex = row;
columnIndex = column;
table = tab;
font = table.getFont();
if (isSelected) {
setForeground(table.getSelectionForeground());
setBackground(table.getSelectionBackground());
}
}
public void paintComponent(Graphics gr) {
super.paintComponent(gr);
if ( text != null && !text.isEmpty() ) {
Graphics2D g = (Graphics2D) gr;
if (lineMeasurer == null) {
AttributedCharacterIterator paragraph = new AttributedString(text).getIterator();
paragraphStart = paragraph.getBeginIndex();
paragraphEnd = paragraph.getEndIndex();
FontRenderContext frc = g.getFontRenderContext();
lineMeasurer = new LineBreakMeasurer(paragraph,BreakIterator.getWordInstance(), frc);
}
float breakWidth = (float)table.getColumnModel().getColumn(columnIndex).getWidth();
float drawPosY = 0;
// Set position to the index of the first character in the paragraph.
lineMeasurer.setPosition(paragraphStart);
// Get lines until the entire paragraph has been displayed.
while (lineMeasurer.getPosition() < paragraphEnd) {
// Retrieve next layout. A cleverer program would also cache
// these layouts until the component is re-sized.
TextLayout layout = lineMeasurer.nextLayout(breakWidth);
// Compute pen x position. If the paragraph is right-to-left we
// will align the TextLayouts to the right edge of the panel.
// Note: this won't occur for the English text in this sample.
// Note: drawPosX is always where the LEFT of the text is placed.
float drawPosX = layout.isLeftToRight()
? 0 : breakWidth - layout.getAdvance();
// Move y-coordinate by the ascent of the layout.
drawPosY += layout.getAscent();
// Draw the TextLayout at (drawPosX, drawPosY).
layout.draw(g, drawPosX, drawPosY);
// Move y-coordinate in preparation for next layout.
drawPosY += layout.getDescent() + layout.getLeading();
}
table.setRowHeight(rowIndex,(int) drawPosY);
}
}
}
public Component getTableCellRendererComponent(
JTable table, Object value,boolean isSelected, boolean hasFocus, int row,int column
)
{
CellArea area = new CellArea(value.toString(),table,row,column,isSelected);
return area;
}
}
final int wordWrapColumnIndex = ...;
myTable = new JTable() {
public TableCellRenderer getCellRenderer(int row, int column) {
if (column == wordWrapColumnIndex ) {
return wordWrapRenderer;
}
else {
return super.getCellRenderer(row, column);
}
}
};
myTable.getColumnModel().getColumn(1).setPreferredWidth(75);
myTable.getColumnModel().getColumn(1).setHeaderValue("<html><b>Day Of<br>Week</b></html>");
import java.awt.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
public class MultiWrapColDemo {
public static void main(String[] args) throws FileNotFoundException {
EventQueue.invokeLater(new ShowIt());
}
}
class ShowIt implements Runnable {
@Override
public void run() {
JTable table = new JTable();
table.getColumnModel().addColumnModelListener( new WrapColListener( table ) );
table.setDefaultRenderer( Object.class, new JTPRenderer() );
// examples:
// table.setIntercellSpacing( new Dimension( 40, 20 ));
// table.setIntercellSpacing( new Dimension( 4, 2 ));
Vector<Vector<String>> dataVector = new Vector<Vector<String>>();
String lorem1 = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore";
String lorem2 = "et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum";
for (int i = 0; i < 12; i++) {
Vector<String> row = null;
if (i % 4 == 0) {
row = new Vector<String>(Arrays.asList(new String[] { "iggle", lorem1, "poggle", "poke" }));
} else if (i % 4 == 1) {
row = new Vector<String>(Arrays.asList(new String[] { lorem2, "piggle", "poggle", lorem1 }));
} else if (i % 4 == 2) {
row = new Vector<String>(Arrays.asList(new String[] { lorem1, "piggle", lorem2, "poke" }));
} else
row = new Vector<String>(Arrays.asList(new String[] { "iggle", lorem2, "poggle", lorem2 }));
dataVector.add(row);
}
Vector<String> columnIdentifiers = new Vector<String>(Arrays.asList(new String[] { "iggle", "piggle", "poggle",
"poke" }));
table.getTableHeader().setFont(table.getTableHeader().getFont().deriveFont(20f).deriveFont(Font.BOLD));
((DefaultTableModel) table.getModel()).setDataVector(dataVector, columnIdentifiers);
JFrame frame = new JFrame("MultiWrapColTable");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JScrollPane jsp = new JScrollPane(table);
frame.getContentPane().add(jsp);
frame.pack();
frame.setBounds(50, 50, 800, 500);
frame.setVisible(true);
}
}
// if the renderer on a column (or the whole table) is not a JTextComponent calculating its preferredSize will not do
// any wrapping ... but it won't do any harm....
class JTPRenderer extends JTextPane implements TableCellRenderer {
@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
int row, int column) {
setText(value.toString());
return this;
}
}
class WrapColListener implements TableColumnModelListener {
JTable m_table;
WrapColListener( JTable table ){
m_table = table;
}
void refresh_row_heights() {
int n_rows = m_table.getRowCount();
int n_cols = m_table.getColumnCount();
int intercell_width = m_table.getIntercellSpacing().width;
int intercell_height = m_table.getIntercellSpacing().height;
TableColumnModel col_model = m_table.getColumnModel();
// these null checks are due to concurrency considerations... much can change between the col margin change
// event and the call to refresh_row_heights (although not in this SSCCE...)
if( col_model == null ) return;
// go through ALL rows, calculating row heights
for (int row = 0; row < n_rows; row++) {
int pref_row_height = 1;
// calculate row heights from cell, setting width constraint by means of setBounds...
for (int col = 0; col < n_cols; col++) {
Object value = m_table.getValueAt(row, col);
TableCellRenderer renderer = m_table.getCellRenderer(row, col);
if( renderer == null ) return;
Component comp = renderer.getTableCellRendererComponent( m_table, value, false, false,
row, col);
if( comp == null ) return;
int col_width = col_model.getColumn(col).getWidth();
// constrain width of component
comp.setBounds(new Rectangle(0, 0, col_width - intercell_width, Integer.MAX_VALUE ));
// getPreferredSize then returns "true" height as a function of attributes (e.g. font) and word-wrapping
int pref_cell_height = comp.getPreferredSize().height + intercell_height;
if (pref_cell_height > pref_row_height) {
pref_row_height = pref_cell_height;
}
}
if (pref_row_height != m_table.getRowHeight(row)) {
m_table.setRowHeight(row, pref_row_height);
}
}
}
@Override
public void columnAdded(TableColumnModelEvent e) {
refresh_row_heights();
}
@Override
public void columnRemoved(TableColumnModelEvent e) {
// probably no need to call refresh_row_heights
}
@Override
public void columnMoved(TableColumnModelEvent e) {
// probably no need to call refresh_row_heights
}
@Override
public void columnMarginChanged(ChangeEvent e) {
refresh_row_heights();
}
@Override
public void columnSelectionChanged(ListSelectionEvent e) {
// probably no need to call refresh_row_heights
}
}
/*
* This class reflects the fact that 1) when you drag a column boundary using the mouse a very large number of
* ChangeEvents are generated and 2) with more complex fonts, more text and larger tables ("real world") the amount
* of computation in calculating the row heights becomes significant and leads to an unresponsive GUI, or worse.
* This "first" strategy to address this involves setting a pause between the detection of a change event and the
* refreshing of the rows. Naturally this involves a Timer, the run() method of which is not the EDT, so it
* must then submit to EventQueue.invokeLater...
* The larger the table, the more text involved, and the more complex the fonts... the more ingenuity will have to
* be used in coping with the potentially vast amount of computation involved in getting the ideal row heights. This
* is in the nature of the beast. Ideas might involve:
* 1) adjusting the row heights immediately only for rows which are visible or likely to be visible (Viewport), and
* then making successive calls to EventQueue.invokeLater to deal with all the other rows
* 2) giving cells a "memory" of their heights as a function of the allowed width. Unfortunately it will not allow
* the possibility of interpolating intermediate values because the question of whether a line wraps may hinge on a
* single pixel difference, although an imperfect solution to this would be err on the side of caution, i.e. pretend
* that a column is a little thinner than it is to cause wrapping before it is strictly necessary... particularly when
* cells are out of view...
* ... other ideas...(?)
*/
class FirstRealWorldWrapColListener implements TableColumnModelListener {
JTable m_table;
final static long PAUSE_TIME = 50L;
java.util.Timer m_pause_timer = new java.util.Timer( "pause timer", true );
TimerTask m_pause_task;
class PauseTask extends TimerTask{
@Override
public void run() {
EventQueue.invokeLater( new Runnable(){
@Override
public void run() {
refresh_row_heights();
System.out.println( "=== setting m_pause_task to null..." );
m_pause_task = null;
}});
}
}
FirstRealWorldWrapColListener( JTable table ){
m_table = table;
}
void queue_refresh(){
if( m_pause_task != null ){
return;
}
System.out.println( "=== scheduling..." );
m_pause_task = new PauseTask();
m_pause_timer.schedule( m_pause_task, PAUSE_TIME );
}
void refresh_row_heights() {
int n_rows = m_table.getRowCount();
int n_cols = m_table.getColumnCount();
int intercell_width = m_table.getIntercellSpacing().width;
int intercell_height = m_table.getIntercellSpacing().height;
TableColumnModel col_model = m_table.getColumnModel();
// these null checks are due to concurrency considerations... much can change between the col margin change
// event and the call to refresh_row_heights (although not in this SSCCE...)
if( col_model == null ) return;
// go through ALL rows, calculating row heights
for (int row = 0; row < n_rows; row++) {
int pref_row_height = 1;
// calculate row heights from cell, setting width constraint by means of setBounds...
for (int col = 0; col < n_cols; col++) {
Object value = m_table.getValueAt(row, col);
TableCellRenderer renderer = m_table.getCellRenderer(row, col);
if( renderer == null ) return;
Component comp = renderer.getTableCellRendererComponent( m_table, value, false, false,
row, col);
if( comp == null ) return;
int col_width = col_model.getColumn(col).getWidth();
// constrain width of component
comp.setBounds(new Rectangle(0, 0, col_width - intercell_width, Integer.MAX_VALUE ));
// getPreferredSize then returns "true" height as a function of attributes (e.g. font) and word-wrapping
int pref_cell_height = comp.getPreferredSize().height + intercell_height;
if (pref_cell_height > pref_row_height) {
pref_row_height = pref_cell_height;
}
}
if (pref_row_height != m_table.getRowHeight(row)) {
m_table.setRowHeight(row, pref_row_height);
}
}
}
@Override
public void columnAdded(TableColumnModelEvent e) {
// refresh_row_heights();
queue_refresh();
}
@Override
public void columnRemoved(TableColumnModelEvent e) {
// probably no need to call refresh_row_heights
}
@Override
public void columnMoved(TableColumnModelEvent e) {
// probably no need to call refresh_row_heights
}
@Override
public void columnMarginChanged(ChangeEvent e) {
// refresh_row_heights();
queue_refresh();
}
@Override
public void columnSelectionChanged(ListSelectionEvent e) {
// probably no need to call refresh_row_heights
}
}
// if the renderer on a column (or the whole table) is not a JTextComponent calculating its preferredSize will not do
// any wrapping ... but it won't do any harm....
class JTPRenderer extends JTextPane implements TableCellRenderer {
Font m_default_font, m_big_font, m_default_alternate_font, m_big_alternate_font;
HashMap<AttributedCharacterIterator.Attribute, Object> m_red_serif_attr_map;
//
JTPRenderer() {
m_default_font = getFont();
m_big_font = m_default_font.deriveFont(m_default_font.getSize() * 1.5f);
m_red_serif_attr_map = new HashMap<AttributedCharacterIterator.Attribute, Object >();
m_red_serif_attr_map.put( TextAttribute.FAMILY, Font.SERIF );
m_red_serif_attr_map.put( TextAttribute.FOREGROUND, Color.RED );
m_red_serif_attr_map.put( TextAttribute.WIDTH, TextAttribute.WIDTH_EXTENDED );
m_default_alternate_font = m_default_font.deriveFont( m_red_serif_attr_map );
m_big_alternate_font = m_big_font.deriveFont( m_red_serif_attr_map );
// simpler alternate font:
// m_default_alternate_font = m_default_font.deriveFont( Font.BOLD | Font.ITALIC );
// m_big_alternate_font = m_big_font.deriveFont( Font.BOLD | Font.ITALIC );
}
@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
int row, int column) {
int rc = row + column;
if( rc % 4 == 2 )
setFont( rc % 5 == 1 ? m_big_alternate_font : m_default_alternate_font );
else
setFont( rc % 5 == 1 ? m_big_font : m_default_font );
setText(value.toString());
return this;
}
}
// set the width on the jTextArea causing a calc of preferred height
jtxt.setSize(table.getWidth(), Short.MAX_VALUE);
int prefH = jtxt.getPreferredSize().height;
table.setRowHeight(row, prefH);
import javax.swing.*;
import javax.swing.table.TableCellEditor;
import java.awt.*;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
class MultilineTableCellEditor extends AbstractCellEditor implements TableCellEditor {
JComponent component = new JTextArea();
JTable table;
int lastRowIndex;
public MultilineTableCellEditor() {
JTextArea textArea = ((JTextArea) component);
textArea.setLineWrap(true);
textArea.setWrapStyleWord(true);
textArea.addComponentListener(new ComponentAdapter() {
@Override
public void componentResized(ComponentEvent e) {
super.componentResized(e);
table.setRowHeight(lastRowIndex, (int) (textArea.getPreferredSize().getHeight()));
}
});
textArea.addKeyListener(new KeyAdapter() {
@Override
public void keyTyped(KeyEvent e) {
super.keyTyped(e);
table.setRowHeight(lastRowIndex, (int) (textArea.getPreferredSize().getHeight()));
}
});
}
public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected,
int rowIndex, int vColIndex) {
this.table = table;
lastRowIndex = rowIndex;
((JTextArea) component).setText((String) value);
component.setFont(table.getFont());
return component;
}
public Object getCellEditorValue() {
return ((JTextArea) component).getText();
}
}
JTable table = new JTable(tableModel) {
// Cell renderer by Alessandro Rossi (posted as solution to this question)
MultilineTableCell renderer = new MultilineTableCell();
MultilineTableCellEditor editor = new MultilineTableCellEditor();
@Override
public TableCellRenderer getCellRenderer(int row, int column) {
if (column == multilineColumn) {
return renderer;
}
return super.getCellRenderer(row, column);
}
@Override
public TableCellEditor getCellEditor(int row, int column) {
if ( column == multilineColumn ) {
return editor;
}
return super.getCellEditor(row, column);
}
};
import java.awt.Component;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.table.TableCellRenderer;
public class LineWrapCellRenderer extends JTextArea implements TableCellRenderer {
@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
int row, int column) {
this.setText((String) value);
this.setWrapStyleWord(true);
this.setLineWrap(true);
int fontHeight = this.getFontMetrics(this.getFont()).getHeight();
int textLength = this.getText().length();
int lines = textLength / this.getColumnWidth();
if (lines == 0) {
lines = 1;
}
int height = fontHeight * lines;
table.setRowHeight(row, height);
return this;
}
}