Java 如何绕过调用JTable渲染器

好吧，这已经困扰了我好几天了。也许标题不够准确，但这是我唯一能想到的描述我处境的东西

我对用户的最终目标是，当他们编辑行时，仅在第4列或第5列中，表格将突出显示（设置背景色黄色）数据分别与第4列和第5列编辑行中的值匹配的任何行，实际编辑行除外。（这两列都是JComboBox）

听起来不错？我还试图突出显示这些行，当用户编辑第4列或第5列中的另一行时，使用与以前不同的值，仍然重复并突出显示匹配的行，同时不重新渲染以前突出显示的行。这对我来说很难，因为我不太明白发生了什么

最后，当我弄明白这一点时，用户只需选择行，就可以从行中删除颜色（表示他们已经检查了该数据）

我需要知道如何在jtable中调用渲染器。它似乎在每次更改时都会被调用。有没有办法呈现表格，然后绕过对呈现器的调用，这样它就不必不断地重新绘制单元格？我不知道我问的问题是否正确

我试图覆盖GetTableCellRenderComponent方法并以这种方式返回颜色，但当我编辑其他单元格时，我丢失了第一次编辑时高亮显示的内容。突出显示的内容也不完全正确，它会获取大部分匹配的数据以及其他不匹配的行。我想我不完全理解这个问题

一定有一个我没有领会的概念。或者可能有一种完全不同的方法来做。我可以往正确的方向推一推

public class ColorChange extends DefaultTableCellRenderer {
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value,
                    boolean isSelected, boolean hasFocus, int row, int column) {
                Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                if (column != 7) {
                    this.setHorizontalAlignment(SwingConstants.CENTER);
                }
                else {
                    this.setHorizontalAlignment(SwingConstants.LEFT);
                }
                Color curColor = c.getBackground();
                if (ColorCheck(table, row, column)) {
                    c.setBackground(Color.YELLOW);
                }
                else if (curColor == Color.YELLOW) {
                    c.setBackground(curColor);
                }
                else {
                    c.setBackground(Color.WHITE);
                }
                return c;
            }

        }

public boolean ColorCheck(JTable jt, int row, int col) {
            boolean result = false;
            int er = jt.getEditingRow();
            int ec = jt.getEditingColumn();
            if (er<0 || ec<0) {
                return result;
            }
            String edMainCat = (String) jt.getValueAt(er, 4);
            String edSubCat = (String) jt.getValueAt(er, 5);
            String MainC = (String) jt.getValueAt(row, 4);
            String SubC = (String) jt.getValueAt(row, 5);

            if (edMainCat == null || edSubCat == null || MainC == null || SubC == null || row == er) {
                return result;
            }
            if (edMainCat.equals(MainC) && edSubCat.equals(SubC)) {
                result = true;
            }

            return result;
        }

公共类ColorChange扩展了DefaultTableCellRenderer{
@凌驾
公共组件GetTableCellRenderComponent（JTable表、对象值、，
布尔值（已选择，布尔值为焦点，整数行，整数列）{
Component c=super.getTableCellRenderComponent（表、值、isSelected、hasFocus、行、列）；
如果（列！=7）{
此.setHorizontalAlignment（SwingConstants.CENTER）；
}
否则{
此.setHorizontalAlignment（SwingConstants.LEFT）；
}
Color curColor=c.getBackground（）；
if（颜色检查（表、行、列））{
c、 挫折地面（颜色：黄色）；
}
else if（curColor==Color.YELLOW）{
c、 挫折背景（颜色）；
}
否则{
c、 挫折地面（颜色：白色）；
}
返回c；
}
}
公共布尔颜色检查（JTable jt、int row、int col）{
布尔结果=假；
int er=jt.getEditingRow（）；
int ec=jt.getEditingColumn（）；
如果（er一个问题可能是：

Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
// ...
Color curColor = c.getBackground();

super.gettableCellRenderComponent
将调用DefaultTableCellRenderer的gettableCellRenderComponent方法。DefaultTableCellRenderer永远不会将渲染器组件的背景设置为黄色。（从理论上讲，如果Swing使用的是一种可以读取用户桌面首选项的外观，并且用户已经设置了这些首选项，使得按钮背景为黄色，那么它就可以实现。）

但在这种情况下，这并不重要，因为单元格渲染器最好使用状态信息，而不是现有外观

可以绘制组件（从而调用其单元格渲染器）的原因有很多，包括用户在组件上移动鼠标这样简单的事情。没有可靠的方法知道到底是什么导致了它。您所能做的就是随时准备调用渲染器

您应该将匹配行存储在私有字段中，与表外观无关。类似于：

public class ColorChange extends DefaultTableCellRenderer {
    private static final long serialVersionUID = 1;

    private final Collection<Integer> matchingRows;

    public ColorChange(Collection<Integer> matchingRows) {
        this.matchingRows = matchingRows;
    }

    @Override
    public Component getTableCellRendererComponent(JTable table,
            Object value, boolean isSelected, boolean hasFocus,
            int row, int column) {

        Component c = super.getTableCellRendererComponent(table,
            value, isSelected, hasFocus, row, column);

        if (column != 7) {
            this.setHorizontalAlignment(SwingConstants.CENTER);
        } else {
            this.setHorizontalAlignment(SwingConstants.LEFT);
        }

        if (!isSelected) {
            if (matchingRows.contains(row)) {
                c.setBackground(Color.YELLOW);
            } else {
                c.setBackground(null);
            }
        }

        return c;
    }
}

公共类ColorChange扩展了DefaultTableCellRenderer{
私有静态最终长serialVersionUID=1；
私人最终收藏匹配行；
公共颜色更改（集合匹配行）{
this.matchingRows=matchingRows；
}
@凌驾
公共组件GetTableCellRenderComponent（JTable表，
对象值，布尔isSelected，布尔hasFocus，
整数行，整数列）{
组件c=super.getTableCellRenderComponent（表，
值、isSelected、hasFocus、行、列）；
如果（列！=7）{
此.setHorizontalAlignment（SwingConstants.CENTER）；
}否则{
此.setHorizontalAlignment（SwingConstants.LEFT）；
}
如果（！isSelected）{
if（matchingRows.contains（行））{
c、 挫折地面（颜色：黄色）；
}否则{
c、 倒退（空）；
}
}
返回c；
}
}

请注意，如果选择了一行，则应使JTable的选择颜色保持有效

要使用上述渲染器，您需要通过侦听表模型更改来维护匹配行：

private final Collection<Integer> matchingRows = new HashSet<>();

// ...

    table.setDefaultRenderer(Object.class, new ColorChange(matchingRows));

    table.getModel().addTableModelListener(event -> {
        int type = event.getType();
        int column = event.getColumn();
        TableModel model = (TableModel) event.getSource();
        int firstRow = event.getFirstRow();
        int lastRow = event.getLastRow();

        if (firstRow == TableModelEvent.HEADER_ROW) {
            table.repaint();
            return;
        }

        if (type == TableModelEvent.UPDATE) {
            if ((column == 4 || column == 5) && firstRow == lastRow) {
                int editedRow = firstRow;
                Object edMainC = model.getValueAt(editedRow, 4);
                Object edSubC = model.getValueAt(editedRow, 5);

                matchingRows.clear();
                int count = model.getRowCount();
                for (int row = 0; row < count; row++) {
                    if (row != editedRow) {
                        Object mainC = model.getValueAt(row, 4);
                        Object subC = model.getValueAt(row, 5);
                        if (Objects.equals(mainC, edMainC) ||
                            Objects.equals(subC, edSubC)) {

                            matchingRows.add(row);
                        }
                    }
                }
            }
        } else if (type == TableModelEvent.INSERT) {
            int start = Math.min(firstRow, lastRow);
            int count = Math.abs(lastRow - firstRow) + 1;

            List<Integer> newRows = new ArrayList<>(matchingRows);
            newRows.replaceAll(row -> row < start ? row : row + count);

            matchingRows.clear();
            matchingRows.addAll(newRows);
        } else if (type == TableModelEvent.DELETE) {
            int start = Math.min(firstRow, lastRow);
            int end = Math.max(firstRow, lastRow);
            int count = end - start + 1;

            List<Integer> newRows = new ArrayList<>(matchingRows);
            newRows.removeIf(row -> row >= start && row <= end);
            newRows.replaceAll(row -> row <= end ? row : row - count);

            matchingRows.clear();
            matchingRows.addAll(newRows);
        }

        table.repaint();
    });

private final Collection matchingRows=new HashSet（）；
// ...
table.setDefaultRenderer（Object.class，新颜色更改（匹配行））；
table.getModel（）.addTableModelListener（事件->{
int type=event.getType（）；
int column=event.getColumn（）；
TableModel model=（TableModel）event.getSource（）；
int firstRow=event.getFirstRow（）；
int lastRow=event.getLastRow（）；
if（firstRow==TableModelEvent.HEADER\u行）{
表1.repaint（）；
返回；
}
if（type==tablemodeleevent.UPDATE）{
if（（列==4 | |列==5）和&firstRow==lastRow）{
int editedRow=第一行；
对象edMainC=model.getValueAt（编辑