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);
}
}```
?
