JTable Column (Spalten ausblenden/filtern?)

S

sportingt

Mitglied
Hallo.
kann man die Sichtbarkeit von Spalten steuern?

Habe eine JTable die ich mit Daten aus einem ResultSet zeilenweise fülle.

Ich möchte jetzt je nach Bedarf Spalten ein- oder ausblenden, also verschiedene Ansichten der Tabelle erzeugen. Wie geht das?
Column scheint ja keine Methode setVisible() zu haben!

z.B. Tabelle mit fünf Spalten
Ansicht 1: Sp1(visible), Sp2(visible),Sp3(visible),Sp4(visible),Sp5(visible)
Ansicht 2: Sp1(invisible), Sp2(visible),Sp3(visible),Sp4(visible),Sp5(invisible)
Ansicht 3: Sp1(visible), Sp2(invisible),Sp3(visible),Sp4(invisible),Sp5(visible)

Die Reihen sollen aber immer aus fünf Werten bestehen, halt nur nicht sichtbar sein?

mfg
sportingt

:confused:
 
Zuletzt bearbeitet:
Hab irgendwann mal ein "Universal"-TableModel gemacht, vllt. hilft dir das:
(Ist nicht mehr auf dem neusten Stand -> Vector <Integer> wäre vermutlich besser bei ids)
Code: 
import javax.swing.table.*;
import javax.swing.JTable;
import java.util.*;
/**
* <p>Überschrift: </p> 
* 
* <p>Beschreibung: </p> 
* 
* <p>Copyright: Copyright (c) 2003</p> 
* 
* <p>Organisation: </p>
* 
* @author Tobias Viehweger
* @version 1.0
*/
public class MyTableModel
	extends AbstractTableModel {
private int nonEditCols[] = null;
protected Vector data = new Vector();
protected Vector columnNames = new Vector();
protected Vector columnIds = new Vector();
protected Vector columnHidden = new Vector();
public MyTableModel(Object[] names, int[] ids, boolean[] hidden) {
	if (names.length == ids.length && names.length == hidden.length) {
	 for (int i = 0; i < names.length; i++) {
		columnNames.addElement(names[i]);
		columnIds.addElement(ids[i] + "");
		columnHidden.addElement(hidden[i] + "");
	 }
	}
}
public void addRow(Object[] data) {
	addRow(toVector(data));
}
private Vector toVector(Object[] data) {
	Vector ret = new Vector();
	for (int i = 0; i < data.length; i++) {
	 ret.addElement(data[i]);
	}
	return ret;
}
public void addRow(Vector d) {
	insertRow(data.size(), d);
}
 
public void setColumnHidden(int column, boolean hidden) throws Exception{
	if (column < columnIds.size()) {
	 setColumnHidden((String)columnNames.elementAt(columnIds.indexOf(column+"")),hidden);
	}else {
	 throw new Exception("Fehler: Index größer als Spaltenanzahl");
	}
}
public void setColumnHidden(String name, boolean hidden) throws Exception {
	if (!columnNames.contains(name))
	 throw new Exception("Fehler: Spalte nicht gefunden");
	int index = columnNames.indexOf(name);
	if (hidden) {
	 if (!isHidden(index)) {
		setHidden(index, true);
	 }
	}else {
	 if (isHidden(index)) {
		setHidden(index, false);
	 }
	}
	fireTableStructureChanged();
}
private void setHidden (int column ,boolean hidden) {
	columnHidden.setElementAt(hidden+"", column);
}
public boolean isHidden(int column) {
	return (columnHidden.elementAt(column).equals("false")) ? false : true;
}
public void removeRow(int row) {
	data.removeElementAt(row);
	super.fireTableRowsDeleted(row, row);
}
public String getColumnName(int column) {
	Object id = null;
	if (column < columnNames.size()) {
	 id = columnNames.elementAt(getColNonHidden(column)) ;
	}
	return (id == null) ? super.getColumnName(column)
		: id.toString();
}
public void setNotEditableColumns(int[] columns) {
	nonEditCols = columns;
}
public boolean isCellEditable(int row, int column) {
	if (nonEditCols != null) {
	 boolean ret = true;
	 for (int i = 0; i < nonEditCols.length; i++) {
		if (getColNonHidden(column) == nonEditCols[i])
		 ret = false;
	 }
	 return ret;
	}
	else {
	 throw new NullPointerException(
		 "Erst Spalten definieren! (setNonEditableColumns())");
	}
}
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
	( (Vector) data.elementAt(rowIndex)).setElementAt(aValue, columnIndex);
}
public int getColumnCount() {
	return columnNames.size() - getHidden();
}
public int getRowCount() {
	return data.size();
}
public Vector getDataVector() {
	return data;
}
public void setDataVector(Vector data) {
	this.data = data;
	fireTableDataChanged();
}
public void insertRow(int row, Vector rowData) {
	data.insertElementAt(rowData, row);
	fireTableRowsInserted(row, row);
}
public Object getValueAt(int row, int col) {
	Object ret = null;
	if (row < data.size()) {
	 if (col < ( (Vector) data.elementAt(row)).size()) {
		if (nothingIsHidden()) {
		 ret = ( (Vector) data.elementAt(row)).elementAt(col);
		}
		else {
		 int skip = 0;
		 Vector info = ( (Vector) data.elementAt(row));
		 ret = ( (Vector) data.elementAt(row)).elementAt(getColNonHidden(col));
		}
	 }
	}
	return ret;
}
public Object[] getRow (int row)
{
	if (row < data.size())
	{
	 return ((Vector)data.elementAt(row)).toArray();
	}
	return null;
}
public void replaceAll(String column, String with)
{
	for (int i = 0; i< data.size(); i++)
	{
	 Vector row = (Vector)data.elementAt(i);
	 int index = columnNames.indexOf(column);
	 if (index < row.size())
		row.setElementAt(with, index);
	}
	fireTableDataChanged();
}
//Gibt den Spaltenindex zurück, der zu col gehört
private int getColNonHidden(int col) {
	int newCol = 0;
	int count = 0;
	int tmp = 0;
	while (count != col) {
	 if (!isHidden(tmp)) {
		count++;
	 }
	 tmp++;
	}
	if (isHidden(tmp))
	 tmp = getNextNonHidden(tmp);
 
	newCol = tmp;
	return newCol;
}
private int getNextNonHidden(int col) {
	int ret = col;
	while (isHidden(ret)) {
	 ret++;
	}
	return ret;
}
private int getHidden() {
	int skip = 0;
	for (int i = 0; i < columnNames.size(); i++) {
	 if (isHidden(i))
		skip++;
	}
	return skip;
}
public boolean nothingIsHidden() {
	boolean ret = true;
	for (int i = 0; i < columnHidden.size(); i++) {
	 if (columnHidden.elementAt(i).equals("true")) {
		ret = false;
		break;
	 }
	}
	return ret;
}
public void replaceOnly(String column, int[] rows, String with)
{
	int index = columnNames.indexOf(column);
	for (int i = 0; i < rows.length; i++)
	{
	 Vector row = (Vector) data.elementAt(rows[i]);
	 if (index < row.size())
		row.setElementAt(with, index);
	}
	fireTableDataChanged();
}
public void replaceWhere(String column, String where, String with)
{
	int index = columnNames.indexOf(column);
	for (int i = 0; i < data.size(); i++)
	{
	 Vector row = (Vector) data.elementAt(i);
	 if (index < row.size() && row.elementAt(index).equals(where))
		row.setElementAt(with, index);
	}
	fireTableDataChanged();
}
}

Verwendung (Bsp. von mir, kannste ja anpassen):
Code: 
private String names[] =
	 {
	 "Künstler",
	 "Titel",
	 "Album",
	 "Tracknummer",
	 "Genre",
	 "Jahr",
	 "Kommentar",
	 "Komponist",
	 "Ursprünglicher Künstler",
	 "Copyright",
	 "URL",
	 "Kodiert von",
	 "Samplerate",
	 "Länge",
	 "Bitrate",
	 "Dateigröße",
	 "Pfad"
};
 
	int ids[] =
		{
		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
	boolean hidden[] =
		{
		false, false, false, true, true, true, true, true, true, true, true,
		true, true, true, false, true, true};
	dTModel = new MyTableModel(names, ids, hidden);

Am wichtigsten ist für dich vermutlich das hidden-Array, welches angibt ob eine Spalte sichtbar ist oder nicht. Neue Zeilen kannst du mit
Code: 
dTModel.addRow(Object [] data);
hinzufügen, wobei das Array dann halt alle Werte enthalten muss (auch die nicht sichtbaren).

MfG
Tobias
 
Mmmh,

so ganz habe ich das Prinzip noch nicht verstanden :(

An welcher Stelle wird denn jetzt die Sichtbarkeit beeinflusst.

Du Hast in MyTableModel mehrer Methoden

Code: 
private void setHidden (int column ,boolean hidden) {
	columnHidden.setElementAt(hidden+"", column);

public void setColumnHidden(String name, boolean hidden)

Ich sehe nur Operationen die Du mit den Vectoren durchführts.

Wo steht denn jetzt der Constructor oder das Object, welches die Sichtbarkeit beeinflusst?

mfg

sportingt
 
Wo steht denn jetzt der Constructor oder das Object, welches die Sichtbarkeit beeinflusst?
Zum Vergrößern anklicken....
Wie meinst du das?

Also Spalten unsichtbar/sichtbar kannst du mit

Code: 
public void setColumnHidden(String name, boolean hidden)
machen.
Die Methode erwartet den Titel der Spalte und ob sie sichtbar sein soll oder nicht (true für unsichtbar)
 
Wenn du die Spalten einfach nicht anzeigen willst reicht es auch wenn du folgende beide Code Zeilen einfügst.

jTable_A.getColumn("ABC").setMinWidth(0);
jTable_A.getColumn("ABC").setMaxWidth(0);

Somit wird in der Tablle die Spalte ABC nicht mehr angezeigt.
Nur das setzten von ....setMaxWidth(0); reicht nicht aus.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück