Java实现自定义table宽高的示例代码

setGlobalRowHeight(int height);
setRowHeight(int row, int height);
setColumnWidth(int column, int width);
fitColumnToContent(int column, int sampleRows);
setFillViewportWidth(boolean fill);

TableCellRenderer headerR = table.getTableHeader().getDefaultRenderer();
Component comp = headerR.getTableCellRendererComponent(...);
int headerWidth = comp.getPreferredSize().width;
for (int i = 0; i < sampleRows; i++) {
    TableCellRenderer cellR = table.getCellRenderer(i, col);
    comp = cellR.getTableCellRendererComponent(table, table.getValueAt(i,col), ...);
    maxWidth = Math.max(maxWidth, comp.getPreferredSize().width);
}

// ===== 文件：ColumnWidthConfig.java =====
package com.example.resizetable;
 
import java.util.Map;
import java.util.prefs.Preferences;
 
/**
 * 持久化列宽配置：使用 Java Preferences API 存储用户列宽偏好
 */
public class ColumnWidthConfig {
    private static final String NODE = "/com/example/resizetable/columnwidth";
    private final Preferences prefs = Preferences.userRoot().node(NODE);
    private final String tableKey;
 
    public ColumnWidthConfig(String tableKey) {
        this.tableKey = tableKey;
    }
 
    /** 保存单列宽度 */
    public void saveWidth(int colIndex, int width) python{
        prefs.putInt(tableKey + ".col." + colIndex, width);
    }
 
    /** 加载单列宽度，若无配置则返回 -1 */
    public int loadWidth(int colIndex) {
        return prefs.getInt(tableKey + ".col." + colIndex, -1);
    }
 
    /** 清除所有列宽配置 */
    public void clear() {
        try {
            for (String key : prefs.keys()) {
                if (key.startsWith(tableKey + ".col.")) {
                    prefs.remove(key);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /** 保存多列宽度 */
    public void saveAll(Map<Integer, Integer> widths) {
        widths.forEach(this::saveWidth);
    }
}
 
// ===== 文件：DimensionController.java =====
package com.example.resizetable;
 
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
imjavascriptport java.awt.*;
import java.util.*;
import java.util.List;
import java.util.concurrent.ExecutionException;
 
/**
 * 列宽控制器：自动/手动调整列宽，响应容器变化，并持久化配置
 */
public class DimensionController {
    private final JTable table;
    private final ColumnWidthConfig config;
    private final int sampleRows;
    private Timer saveTimer;
 
    public DimensionController(JTable table, ColumnWidthConfig config, int sampleRows) {
        this.table = table;
        this.config = config;
        this.sampleRows = sampleRows;
        initSaveDebounce();
        installModelListener();
    }
 
    /** 初始化防抖定时器，等待用户停止拖拽后再保存 */
    private void initSaveDebounce() {
        saveTimer = new Timer(500, e -> saveConfig());
        saveTimer.setRepeats(false);
    }
 
    /** 安装列宽变化监听，触发防抖保存 */
    private void installModelListener() {
        table.getColumnModel().addColumnModelListener(new TableColumnModelListener() {
            @Override public void columnMarginChanged(ChangeEvent e) {
                saveTimer.restart();
            }
            @Override public void columnMoved(TableColumnModelEvent e) {}
            @Override public void columnAdded(TableColumnModelEvent e) {}
            @Override public void columnRemoved(TableColumnModelEvent e) {}
            @Override public void columnSelectionChanged(ListSelectionEvent e) {}
        });
    }
 
    /** 自动调整所有列宽（后台线程） */
    public void autoAdjustAll() {
        new SwingWorker<Map<Integer, Integer>, Void>() {
            @Override
            protected Map<Integer, Integer> doInBackground() {
                Map<Integer, Integer> result = new HashMap<>();
                TableColumnModel cm = table.getColumnModel();
                for (int col = 0; col < cm.getColumnCount(); col++) {
                    int width = measureColumn(col);
                    result.put(col, width);
                }
                return result;
            }
            @Override
            protected void done() {
                try {
                    Map<Integer, Integer> widths = get();
                    widths.forEach((col, w) -> table.getColumnModel()
                            .getColumn(col).setPreferredWidth(w));
                    saveConfig();
                } catch (InterruptedException | ExecutionException ex) {
                    ex.printStackTrace();
                }
            }
        }.execute();
    }
 
    /** 测量单列所需宽度 */
    private int measureColumn(int col) {
        int max = 0;
        TableColumn tc = table.getColumnModel().getColumn(col);
        // header
        TableCellRenderer hr = tc.getHeaderRenderer();
        if (hr == null) hr = table.getTableHeader().getDefaultRenderer();
        Component c = hr.getTableCellRendererComponent(
                table, tc.getHeaderValue(), false, false, -1, col);
        max = c.getPreferredSize().width;
        // sample rows
        int rowCount = Math.min(sampleRows, table.getRowCount());
        for (int row = 0; row < rowCount; row++) {
            TableCellRenderer cr = table.getCellRenderer(row, col);
            c = cr.getTableCellRendererComponent(
                    table, table.getValueAt(row, col),
                    false, false, row, col);
            max = Math.max(max, c.getPreferredSize().width);
        }
        // 加入一点缓冲
        return max + 10;
    }
 
    /** 恢复持久化配置的列宽 */
    public void restoreConfig() {
        TableColumnModel cm = table.getColumnModel();
        for (int col = 0; col < cm.getColumnCount(); col++) {
            int w = config.loadWidth(col);
            if (w > 0) cm.getColumn(col).setPreferredWidth(w);
        }
    }
 
    /** 保存当前列宽到配置 */
    public void saveConfig() {
        TableColumnModel cm = table.getColumnModel();
        Map<Integer, Integer> widths = new HashMap<>();
        for (int col = 0; col < cm.getColumnCount(); col++) {
            widths.put(col, cm.getColumn(col).getWidth());
        }
        config.saveAll(widths);
    }
 
    /** 清除所有持久化并恢复默认 */
    public编程 void clearAndDefault() {
        config.clear();
        autoAdjustAll();
    }
 
    /** 编程方式设置单列宽度 */
    public void setColumnWidth(int col, int width) {
        table.getColumnModel().getColumn(col).setPreferredWidth(width);
        saveConfig();
    }
 
    /** 获取单列当前宽度 */
    public int getColumnWidth(int col) {
        return table.getColumnModel().getColumn(col).getWidth();
    }
}
 
// ===== 文件：ResizableTablePanel.java =====
package com.example.resizetable;
 
import javax.swing.*;
import java.awt.*;
 
/**
 * 自适应表格面板：封装 JTable、滚动条和宽度控制
 */
public class ResizableTablePanel extends JPanel {
    private final JTable table;
    private final DimensionController controller;
 
    public ResizableTablePanel(Object[][] data, Object[] columns, String tableKey) {
        super(new BorderLayout());
        table = new JTable(data, columns);
        ColumnWidthConfig config = new ColumnWidthConfig(tableKey);
        controller = new DimensionController(table, config, 50);
        // 恢复历史配置，若无则自动调整
        controller.restoreConfig();
        if (config.loadWidth(0) < 0) {
            controller.autoAdjustAll();
        }
        add(new jscrollPane(table), BorderLayout.CENTER);
    }
 
    // 对外 API
    public void fitAllColumns() { controller.autoAdjustAll(); }
    public void resetWidths() { controller.clearAndDefault(); }
    public void shttp://www.chinasem.cnetColumnWidth(int col, int w) { controller.setColumnWidth(col, w); }
    public int getColumnWidth(int col) { return controller.getColumnWidth(col); }
}