Datenaufbereitung über JTabbedPane, JList und JTable – Tutorial

In der Java Oberflächenprogrammierung liest in der Regel der Softwareentwickler Daten aus einer Datenbank um sie anschließend visuell in seinem Programm zu veranschaulichen. Für die Veranschaulichung gibt es unterschiedlichste Möglichkeiten.
In diesem Tutorial wird gezeigt, wie Daten beispielsweise in einer Liste oder in einer Tabelle visuell aufbereitet werden können. Das Ganze wird in einer Anwendung in zwei verschiedenen Tabs dargestellt.

[ad#co-3]

Die Darstellung der Daten (hier: Kundendaten) wird in vier Klassen abgebildet, wobei die Herkunft (Zugriff auf die Datenbank) der Kundendaten in diesem Tutorial keine Rolle spielt. Die Klassen befinden sich alle (mit Ausnahme von Customer.java) in einem Package, welches den Namen gui trägt.

Hinweis: Wie Daten aus einer Datenbank gelesen werden können, wird in folgenden Tutorials veranschaulicht:

Die hier verwendeten Daten werden aus der MySQL Testdatenbank Sakila geladen.

CustomerView.java

Diese Klasse ist die Starterklasse. Die Oberfläche besteht aus einer JTabbedPane, welche zwei Tabs mit den entsprechenden Ansichten beinhaltet.

package gui;

import javax.swing.JFrame;
import javax.swing.JTabbedPane;

public class CustomerView extends JFrame
{
	public CustomerView()
	{
		setTitle("Kundenansicht - www.itblogging.de");
		
		// Erstellen einer Tabbed-Ansicht
		JTabbedPane tabber = new JTabbedPane();
		// ein Tab wird hinzugefügt und mit der Listenansicht gefüllt 
		tabber.add("Listenansicht", new ListView());
		// ein Tab wird hinzugefügt und mit der Tabellenansicht gefüllt
		tabber.add("Tabellenansicht", new TableView());
		// das TabbedPane wird der Oberfläche hinzufüget
		add(tabber);
		// die Größe des Fensters beträgt 400x300 ...
		setSize(400,300);
		// ... und soll natürlich sichtbar sein
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
	
	public static void main(String[] args)
	{
		new CustomerView();
	}
}

Customer.java

Der Aufbau eines Kunden ist in diesem Tutorial minimal gehalten. So hat ein Kunde einen Vornamen, Nachname sowie eine E-Mail Adresse. Die Klasse ist trivial und besteht im Allgemeinen nur aus getter und setter Methoden. Hinzu kommt die toString() Methode, welche bei Aufruf der Klasse den Nachnamen und den Vornamen ausgibt.

public class Customer
{
	private String firstName;
	private String lastName;
	private String eMail;
	
	/*
	 *  getter und setter
	 *  ....
	 */
	
	@Override
	public String toString()
	{
		return lastName + ", " + firstName; 
	}
}

ListView.java

In dieser Klasse wird eine Liste mit den Kundendaten bereitgestellt. Wichtig ist, das die JScrollPane nicht vergessen wird, damit schlussendlich alle Kundendaten durch einen Scrollbalken angezeigt werden können.
Hinweis: getCustomerList() liefert eine Kundenliste. Mit dem Aufruf toArray() wird die toString() Methode von Customer.java aufgerufen.

package gui;

import java.awt.BorderLayout;
import java.util.ArrayList;

import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JScrollPane;

import model.Customer;
import model.CustomerList;

public class ListView extends JLabel
{
	public ListView()
	{
		setLayout(new BorderLayout());
		
		/*
		 *  eine Liste mit Kunden wird geholt
		 *  der genaue Aufbau (Datenbank, Model, etc.) soll an dieser Stelle
		 *  keine Rolle spielen.
		 */
		ArrayList<Customer> customerList = CustomerList.getInstance().getCustomerList();
		// über toArray() wird die toString() Methode aufgerufen. Ausgegeben wird <Nachname, Vorname>
		JList list = new JList(customerList.toArray());
		// die Liste wird scrollbar an die view übergeben
		add(new JScrollPane(list));
	}
}

TableView.java

Etwas spannender hingegen ist die Darstellung einer Tabelle. Die Magie jedoch passiert in dem Model der Tabelle. Diese wird in CustomerTableModel.java etwas näher beschrieben und der Tabelle über setModel() übergeben.

package gui;

import java.awt.BorderLayout;

import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;

public class TableView extends JLabel
{
	public TableView()
	{
		setLayout(new BorderLayout());
		// eine neue Tabelle wird erstellt..
		JTable customerTable = new JTable();
		// ..und das Model gesetzt..
		customerTable.setModel(new CustomerTableModel());
		// ..bevor es der view hinzugefügt wird (wichtig ist, das die Tabelle scrollbar ist)
		add(new JScrollPane(customerTable));
	}
}

CustomerTableModel.java

Das wichtigste einer Klasse die ein Tabellenmodel darstellen soll, ist zunächst die Implementierung der Klass TableModel. In Eclipse wird in der Regel der Programmierer darauf aufmerksam gemacht, alle fehlenden Methoden automatisch zu implementieren.
Diese Methoden bauen die Tabelle auf, in dem beispielsweise die Tabellenköpfe, die Anzahl der Zeilen oder Editierbarkeit gesetzt wird.
Auch an dieser Stelle noch einmal der Hinweis, das über getCustomerList() eine Kundenliste über eine Datenbank ausgelesen wird worauf in diesem Tutorial nicht näher eingegangen wird.

package gui;

import java.util.ArrayList;

import javax.swing.event.TableModelListener;
import javax.swing.table.TableModel;

import model.Customer;
import model.CustomerList;

public class CustomerTableModel implements TableModel 
{
	ArrayList<Customer> customerList = null;
	
	public CustomerTableModel()
	{
		/**
		 *  getCustomerList() liefert eine ArrayList mit Kunden
		 *  der genaue Aufbau (Datenbank, Model, etc.) soll an dieser Stelle
		 *  keine Rolle spielen. 
		 */
		customerList = CustomerList.getInstance().getCustomerList();
	}

	/**
	 * Liefert die Anzahl der gelisteten Kunden
	 */
	@Override
	public int getRowCount()
	{
		return customerList.size();
	}

	/**
	 * setzt die Anzahl der Spalten 
	 * hier: Vorname,Nachname,eMail = 3
	 */
	@Override
	public int getColumnCount()
	{
		return 3;
	}

	/**
	 * setzt die Spaltennamen
	 */
	@Override
	public String getColumnName(int columnIndex)
	{
		switch (columnIndex)
		{
			case 0: return "Vorname";
			case 1: return "Nachname";
			case 2: return "E-Mail";
			default: break;
		}
		return null;
	}

	/**
	 * setzt den Typ des Inhalts einer Tabellenzelle
	 * hier: es handelt sich immer um Strings
	 */
	@Override
	public Class<?> getColumnClass(int columnIndex)
	{
		return String.class;
	}

	/**
	 * kann spezifische Zellen editierbar setzen
	 * hier: alle Zellen sind nicht editierbar
	 */
	@Override
	public boolean isCellEditable(int rowIndex, int columnIndex)
	{
		return false;
	}

	/**
	 * liefert den Inhalt der einzelnen Zellen
	 */
	@Override
	public Object getValueAt(int rowIndex, int columnIndex)
	{
		switch (columnIndex)
		{
			case 0: return customerList.get(rowIndex).getFirstName();
			case 1: return customerList.get(rowIndex).getLastName();
			case 2: return customerList.get(rowIndex).geteMail();
			default: break;
		}
		return null;
	}

	
	@Override
	public void setValueAt(Object aValue, int rowIndex, int columnIndex)
	{
		// wenn die Zellen editierbar sind können die neuen Inhalte hier geschrieben werden
	}

	@Override
	public void addTableModelListener(TableModelListener l)
	{}

	@Override
	public void removeTableModelListener(TableModelListener l)
	{}
}

Ergebnis

Im Ergebnis erhalten wir eine Anwendungen die aus zwei Tabs besteht. In dem Tab „Listenansicht“ wird der Inhalt der Klasse ListView.java dargestellt und in der „Tabellenansicht“ der Inhalt aus TableView.java.
Offensichtlich ist, das in der Listendarstellung die toString() Methode des Customers aufgerufen wird und in der Tabellenansicht explizit jeder Spalte einen Wert des Objektes zugewiesen wurde.

Listenansicht

Listenansicht

Tabellenansicht

Tabellenansicht