Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
ich möchte aus dem jTable2 gerne die ausgewählte Reihe löschen.
Wenn ich das über das DefaultTableModel mache geht das. Allerdings über mein selber gemachtes Model nicht. Muß ich die Methode für "removeRow" irgendwie vererbbar machen oder wie mache ich das?
Ich weiß gar nicht wie ich die Überschrift für das Problem nennen soll.
> du musst natürlich die abstrakte Klasse AbstractTable implementieren und nicht DefaultTable erweitern...
von AbstractTableModel muss man technisch gesehen auch erweitern/ erben, ist kein Interface
allgemein kann durchaus auch DefaultTableModel die Grundlage sein, je nachdem wie man es machen will,
ohne den Code von MeinFixedTableModel, besonders den Code zum Entfernen von Zeilen, kann man offensichtlich nur schwer beurteilen, was daran nicht funktioniert
public class MeinFixedTableModel extends AbstractTableModel{
public int getRowCount()
{return data1.length;}
public int getColumnCount()
{return 2;}
public Object getValueAt( int row, int col )
{return data1[row][col];}
public String getColumnName(int col)
{return (String)column1[col];}
public boolean isCellEditable(int row, int column) {
return (true);
}
Wie würde der Code nun für das RemoveRow aussehen wenn ich den da einfügen würde?
Danke für die schnellen Antworten.
Ich hätte nicht gedacht, dass es so kompliziert ist. Es exisitiert mehrere ArrayListen die nicht nur Text sondern auch Werte der Rahmen enthält. Diese wird jedes mal wenn eine Aktion eintritt (Hinzufügen von Zeile - jTablewerte laden, Rahmen setzen usw). Da jetzt dran rumspielen würde sehr viel Arbeit und umformen bedeuten. Im Prinzip soll (bzw. DARF) es nur die gleiche Funktion haben wie:
DefaultTableModel removeRow() entfernt eine Zeile aus den DefaultTableModel-Daten,
genauso könntest du etwas aus deinen Daten entfernen, bisher ist nur das data-Array zu sehen, keine anderen Daten die du benennst,
das ist ziemlich dasselbe
du kannst auch komplett auf eigenes Model verzichten und ein DefaultTableModel verwenden, welchem du deine Daten übergibst
----
kompliziert denkbar wäre, die Daten-Arrays usw. unverändert zu lassen und nur im Model zu merken, welche Indexe aktuell erlaubt sind,
das Löschen einer Zeile hieße dann 'Index 5 ignorieren, Size-1, Index 6 danach ist Zeile 7 in Ursprungsdaten' usw.,
eher noch schlimmer als direkt zu löschen
Einfach ist relativ. Ich würde das als nicht sonderlich kompliziert einschätzen. Man muss ja nur eine Kopie eines Arrays erstellen, exklusive eines bestimmten Datensatzs. Ist ja eine klassische Anfängerübung.
Da aber nun mal Dein TableModel auf data1 basiert (s. z.B. getValueAt()) bleibt Dir fast nichts anderes übrig. Die anderen theoretischen Möglichkeiten, sind eher noch komplizierter.
Etwas mehr Code...
Ich hatte an anderer Stelle schonmal Hilfe benötigt um die ersten 2 Spalten sozusagen einzufrieren.
Um dies zu realisieren mußte ich einen 2ten Table machen, der ein eigenes Model besitzt. Mit dem DefaultTableModel ging dies nicht. Somit wird beim transferieren der Daten aus der Datenbank in den jTable erstmal die ganze Tabelle gelöscht. Das hatte ich mit dieser FOR-Schleife realisiert.
Ich habe aber auch noch die Funktion "Löschen" wo dann die mit der Maus ausgewählte Reihe gelöscht wird (eher: alles mit dem Rahmenumschlungene). Ich möchte jetzt ungern in die systematik der Rahmen und Texte mich einmischen.
Hier nochmal die Screenshot.
http://www.dj-t-motion.de/fmeascreen.jpg
Bitte haltet euch nicht an Data1 fest. Das ist erstmal nur zum testen. Später wird data1 sehr statisch, das muß ich acuh noch umsetzen, aber ich wollte jetzt das was im jTable1 ist erstmal auch genauso (nur das es diesmal ein eigenes tableModel ist, umsetzen)
wie würde das Codemäßig aussehen wenn er einen refresh macht mit der untersten Zeile weniger in einem Array?!
Später wird data1 sehr statisch, das muß ich acuh noch umsetzen, aber ich wollte jetzt das was im jTable1 ist erstmal auch genauso (nur das es diesmal ein eigenes tableModel ist, umsetzen)
Wie gesagt, Du musst einfach nur eine neues Array ohne die entsprechende "Zeile" erstellen und dieses der usprünglichen Variablen zu weisen. Woran scheitert es denn?
Hier mal eine Möglichkeit um einen beliebigen Index (im Bsp. Index 3) aus einem Array zu löschen:
Java:
int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.println(java.util.Arrays.toString(a));
int[] b = new int[a.length-1];
int toDelete = 3;
int bCounter = 0;
for (int i=0; i<a.length; i++) {
if (i!=toDelete) {
b[bCounter++] = a[i];
}
}
a = b;
System.out.println(java.util.Arrays.toString(a));
deine vorherigen Themen sind mir zumindest wohlbekannt, aber es ändert nichts daran dass du wie immer keine richtigen Fragen stellst, keinen Code postest, keine Fehler oder konkreten Probleme beschreibst
> wie würde das Codemäßig aussehen wenn er einen refresh macht mit der untersten Zeile weniger in einem Array?!
es wurde doch schon dazu was geschrieben, neues Array anlegen, Zeilen kopieren, was soll man mehr sagen außer für dich die Programmierung zu übernehmen?
du musst mitarbeiten, was ist ganz konkret das Problem?
kannst du ein Array mit der Länge um 1 kleiner anlegen, ja oder nein?
kannst du das vorhandene Array mit einer for-Schleife durchlaufen, ja oder nein?
bezieht sich deine Frage unabhängig von dem Array auf das 'refresh machen', was immer du damit meinst, ja oder nein?
wie genau kommt es bei dir eigentlich zum Löschen, wird ein Button gedrückt?
alles musst du haargenau ausführlich beschreiben, Code dazu posten und und und
wenn du mit dem Array Probleme hast, könntest du etwa deine TableModel usw. vorerst vergessen und dich einem ganz anderen Programm widmen
Java:
public class Test
{
public static void main(String[] args)
{
int[] a = {1,2,3,4,5};
// wie kann ein Array b erstellt werden wie a mit einer Zeile weniger
}
}
ist das deine Frage, ja oder nein?
(edit: Lösung inzwischen vorhanden, sogar auch mit int[] a und b )
--------
generell noch ein Tipp, da ich das andere mit der doppelten Tabelle etwas kenne:
versuche nicht alles immer in dein kompliziertes Hauptprogramm einzubauen,
du kannst doch auch erstmal ein komplett anderes neues JFrame anfangen mit EINER Tabelle,
mit vergleichbaren individuellen Model auf einfachen Dummy-Daten, und dort das Löschen üben
je einfacher die Programme, desto leichter kannst du hier dann auch den Code dazu posten,
ohne unseliges GroupLayout, GUI-Builder und sonstige Altlasten, die keine Rolle spielen
ob danach der Einbau in dein Hauptprogramm klappt ist eine weitere Frage,
aber von einem Nebenprogramm mit funktionierenden Löschen wäre es eine ganz andere Ausgangslage
Tut mir leid, dass ich immer so unkonkret frage.
Im Prinzip hab ich das Problem, dass es mir 1. so vorkommt, wenn ich nun die methode removeRow(int reihe) überschreibe, dass ich dann da sozusagen komplizierten Code schreiben muss, damit er in die tiefen Niederungen der jTable Reihenlöschung vordringen muss und ich mir nicht vorstellen kann wie man das mit normaler programmierung hinbekommt - sonst hätte ja auch die removeRow methode- im AbstractTableModel mit drinnenstecken können.
Wenn ich jetzt die 2.Reihe löschen möchte, würde ich das irgendwie schon hinbekommen, aber ich frage mich, ob dann nicht die untereste Zeile im jTable leer bleibt, ich will ja nicht Text gelöscht haben sondern überhaupt den schreibbaren bereich.
Ja im normalfall (wie es auch bei dem anderen Problem bei dem gefrieren war) versuche ich es mit einem kleinen Programm. Das ich hier an so eine komplizierte Stelle stoße hätte ich nicht gedacht. Also hier konkret:
wie muss
Java:
public void removeRow(int reihe){
}
aussehen, damit z.b. die dritte Zeile gelöscht wird. Das Beispiel von Michael... (danke dafür) war mir für ein normales Array klar.
mit dem refreshen meinte ich, wenn ich jetzt data1 umändern würde, wäre das dann sofort da oder muss man noch enien refresh machen ? Ich blamiere mich hier gerade so... Aber zu meiner Rettung hab ichs ja in den Anfängerbereich gepostet
Wenn ich jetzt die 2.Reihe löschen möchte, würde ich das irgendwie schon hinbekommen, aber ich frage mich, ob dann nicht die untereste Zeile im jTable leer bleibt, ich will ja nicht Text gelöscht haben sondern überhaupt den schreibbaren bereich.
für ein zweidimensionales Array geht es genauso, das ist eigentlich auch nur ein normales Array, nur dass die einzelnen Elemente keine ints sind sonder zufällig auch (dann eindimensionale) Arrays
> ob dann nicht die untereste Zeile im jTable leer bleibt, ich will ja nicht Text gelöscht haben sondern überhaupt den schreibbaren bereich.
dafür gibts ja die Methode
> public int getRowCount() {return data1.length;}
die 1 weniger zurückliefern wird -> Tabelle kleiner
Danke, das refreshen durch fireTableRowDeleted klappt (jedenfalls werden direkt die passenden Rahmen angezeigt was vorher erst durch klicken auf die Zeilen geschah).
ich habe jetzt mal spaßeshalber
Java:
public int removeRow(int reihe){
return data1.length-1;
}
gemacht in der Hoffnung, dass der jTable dann um eine Zeile kürzer wird. Ist aber leider nicht der Fall
Sorry, dann habe ich gar keine Ahnung wie man überhaupt was am Table dort verändern kann.
ich dachte in der RemoveRow methode muß ich nun Data1 verändern und wenn Data1 als Return ausgegeben wird dann ändert sich somit auch der jTable wenn er refreshed wird oder denke ich da falsch ?
Also muß es theoretisch so aussehen:
Java:
public Object removeRow(int reihe){
return data1;
}
und in der methode selbst muß data1 verändert werden, oder?
was läßt dich vermuten, dass die Rückgabe irgendwas bringen könnte?
weder JTable noch jemand sonst in der GUI ruft diese Methode auf,
das machst du höchstens selber, etwa im Listener eines Buttons, und dann nutzt du den Rückgabewert ja nicht..,
grundsätzlich muss man irgendwo aufgeschnappt haben, dass bei TableModel die Benachrichtigung der JTable wichtig ist,
damit diese reagieren kann, AbstractTableModel bietet dafür fireXY()-Methoden, ansonsten muss man es selber machen,
die JTable sollte als TableModelListener registriert sein, da gibt es letzlich nur eine Methode
was macht DefaultTableModel remove? kann man nachschauen, wenn auch wieder nicht ganz leicht, Quellcode nötig:
Java:
/**
* Removes the row at <code>row</code> from the model. Notification
* of the row being removed will be sent to all the listeners.
*
* @param row the row index of the row to be removed
* @exception ArrayIndexOutOfBoundsException if the row was invalid
*/
public void removeRow(int row) {
dataVector.removeElementAt(row);
fireTableRowsDeleted(row, row);
}
Daten ändern, Tabelle informieren,
nichts mit Rückgabewert oder sonstiges
Danke, der denkansatz hilft mir weiter...
Nur, dass data1 bei mir halt ein blödes Object [][] Array ist. Im Prinzip soll es ja einfach nur leer sein und keine Daten beinhalten bis der Benutzer das ändert.
Wie man sieht soll data1 am Anfang leer sein, aber die Zeile
Java:
public Object getValueAt( int row, int col )
{return data1[row][col];}
wird dann zu einem Error (Exception in thread "AWT-EventQueue-0" java.lang.ArrayIndexOutOfBoundsException: 0). Wieso kann er das nicht so akzeptieren ?
Eigentlich wollte ich ja gar nicht mit Arrays arbeiten sondern einfach nur eine Zeile im jTable löschen. Echt blöd, dass das nicht so einfach geht. In meinem Programm habe ich keine extra Klasse für die Tables gemacht, da ich logischerweise von dort aus nicht auf Data1 zugreifen kann und ergänzende Zeilen wie:
Java:
public Object getValueAt( int row, int col, Object[][] data1 )
{return data1[row][col];}
bringen einen da wohl auch nicht weiter. Ich weiß nicht mehr weiter....
Hier mein Programmcode:
Java:
public class FmeaHauptSeite extends javax.swing.JFrame {
final Color color = UIManager.getColor("Table.gridColor");
// DefaultTableModel dtm;
int markierteSpalte;
Globales gb = new Globales();
Object[][] data1 = {{}};
Object[] column1 = {"No", "Funktion", "pot.Fehler", "pot.Folge", "B", "pot.Ursache", "A", "V/P", "aktuelle Maßnahme", "E", "RPZ", "empfohlene Maßnahme", "zu erledigen durch/bis", "getroffene Maßnahme", "B", "A", "E", "RPZ", "Status"};
String StrID = "";
// List list = new ArrayList( Arrays.asList( new String[]{"Purzelchen", "Hässchen"} ) );
AktuelleRahmen komplettrahmen = new AktuelleRahmen();
List<Integer> funktionRahmenliste = new ArrayList<Integer>();
List<Integer> potFehlerRahmenliste = new ArrayList<Integer>();
public class MeinTableModel extends AbstractTableModel{
public int getRowCount()
{return 0;}
public int getColumnCount()
{return 2;}
public Object getValueAt( int row, int col )
{return data1[row][col];}
}
public class MeinFixedTableModel extends AbstractTableModel{
public int getRowCount()
{return data1.length;}
public int getColumnCount()
{return 2;}
public Object getValueAt( int row, int col )
{return data1[row][col];}
public String getColumnName(int col)
{return (String)column1[col];}
public boolean isCellEditable(int row, int column) {
return (true);
}
public void removeRow(int row) {
// data1.removeElementAt(row);
fireTableRowsDeleted(row, row);
}
}
// Um überall an die Daten zu kommen
public void setData1(Object[][] dataOrg){
data1 = dataOrg;
}
public Object[][] getData1(){
return data1;
}
public void setColumn1(Object[] dataOrg){
column1 = dataOrg;
}
public Object[] getcolumn1(){
return column1;
}
> wird dann zu einem Error (Exception in thread "AWT-EventQueue-0" java.lang.ArrayIndexOutOfBoundsException: 0). Wieso kann er das nicht so akzeptieren ?
was hat das mit dem remove zu tun?
anscheinend hast du das remove noch nicht implementiert, dann ist das doch ein vollkommen unabhängiges Thema?
von einem leeren Array kann nix gelesen werden, ist das nicht sonnenklar?
was verstehst du daran schon wieder nicht? es wäre doch fatal fehlerhaft, wenn Java sich dann einfach einen Wert ausdenken würde
dadurch, dass die getRowCount()-Methoden im Falle eines leeren Arrays auch 0 zurückgeben,
sollte sinnvoll verhindert werden, dass die JTable getValueAt() in diesem Fall überhaupt aufruft,
------
für das remove gilt wie schon vor ca. 1000 Postings, dass du data1 verkleinern musst,
ich sehe aktuell keine Frage?
wobei du in diesem Fall mit data1 außerhalb des Models sowieso auf eine Methode im Model verzichten könntest,
du kannst data1 auch direkt vom Listener eines Buttons ändern, oder wo immer das remove angestoßen wird,
wichtig: du musst in jeden Fall bei BEIDEN Models fireTableRowsDeleted(row, row); aufrufen, damit beide JTable in der GUI informiert werden
-----
Java:
public class MeinTableModel extends AbstractTableModel{
public int getRowCount()
{return 0;}
scheint übrigens ziemlich sinnlos, zu dem Model wird doch wohl in der GUI aktuell nichts angezeigt?
Danke nochmal, ich hoffe dies wird nun mein letzter Post. Das mit dem leeren Array verstehe ich, dass er dann natürlich nicht drauf zugreifen kann, aber das ziel ist es ja denke ich dieses Leer zu bekommen.
Da scheint es so zu sein, als ob ich aus einem Array nicht ein Element löschen kann, sondern es über eine Arraylist machen sollte. Aber ich denke das TableModel kann nur mit normalen Arrays arbeiten. Wie würde ein 2-dimensionale Arraylist von folgendem aussehen ?
Ich habe mal folgendes Versucht, jedes Element auf Null zu machen, immerhin hat dann mein jTable leere Elemente aber die Felder sind noch vorhanden. Wie ich da jetzt aus data1 eine ganze Reihe lösche ist wohl nicht möglich... Naja... Ich hoffe jemand versteht mein Problem
Sorry SlathaB, du gibst Dir echt Mühe aber ich glaube ich verstehe es einfach nicht. Habe bisher immer mit ArrayList gearbeitet und auf diesem Niveau hier wird wohl alles per normalen Array gemacht.
die Methode "data1.removeElementAt(row);" geht mit diesem normalen Array ja auch nicht.
Java:
public void removeRow(int row) {
for (int xx = 0; xx<2;xx++){
System.out.println("Der inhalt: " + jTable2.getValueAt(row, xx));
data1[row][xx]=null;
}
// jTable2.;
fireTableRowsDeleted(row, row);
}
aus einem Array eine Zeile zu löschen wurde ja schon besprochen, ist relativ leicht,
da ist auch nichts auf null zu setzen, sondern kleineres Array + kopieren!
es ist so leicht, es steht schon geschrieben in diesem Thread...
ArrayList ist natürlich schöner, aber auch das musst du im wesentlichen selber machen,
was ist eine Zeile? da kannst du bei einem eindimensionalen Array bleiben oder auch eine Liste wählen,
das für sich musst du als ersten Punkt klären
-----
danach 10 Zeilen (wie auch immer die jeweils umgesetzt sind) in eine Liste einfügen, wo sollte da irgendeine Art von Schwierigkeit bestehen?
ich werde dir niemals irgendwelchen Code schreiben, denken musst du schon selber können
getValueAt() und andere Methoden der TableModel danach passend anpassen
Danke, allerdings verändert sich ja nun ständig die Größe des Array, somit müßte dieses kleine Array dynamisch sein. In dem Beispiel von Michael...
Java:
int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.println(java.util.Arrays.toString(a));
int[] b = new int[a.length-1];
sind das alles statische Arrays, aber meins muss sich ja ständig ändern wenn man eine Zeile hinzufügt bzw löscht. Wie macht man das denn ?
Ich bin jetzt so weit, dass ich soweit von jTable1 in jTable2 ein Abbild durch die ArrayList erstelle (wodurch natürlich irgendwann der Out of Range fehler kommt weil die größen so unterschiedlich sind.
ersetze
> int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
durch
> int[] a = beliebiges ;
am Ende wird ja auch b in a gespeichert,
der eigentliche Code funktioniert für jede Länge, und übrigens auch für jeden Datentyp,
du könntest allein in der Definition des neuen Arrays
> int[] b = new int[a.length-1];
per Texteditor 'int' durch 'String[]' ersetzen und hättest quasi den korrekten Code für dein String[][] ..
Davon reden wir ja die ganze Zeit. Ein Array - einmal erstellt - hat eine feste, unveränderliche Größe. Wenn Du Zeilen hinzufügst oder entfernst, muss ein neues Array erzeugt (Bsp. Zeile 3) und der ursprünglichen Variablen zugewiesen (Bsp. Zeile 11) werden.
