Bestimmte Zeilen einfärben

Hallo,

ich würde gerne bestimmte Zeilen färben.

Hiermit kann ich die 3te Spalte einfärben. In dem Beispiel würde die Spalte “grün”.

jTable1.getColumn(jTable1.getColumnName(2)).setCellRenderer(ccr);```

Mein zugehöriger CellRenderer sieht derzeit wie folgt aus!

```import java.awt.Color;
import javax.swing.table.DefaultTableCellRenderer;

public class CustomCellRenderer extends DefaultTableCellRenderer {

    /**
     * 
     */
    private static final long serialVersionUID = -7171382203765416074L;

    Color currentCol;
    
    @Override
    protected void setValue(Object value) {
        super.setValue(value);
        
        System.out.println("HIER " + value);

        if (value.equals("new")) {
            currentCol = Color.GREEN;
        } 
        if (value.equals("old")) {
            currentCol = Color.YELLOW;
        } 
        
        setBackground(currentCol);
    }
}  ```

Jetzt möchte ich jedoch nicht mit getColumn arbeiten sondern nur die jeweilige Zeile einfärben.

Ìch dachte mir das sollte ja mit getRow oder ähnliches gehen. Nur geht das leider nicht.

Z.B. so 2. Zeile einfärben.

```ccr.setValue("new");
jTable1.getRow(jTable1.getRow(2)).setCellRenderer(ccr);```

Die Darstellung und somit die Hintergrundfarbe einer Zelle wird immer durch deren Renderer festgelegt. D.h. der Renderer muss anhand eines verfügbaren Kriteriums (evtl. im Zellobjekt enthalten) entscheiden können wie er die Zelle einfärben soll.
Anhand welcher Kriterien entscheidet es sich denn, ob und wie eine Zelle eingefärbt wird?

Renderer kann man entweder für bestimmte Objekte oder für die komplette Spalte setzen.

Wenn man verschiedene Renderer für verschiedene Objekte, Spalten nutzt kann man auch noch durch überschreiben der prepareRenderer Methode der JTable, die Darstellung ausserhalb des Renderers manipulieren.

Danke für deine schnelle Antwort!

Habe nochmal etwas versucht!

import javax.swing.table.DefaultTableCellRenderer;

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

public class CustomCellRenderer extends DefaultTableCellRenderer {

	 private String columnName;
	 
	 public CustomCellRenderer(String column) {
	     this.columnName = column;
	     setOpaque(true);
	 }
	 public Component getTableCellRendererComponent(JTable table, int row, int column) {
     //Object columnValue=table.getValueAt(row,table.getColumnModel().getColumnIndex(columnName));
    
	     if(row == 1) {
	    	 setBackground(Color.BLUE);
	    	 System.out.println("BLUE");
	     }
	     else {
	    	 System.out.println("GREEN");
	         setBackground(Color.GREEN);	        
	     }
	     return this;
 }```

und mein Aufruf aus einer anderen Klasse sieht wie folgt aus

```CustomCellRenderer ccr = new CustomCellRenderer("2"); 
ccr.getTableCellRendererComponent(jTable1, 1, 2);

Das klappt auch soweit und er gibt mir die korrekten Sachen in der Console aus, jedoch färbt er nichts ein! :frowning:

table.setBackground(Color.BLUE);

ah klappt.

Jedoch färbt er mir gleich die ganz Tabelle blau oder grün. Ich würde jedoch gerne nur die einzelne Zeile in der bestimmten Farbe färben.

Der Renderer wird (zumindest in diesem Codeausschnitt) nicht gesetzt. Soll denn grundsätzlich für die erste Zeile eine andere Hintergrundfarbe gesetzt werden? Wenn keine weiteren Renderer vewendet werden, könnte man diese als DefaultRenderer für alle Objekte setzen. setDefaultRenderer(Object.class, ...

Hi Michael,

ich habe 2 Checkboxen. Ist Checkbox 1 (Anhang 1) ausgewählt sollen die ausgebenen Werte blau markiert werden. Checkbox 2 (Anhang 2) -> grün.

Das funktioniert soweit.

Wenn beide ausgewählt sind dann (Anhang 3), sollen die ausgegeben Ergebnisse aus Checkbox 1 blau und aus Checkbox 2 grün.

Damit man erkennt aus welcher Checkbox die Werte “stammen”.

Hier findest du auch Unterstützung: http://wiki.byte-welt.net/wiki/JTable_(Tutorial)©

Dann muss es für den Renderer ersichtlich sein, ob der Datensatz einer Zeile “old” oder “new” ist.
Verwendest Du den ein eigenes TableModel in dem ein Datensatz/eine Zeile durch ein eigenständiges Objekt repräsentiert wird? Dann könntest Du dieses Objekt um ein entsprechendes Attribut erweitern und anhand dieses Attributs die Zellen/Zeilen einfärben.

Ich habe das mal so gelöst:

Einfach den DefaultCellRenderer dazu benützen:

		table.setDefaultRenderer(Object.class, new DefaultTableCellRenderer() {
			@Override
			public Component getTableCellRendererComponent(JTable table,
					Object value, boolean isSelected, boolean hasFocus,
					int row, int column) {

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

				if (auswertung.size() < row) {
					row = auswertung.size();
				} else {
					if (auswertung.get(row).get(column).equals("1")) {
						setBackground(Color.RED);
					} else {
						setBackground(Color.WHITE);
					}
				}

				return this;
			}
		});```

was macht auswertung.size() ? :wut:

@michael : Ich benutze ein TableModel.

        	for (int x = 2; x < getArrayListSize(); x += 3) { 
                if (x <= newArrayList.size()) {
                    // Check if description contains in the new map-file and not in the old map-file
                    if (!oldArrayList.contains(newArrayList.get(x)) && (newArrayList.get(x) != "-")){
                        System.out.println("Nicht Vorhanden in alter Liste: " + newArrayList.get(x));
                        //jTable1.setBackground(Color.CYAN);
                        //ccr.setValue("new");
                        //jTable1.getRowCount(jTable1.getColumnName(2)).setCellRenderer(ccr);
                        ccr.getTableCellRendererComponent(jTable1, 2, 2);
                        System.out.println("LALLA " + jTable1.getModel().getRowCount());
                        //ccr.setValue("new");
                        ((DefaultTableModel)jTable1.getModel()).addRow(new Object[]{newArrayList.get(x-2), newArrayList.get(x-1), newArrayList.get(x)});
                    }	        		
                }
        	}
        } 
       
        if (jCheckBox2.isSelected() == true) {
        	for (int x = 2; x < getArrayListSize(); x += 3) { 
                if (x <= oldArrayList.size()) {
	                // Check if description contains in the old map-file and not in the new map-file
	                if (!newArrayList.contains(oldArrayList.get(x))) {
                        System.out.println("Nicht Vorhanden in alter Liste: " + oldArrayList.get(x));
                        //jTable1.setBackground(Color.blue);
                        //ccr.setValue("old");
                        //jTable1.getColumn(jTable1.getColumnName(2)).setCellRenderer(ccr);
                        ccr.getTableCellRendererComponent(jTable1, 1, 2);
                        ((DefaultTableModel)jTable1.getModel()).addRow(new Object[]{oldArrayList.get(x-2), oldArrayList.get(x-1), oldArrayList.get(x)});
                    }	        		
                }
        	}
        } ```

Hierbei scheint es sich um eine List<List<String>> zu handeln - einem zusätzlichen Model. Halte ich für Deinen Fall zu aufwendig, da man die Information leicht im bestehenden TableModel abbilden könnte. Wenn, dann würde Dir auch eine einfache List<?> (z.B. List) ausreichen.

Nichts was für dich von bedeutung wäre…

Das sind bestandteile von meinem Code, ich habe den nur kutz aus dem Projekt kopiert, entschuldige:o)

Du solltest Dir überlegen, mit Objekten zu arbeiten. Die Werte eines gemeinsamen Datensatzes in einer List auf Index 0, 1, 2 usw. zu legen, ist nicht nur frikelig und fehleranfällig, das wird irgendwann recht unübersichtlich und schwer beherrschbar.

Ein simpler, vielleicht nicht ganz sauberer Weg, den Du ohne großartige Anpassung Deines bisherigen Codes gehen könntest wäre folgender. Hier wird die Information zur Zeilenfarbe im eigenen TableModel abgelegt.

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

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableModel;

public class TableRendererDemo {
	public static void main(String[] s) {
		new TableRendererDemo().startDemo();
	}
	
	private void startDemo() {
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setBounds(0, 0, 200, 200);
		final MyTableModel model = new MyTableModel(new String[] {"ID", "Value", "Description"});
		model.addRow(new String[] {"0x0002", "0xF1", "Test3"}, 0);
		model.addRow(new String[] {"0x0005", "0xF1", "Test6"}, 0);
		model.addRow(new String[] {"0x0002", "0xFF", "Test7"}, 1);
		model.addRow(new String[] {"0x0003", "0x00", "IrgendeinTest"}, 2);
		model.addRow(new String[] {"0x0004", "0xF1", "Test99"}, 0);
		JTable table = new JTable(model);
		frame.add(new JScrollPane(table));
		frame.setVisible(true);
		
		table.setDefaultRenderer(Object.class, new DefaultTableCellRenderer() {
			private Color[] color = new Color[] {Color.GREEN, Color.BLUE, Color.ORANGE};
			
			public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
					int row, int column) {
				super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
				int colorIndex = model.getMarker(table.convertRowIndexToModel(row));
				this.setBackground(color[colorIndex]);
				return this;
			}
		});
	}

	class MyTableModel extends DefaultTableModel {
		private List<Integer> list = new ArrayList<Integer>();
		
		public MyTableModel(String[] columnNames) {
			super(columnNames, 0);
		}

		public void addRow(Object[] rowData, int mark) {
			super.addRow(rowData);
			list.add(mark);
		}
		
		public int getMarker(int row) {
			return list.get(row);
		}
	}
}```

Ich hab in meiner Snippetsammlung noch das hier gefunden, vielleicht hilft es:


import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableColumnModel;
import javax.swing.table.TableColumn;

@SuppressWarnings("serial")
public class TableColoring extends JFrame {

    public static void main(String[] args) {
        new TableColoring();
    }

    /**
     * Diese Klasse stellt die Daten einer Tabellenzeile dar. Diese bestehen
     * hier aus einer Codezahl und der Beschreibung dieses Codes.
     */
    public class TableEntry {
        private String code;
        private String contents;

        public TableEntry(String code, String contents) {
            this.code = code;
            this.contents = contents;
        }

        public String getCode() {
            return code;
        }

        public String getContents() {
            return contents;
        }
    }

    /**
     * Diese Klasse ist ein eigenes Tabellenmodell. Es hält die Daten der
     * Tabelle in Form einer Liste von TableEntry Objekten vor und weiß diese
     * anzuzeigen. Darüber hinaus kann man die Tabelle leeren und Daten
     * anhängen.
     */
    public class MyTableModel extends AbstractTableModel {

        /** Liste mit den Elementen der Tabelle: */
        private List<TableEntry> entryList;

        public MyTableModel() {
            super();
            entryList = new ArrayList<TableEntry>();
        }

        /** Ermittelt die Spaltenzahl. */
        @Override
        public int getColumnCount() {
            return 2;
        }

        /** Ermittelt die Zeilenzahl. */
        @Override
        public int getRowCount() {
            return entryList.size();
        }

        /**
         * Ermittelt den Tabelleninhalt der angegebenen Zelle.
         *
         * @param row
         *            Zeilennummer (die erste hat die 0)
         * @param column
         *            Spaltennummer (die erste hat die 0)
         */
        @Override
        public Object getValueAt(int row, int column) {
            String value = "";
            switch (column) {
                case 0:
                    value = entryList.get(row).getCode();
                    break;
                case 1:
                    value = entryList.get(row).getContents();
                    break;
            }
            return value;
        }

        /** Löscht den Inhalt der Tabelle. */
        public void clear() {
            entryList.clear();
        }

        /**
         * Fügt ein Element der Tabelle hinzu. Zudem wird jede zweite
         * Tabellenzeile mit einer anderen Hintergrundfarbe versehen.
         *
         * @param entry
         *            Neuer Tabelleneintrag
         * @param color
         *            Farbe dieses Eintrags
         */
        public void addEntry(TableEntry entry, Color color) {
            /* Zeilennummer der neuen Zeile ermitteln: */
            int row = entryList.size();

            /* Eintrag an die Tabelle anhängen: */
            entryList.add(entry);

            /* Renderer beschaffen (ist für alle Felder der gleiche): */
            MyTableRenderer codeRenderer = (MyTableRenderer) myTable
                    .getCellRenderer(0, 0);

            /* Vordergrundfarbe setzen: */
            codeRenderer.setRowForegroundColor(row, color);

            /* Hintergrundfarbe setzen: */
            if (row % 2 == 1) {
                codeRenderer.setRowBackgroundColor(row,
                        new Color(255, 255, 200));
            }
            else {
                codeRenderer.setRowBackgroundColor(row, Color.WHITE);
            }
        }
    }

    /**
     * Diese Klasse ist für das Rendern (die optische Darstellung) der
     * Tabellenzellen zuständig. Sie wurde von DefaultTableCellRenderer
     * abgeleitet, um nicht für jede Zelle eine neue Klasse zu erzeugen.
     *
     * Die Farben werden (immer für eine ganze Zeile gleich) in zwei Maps
     * vorgehalten und bei der Darstellung werden die dort gesetzten Farben,
     * so vorhanden, verwendet.
     */
    public class MyTableRenderer extends DefaultTableCellRenderer {

        /** Map mit der Information über die Vordergrundfarben */
        HashMap<Integer, Color> rowForegroundColors;

        /** Map mit der Information über die Hintergrundfarben */
        HashMap<Integer, Color> rowBackgroundColors;

        /** Der Konstruktor, hier werden unsere Maps erzeugt. */
        public MyTableRenderer() {
            super();
            rowForegroundColors = new HashMap<Integer, Color>();
            rowBackgroundColors = new HashMap<Integer, Color>();
        }

        /**
         * Liefert eine Komponente für die anzuzeigende Zelle zurück. Die
         * Hauptarbeit lassen wir super.getTableCellRendererComponent(...)
         * machen und hängen nur ein wenig Code dahinter.
         *
         * @param table
         *            Die Tabelle
         * @param value
         *            Das anzuzeigende Objekt (im Normalfall ein String)
         * @param isSelected
         *            Zeigt an, ob das Objekt selektiert wurde.
         * @param hasFocus
         *            Zeigt an, ob der Focus auf dieser Zelle liegt.
         * @param row
         *            Zeile in der die Zelle liegt.
         * @param column
         *            Spalte in der die Zelle liegt.
         */
        @Override
        public Component getTableCellRendererComponent(JTable table,
                Object value, boolean isSelected, boolean hasFocus, int row,
                int column) {
            super.getTableCellRendererComponent(table, value, isSelected,
                    hasFocus, row, column);

            if (isSelected) {
                if (rowForegroundColors.containsKey(row))
                    setForeground(rowBackgroundColors.get(row));
                else
                    setForeground(Color.WHITE);

                if (rowBackgroundColors.containsKey(row))
                    setBackground(rowForegroundColors.get(row));
                else
                    setBackground(Color.BLACK);
            }
            else {
                if (rowForegroundColors.containsKey(row))
                    setForeground(rowForegroundColors.get(row));
                else
                    setForeground(Color.BLACK);

                if (rowBackgroundColors.containsKey(row))
                    setBackground(rowBackgroundColors.get(row));
                else
                    setBackground(Color.WHITE);
            }

            return this;
        }

        /**
         * Setzt die Vordergrundfarbe für die angegebene Zeile.
         * @param row Zeilennummer (0 ist die erste)
         * @param color Vordergrundfarbe
         */
        public void setRowForegroundColor(int row, Color color) {
            rowForegroundColors.put(new Integer(row), color);
        }

        /**
         * Setzt die Hintergrundfarbe für die angegebene Zeile.
         * @param row Zeilennummer (0 ist die erste)
         * @param color Hintergrundfarbe
         */
        public void setRowBackgroundColor(int row, Color color) {
            rowBackgroundColors.put(new Integer(row), color);
        }
    }

    private JTable myTable;

    /**
     * Der Konstruktor dieser Beispielklasse. Hier wird die grafische
     * Oberfläche erzeugt.
     */
    public TableColoring() {
        setLayout(new GridBagLayout());
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.insets  = new Insets(0, 0, 0, 0);
        gbc.fill    = GridBagConstraints.NONE;

        gbc.gridx    = 0;
        gbc.gridy    = 0;
        gbc.weighty  = 1.0;
        gbc.weightx  = 1.0;
        gbc.fill     = GridBagConstraints.BOTH;
        DefaultTableColumnModel columnModel1 = new DefaultTableColumnModel();
        {
            TableColumn col1 = new TableColumn(0, 50);
            col1.setHeaderValue("Code");
            col1.setMaxWidth(50);
            columnModel1.addColumn(col1);
            TableColumn col2 = new TableColumn(1, 350);
            col2.setHeaderValue("Beschreibung");
            columnModel1.addColumn(col2);
        }
        MyTableModel tableModel = new MyTableModel();
        myTable = new JTable(tableModel, columnModel1);
        myTable.setDefaultRenderer(Object.class, new MyTableRenderer());
        JScrollPane scrollPane = new JScrollPane(myTable);
        scrollPane.setPreferredSize(new Dimension(400, 300));
        add(scrollPane, gbc);

        fillTable(tableModel);
        startGui();
    }

    /**
     * Füllt die Tabelle mit Testdaten.
     *
     * @param tableModel Tabellenmodell der zu befüllenden Tabelle.
     */
    private void fillTable(MyTableModel tableModel) {
        /* Datenobjekte für die Tabelle füllen: */
        TableEntry entry1 = new TableEntry("11", "Anbau einjähriger Pflanzen");
        TableEntry entry2 = new TableEntry("12", "Anbau mehrjähriger Pflanzen");
        TableEntry entry3 = new TableEntry("13", "Betrieb von Baumschulen "
                + "sowie Anbau von Pflanzen zu Vermehrungszwecken");
        TableEntry entry4 = new TableEntry("14", "Tierhaltung");
        TableEntry entry5 = new TableEntry("15", "Gemischte Landwirtschaft");

        /* Farben bilden: */
        Color red = createJavaColor("red");
        Color blue = createJavaColor("blue");
        Color orange = createJavaColor("FF6600");
        Color gold = createJavaColor("ffd700");
        Color lightseagreen = createJavaColor("20b2aa");

        /* Daten mit den passenden Farben an die Tabelle anhängen: */
        tableModel.addEntry(entry1, red);
        tableModel.addEntry(entry2, blue);
        tableModel.addEntry(entry3, orange);
        tableModel.addEntry(entry4, gold);
        tableModel.addEntry(entry5, lightseagreen);

        /* Die Tabelle darüber informieren, dass sich ihr Inhalt geändert hat: */
        tableModel.fireTableDataChanged();
    }

    /**
     * Bildet aus einem der für die Anzeige als HTML-Datei gebildeten Farbnamen
     * der Form "red" oder "FF0000" ein passendes Color-Objekt.
     *
     * (Siehe auch http://tomheller.de/theholycymbal/html-farben.html für ggf.
     * weitere benannte Farben.)
     *
     * @param namedColor
     *            Benannte HTML-Farbe
     * @return Color-Objekt mit der entsprechenden Farbe
     */
    private Color createJavaColor(String namedColor) {
        Color color;

        /* Benannte Farben mit den passenden Werten bilden: */
        if ("red".equals(namedColor))
            color = new Color(255,   0,   0);
        else if ("yellow".equals(namedColor))
            color = new Color(255, 255,   0);
        else if ("blue".equals(namedColor))
            color = new Color(  0,   0, 255);
        else if ("green".equals(namedColor))
            color = new Color(  0, 128,   0); // 008000
        else if ("purple".equals(namedColor))
            color = new Color(128,   0, 128); // 800080
        else if ("maroon".equals(namedColor))
            color = new Color(128,   0,   0); // 800000
        else if ("olive".equals(namedColor))
            color = new Color(128, 128,   0); // 808000
        else if ("navy".equals(namedColor))
            color = new Color(  0,   0, 128); // 000080
        else if ("teal".equals(namedColor))
            color = new Color(  0, 128, 128); // 008080
        else if ("gray".equals(namedColor))
            color = new Color(128, 128, 128); // 808080
        else if ("silver".equals(namedColor))
            color = new Color(192, 192, 192); // c0c0c0
        else if ("lime".equals(namedColor))
            color = new Color(  0, 255,   0); // 00ff00
        else if ("fuchsia".equals(namedColor))
            color = new Color(255,   0, 255); // ff00ff
        else if ("black".equals(namedColor))
            color = new Color(  0,   0,   0);
        else if ("white".equals(namedColor))
            color = new Color(255, 255, 255);
        else if ("orange".equals(namedColor))
            color = new Color(255, 102,   0); // FF6600

        /* Bei Farben der Art ff00b4 den Wert umrechnen und verwenden: */
        else if (namedColor.length() == 6)
            color = new Color(Integer.parseInt(namedColor, 16));

        /* Falls die Farbe nicht erkannt wurde, nehmen wir schwarz: */
        else
            color = new Color(0, 0, 0);

        return color;
    }

    /** Startet die grafische Oberfläche. */
    private void startGui() {
        setLocation(100, 100);
        pack();
        setVisible(true);
    }

}```

Sorry, ich verstehe das nicht so ganz :frowning:

Ich kriege das einfach nicht hin, dass er nur jeweils eine Zeile färben soll, abhängig davon ob zb.

int select

1 oder 2 ist.

Ist das nicht einfacher möglich :wink: ?

import javax.swing.table.DefaultTableCellRenderer;

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

public class CustomCellRenderer extends DefaultTableCellRenderer {

	 private String columnName;
	 
	 public CustomCellRenderer(String column) {
	     this.columnName = column;
	     setOpaque(true);
	 }
	 public Component getTableCellRendererComponent(JTable table, int select, int row, int column) {
         if (select == 1) {
             table.setBackground(Color.RED);
             System.out.println(row);
	     }
	     else {
	     	 table.setBackground(Color.BLACK);
	     	 System.out.println(row);
	     }
	     return this;
	 } 
} ```

```        int test1 = 2;
        ((DefaultTableModel)jTable1.getModel()).setRowCount(0);
        if (jCheckBox1.isSelected() == true) {
        	for (int x = 2; x < getArrayListSize(); x += 3) { 
                if (x <= newArrayList.size()) {
                    // Check if description contains in the new map-file and not in the old map-file
                    if (!oldArrayList.contains(newArrayList.get(x)) && (newArrayList.get(x) != "-")){
                        ccr.getTableCellRendererComponent(jTable1, test1, 2, 2);
                        ((DefaultTableModel)jTable1.getModel()).addRow(new Object[]{newArrayList.get(x-2), newArrayList.get(x-1), newArrayList.get(x)});
                    }	        		
                }
        	}
        } 
       int test = 1;
        if (jCheckBox2.isSelected() == true) {
        	for (int x = 2; x < getArrayListSize(); x += 3) { 
                if (x <= oldArrayList.size()) {
	                // Check if description contains in the old map-file and not in the new map-file
	                if (!newArrayList.contains(oldArrayList.get(x))) {
                        ccr.getTableCellRendererComponent(jTable1, test, 1, 2);
                        ((DefaultTableModel)jTable1.getModel()).addRow(new Object[]{oldArrayList.get(x-2), oldArrayList.get(x-1), oldArrayList.get(x)});
                    }	        		
                }
        	}
        } ```

Gibt es keine Möglichkeit dem SetBackground zu sagen, dass man nur eine Zeile von meinem jTable1 färben möchte?

JTable ist ein umfassendes und eher komplexes Thema, das Renderingkonzept und die TableCellRenderer werden im Link von L-extron-x erläutert.

Man muss schon die getTableCellRendererComponent Methode des DefaultTableCellRenderer überschreiben, eine eigene Methode zu erfinden nutzt nichts. Siehe oben genannten Link

Wie gesagt, gibt es nur die Möglichkeit via Renderer oder nachgelagert in der überschriebenen prepareRe… der JTable. Noch einfacher geht nicht.

Du müsstest setBackground(...) nicht bei der Tabelle sondern nur bei dem jeweiligen CellRenderer aufrufen, und zwar jedesmal wenn eine TableCell gezeichnet wird. Dazu muss der CellRenderer natürlich bei jedem mal Zeichnen feststellen können welchen Wert select für die jeweilige Zeile hat. Wie schon vorgeschlagen wäre es praktisch wenn es dafür eine eigene Spalte im Modell gibt. Die Tabelle sähe dann z.B. so aus:

Einen simplen CellRenderer, der eine Cell entsprechend dem select-Wert der Zeile einfärbt, kann man dann folgendermaßen setzen:

        jTable1.setDefaultRenderer( Object.class, new DefaultTableCellRenderer() {

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

                Component component = super.getTableCellRendererComponent( table, value, isSelected, hasFocus, row, column);
                int select = (int)table.getModel().getValueAt(row, 0 );

                if( select == 1 ) {
                    component.setBackground(Color.yellow);
                } else {
                    component.setBackground(Color.cyan);
                }

                return component;
            };

        });

Ergebnis:

Den Wert für select kann man sich in der Methode freilich auch von woanders her besorgen, allerdings ist er im TableModell schon gut untergebracht.

Falls die Spalte “select” nicht angezeigt werden soll kann man sie auch aus der Darstellung der Tabelle entfernen (sie ist danach immer noch im TableModell enthalten, wird aber halt nur nicht mehr angezeigt):

        TableColumnModel columnModel = jTable1.getColumnModel();
        columnModel.removeColumn( columnModel.getColumn( 0 ) );

Ergebnis:

leider sehe ich nicht wie die Tabelle aussehen könnte!?

Und nach Ergebnis: ? Fehlt da noch etwas? :confused:

Aber ich glaube mir das vorstellen zu können! Das ist eine super Idee! Ich probier das dann mal aus!

[QUOTE=izloh]leider sehe ich nicht wie die Tabelle aussehen könnte!?

Und nach Ergebnis: ? Fehlt da noch etwas? :/[/QUOTE]

Hmm, bei mir werden dort Bilder angezeigt. Hatte die bei irgendeinem image-hoster hochgeladen. Sind die bei dir nicht zu sehen?

Bild1: Standard-Tabelle mit eigener Spalte für select
Bild2: Tabelle mit bunten Zeilen dank eigenem CellRenderer
Bild3: Tabelle mit bunten Zeilen, bei der die select-Spalte nicht angezeigt wird