Set color of JTable row at runtime

Question

My Java 8 applet connects to an SQL database and displays the result of a "select" statement in a JTable with two columns:

If the String in row 1/ColumnA isn't the same as the String in row 0/ColumnA, I want to give row 1 a grey background color (to mark the start of "new" data), the other rows should use the default white color.

Code for creating the table:

JTable myTable = new JTable();
myTable.setSelectionModel(new ToggleListSelectionModel()); //custom selection model
myTable.setModel(new DefaultTableModel(
    new Object[][] {
    },
    new String[] {
        "ColumnA", "ColumnB"
    }
));

Getting the data and filling the table:

Statement stat = connection.createStatement();
ResultSet rs = stat.executeQuery(someSelectStatement);
Object[] row = null;

while(rs.next()) {  
    int columns = rs.getMetaData().getColumnCount();    
    row = new Object[columns];

    for (int i=1; i<=columns; i++) {
        row[i - 1] = rs.getObject(i);
    }

    //TODO: Set color of row according to data in "ColumnA" of previous row
    ((DefaultTableModel) myTable.getModel()).insertRow(rs.getRow()-1,row); //Add new row with the ResultSet's content
    //Get String data of ColumnA for this specific row with e.g. "(String) row[0]"
}

rs.close();
stat.close();

From what I've found so far, I have to use a custom TableModel instead of the DefaultTableModel I set in the beginning but how do I use it? Everything I've found uses fixed checks, e.g.

if content in the cell is 'buy', set the background color to 'green'

(e.g. here or here) but in my case I don't know anything about the content when the table is created because it's filled/rows are added at runtime.

I also found this answer but the author of the question reads the data, then changes the model and only then fills the table, while I fill the table row by row (directly after reading the row's content).

My question: I know how to compare the content of a cell to content of the cell in the previous row but how do I set the background color of the row at runtime?

Edit:

Here's some MRE code for filling the table. Please note: If you post a suggestion about how to accomplish what I want to do, keep in mind that I'm working with a database and a ResultSet (see code above), not pre-defined data (see code below)!

JTable myTable = new JTable();
myTable.setSelectionModel(new ToggleListSelectionModel()); //custom selection model
myTable.setModel(new DefaultTableModel(
    new Object[][] {
        {"1000", 123},
        {"1000", 234}, 
        {"1001", 123},
        {"1002", 123},
        {"1002", 234},
        {"1002", 345},
        {"1003", 123},
        {"1003", 234}
    },
    new String[] {
        "ColumnA", "ColumnB"
    }
));

Result:

Desired result (grey background for every new "Column A" value):

Alternative result (alternate marking all rows of a group):

Answer 1

table.setDefaultRenderer(Object.class, new DefaultTableCellRenderer() {
    @Override
    public Component getTableCellRendererComponent(JTable table,
                                  Object value,
                                  boolean isSelected,
                                  boolean hasFocus,
                                  int row,
                                  int column) {
        Component comp = super.getTableCellRendererComponent(table,
                value, isSelected, hasFocus, row, column);
        if(!isSelected) { //Important check, see comment below!
            boolean levelBreak = row == 0;
            if (!levelBreak) {
                Object prior = table.getValueAt(row - 1, 0);
                Object current = table.getValueAt(row, 0);
                levelBreak = !prior.equals(current);
            }
            comp.setBackground(levelBreak ? Color.BLUE : Color.WHITE);
        }
        return comp;
    }
});

As the renderer / renderer component is reused for all table cells, the background must be set for all cases.

In general the JTable's TabelModel is better for getting a value instead of JTable's getValueAt, but evidently you neither sort the rows nor rearrange the columns.

---

For a possible older installed renderer

class MyCellRenderer extends DefaultTableCellRenderer {

    private final TableCellRenderer old;

    MyCellRenderer(TableCellRenderer old) {
        this.old = old;
    }

    @Override
    public Component getTableCellRendererComponent(JTable table,
                                  Object value,
                                  boolean isSelected,
                                  boolean hasFocus,
                                  int row,
                                  int column) {
        boolean levelBreak = row == 0;
        if (!levelBreak) {
            Object prior = table.getValueAt(row - 1, 0);
            Object current = table.getValueAt(row, 0);
            levelBreak = !prior.equals(current);
        }
        Component comp;
        if (old != null) {
            comp = old.getTableCellRendererComponent(table,
                value, isSelected, hasFocus, row, column);
        } else {
            comp = super.getTableCellRendererComponent(table,
                value, isSelected, hasFocus, row, column);
        }
        comp.setBackground(levelBreak ? Color.BLUE : Color.WHITE);
        return comp;
    }
}

table.setDefaultRenderer(Object.class, new MyCellRenderer(table.getDefaultRenderer(Object.class));

Answer 2

You need to create and use a custom TableCellRenderer

Basically, implement the one method in this class:

getTableCellRendererComponent(JTable table,
                                      Object value,
                                      boolean isSelected,
                                      boolean hasFocus,
                                      int row,
                                      int column)

I think the easiest way to do this is to create a new class that extends DefaultTableCellRendererComponent, like

class myRenderer extends DefaultTableCellRendererComponent {
    public Component getTableCellRendererComponent(JTable table,
                                          Object value,
                                          boolean isSelected,
                                          boolean hasFocus,
                                          int row,
                                          int column) {
      Component c = super.getTableCellRendererComponent(...);
    }
}

Component c is a JLabel. Just call setBackground (based on the row) and you should be set

Answer 3

I don't know anything about the content when the table is created because it's filled/rows are added at runtime.

You don't need to know anything about the data in advance. The rendering of a JTable is only done AFTER the data has been added to the TableModel.

The Table Row Rendering suggestion you linked to in your question is the approach you should be using. It shows how to do the rendering dynamically based on the data in the model.

Everything I've found uses fixed checks, e.g. "if content in the cell is 'buy', set the background color to 'green'"

Well you also have a fixed check:

1. You want to get the data for the current row
2. then get the data for the previous row.
3. Then you compare both values and do the required highlighting.

All you are doing is comparing two values. Whether one value is hard coded is retrieve from the previous row makes no difference for the comparison.

From what I've found so far, I have to use a custom TableModel instead of the DefaultTableModel

There is no reason you can't use the DefaultTableModel. In fact the code from the Table Row Rendering uses the DefualtTableModel. The model used is irrelevant. All the model does is store the data. The rendering process then uses the data from the model.

So my suggestion is to:

1. start with the working demo code from the Table Row Rendering link.
2. change the hardcoded data to be similar to your real data.
3. then add you custom rendering logic

Get the basics working first. Then worry about adding the data dynamically from the database. Simplify the problem and solve one step at a time.

Simple MRE using all the suggestions from above:

import java.awt.*;
import javax.swing.*;
import javax.swing.table.*;

public class SSCCE extends JPanel
{
    public SSCCE()
    {
        JTable myTable = new JTable()
        {
            @Override
            public Class getColumnClass(int column)
            {
                return getValueAt(0, column).getClass();
            }

            @Override
            public Component prepareRenderer(TableCellRenderer renderer, int row, int column)
            {
                Component c = super.prepareRenderer(renderer, row, column);

                if (!isRowSelected(row))
                {
                    if (row == 0)
                        c.setBackground( Color.BLUE );
                    else
                    {
                        Object previous = getModel().getValueAt(row - 1, 0);
                        Object current = getModel().getValueAt(row, 0);
                        c.setBackground( current.equals(previous) ? Color.WHITE : Color.BLUE );
                    }
                }

                return c;
            }
        };

        myTable.setModel(new DefaultTableModel(
            new Object[][] {
                {"1000", 123},
                {"1000", 234},
                {"1001", 123},
                {"1002", 123},
                {"1002", 234},
                {"1002", 345},
                {"1003", 123},
                {"1003", 234}
            },
            new String[] {
                "ColumnA", "ColumnB"
            }
        ));

        setLayout( new BorderLayout() );
        add(new JScrollPane(myTable));
    }

    private static void createAndShowGUI()
    {
        JFrame frame = new JFrame("SSCCE");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new SSCCE());
        frame.pack();
//        frame.setLocationByPlatform( true );
        frame.setVisible( true );
    }

    public static void main(String[] args) throws Exception
    {
        java.awt.EventQueue.invokeLater( () -> createAndShowGUI() );
/*
        EventQueue.invokeLater(new Runnable()
        {
            public void run()
            {
                createAndShowGUI();
            }
        });
*/
    }
}