verständnissproblem mit TableModel

[kleinfritzchen]

Hallo,
Ich habe ein TableModel das mir Daten in einer Liste verwaltet. In dem Model sind die ganz normalen Metoden implementiert (implements TableModel).
Mein Problem ist das ich nicht ganz verstehe wie man eine Zeile (Datensatz) löschen kann.
hier in dem Link:http://www.java-forum.org/java-faq-beitraege/7035-jtable-teil-2-kommen-daten-tabelle.html
ist beschrieben das Man ein Event zusammenbauen muss und es an das Model senden muss.
Muss ich dafür erst einen Listener in dem Model adden der dann auf das Event reagiert oder geht das automatisch?
Im Endefekt soll man auf eine Button klicken und dann soll der selektierte Satz gelöscht werden (auch aus der Liste!).
Hier mal das Model:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

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

public class InvDatenModel implements TableModel{
	DatenListe<InventurDaten> dl=new DatenListe<InventurDaten>(1000);
//	File dateiName = new File("y:\\Java von eee\\InventurDaten082011.csv");
//	BufferedReader br;
//	String[] z1;
//	String z;
	
	private List<TableModelListener> tableListener = new ArrayList<TableModelListener>();;
	// Auswertungs Bereich
	//DatenListe<InventurDaten> auswertung=new DatenListe<InventurDaten>(1000);
	
	//Konstruktor
	InvDatenModel(File dateiNamee){
		a=new AuswertModel();
		this.dateiName=dateiNamee;
		System.out.println(dateiName);
		System.out.println(dateiName);
		datenLaden();
	}
	//Instanzvariablen
	String[][] daten=new String[500][6];
	InventurDaten satz;
	int anzZeilen, spalten;
	BufferedReader br;
	String z, kopfzeile;
	String[] z1;
	AuswertModel a;
	int x, y;
	float zz;
	private File dateiName;
	
	// Datei auswerten
	public void datenLaden()
	{
		System.out.println("bin da");
		// System.out.println(!(dateiName.exists()));
		if (!(dateiName.exists())){
			System.out.println("Dateipfad falsch");
		}
		System.out.println("Datei ok");
		try {
			
			FileReader fr = new FileReader(dateiName);
			br = new BufferedReader(fr);
			z=br.readLine();
			kopfzeile=z;
			while ((z = br.readLine()) != null) {
				z1 = z.split(";");
				spalten=z1.length;
				System.out.println(z+ z1.length);
				//System.out.println(z);
				//System.out.println(InventurDaten.getAnzDaten());
				satz=new InventurDaten(
						z1[0],
						z1[1],
						Float.parseFloat(z1[2]),
						Float.parseFloat(z1[3]),
						Float.parseFloat(z1[4]),
						z1[5]);
				System.out.println(z1[5]);
				System.out.println(satz.artNr+"\t"+satz.f1+"\t"+satz.f2+"\t"+satz.f3+satz.datum);
				addD(satz);
//				for (int j = 0; j < z1.length; j++) {
//					daten[anzZeilen][j] = z1[j];
//					satz=
//				}
				anzZeilen++;
				//z = br.readLine();
				//System.out.println(z);
			}
			
		} catch (FileNotFoundException e) {
			System.out.println("Datei nicht gefunden");
			e.printStackTrace();
		} catch (IOException e) {
			System.out.println("Ein Ausgabe fehler");
			e.printStackTrace();
		}
		

	}
	
	public void anzz() throws IOException{
		while((z=br.readLine())!=null){
			anzZeilen +=1;
		}
	}
	
  	public void addD(InventurDaten f) {
		dl.add(f);
		//System.out.println(dl.get(dl.getElementCount()-1).f3);
		a.addAuswertung(f);
		//testausgabe();
		for (TableModelListener l : tableListener) {
			l.tableChanged(new TableModelEvent(this));
		}
	}


	@Override
	public void addTableModelListener(TableModelListener l) {
		tableListener.add(l);
		
	}

	@Override
	public Class<?> getColumnClass(int columnIndex) {
		switch (columnIndex){
		case 0:return String.class;
		case 1:return String.class;
		case 2:return Float.class;
		case 3:return Float.class;
		case 4:return Float.class;
		case 5:return String.class;
		default: return null;
		}
	}

	@Override
	public int getColumnCount() {
		return 6;
	}

	@Override
	public String getColumnName(int columnIndex) {
		switch (columnIndex){
		case 0:return "Artikel Nr";
		case 1:return "Einheit";
		case 2:return "A-\u00d8[mm] / [m]";
		case 3:return "I-\u00d8[mm] / [Kg]";
		case 4:return "Meter";
		case 5:return "Datum";
		default: return null;
		}
	}

	@Override
	public int getRowCount() {
		
		return dl.getElementCount();
	}

	@Override
	public Object getValueAt(int rowIndex, int columnIndex) {
		// TODO Auto-generated method stub
		switch (columnIndex){
			case 0:return dl.get(rowIndex).artNr;
			case 1:return dl.get(rowIndex).einheit;
			case 2:return dl.get(rowIndex).f1;
			case 3:return dl.get(rowIndex).f2;
			case 4:return dl.get(rowIndex).f3;
			case 5:return dl.get(rowIndex).zusText;
			default: return null;
		}
		
		
	}

	@Override
	public boolean isCellEditable(int rowIndex, int columnIndex) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void removeTableModelListener(TableModelListener l) {
		tableListener.remove(l);
		
	}

	@Override
	public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
		// TODO Auto-generated method stub
	}
	
	public void delZeile(int rowIndex){
		TableModelEvent(this,rowIndex,rowIndex,
				TableModelEvent.ALL_COLUMNS,TableModelEvent.DELETE);
	}

	public void speichern(){
		try {
			FileWriter fw=new FileWriter(dateiName);
			System.out.println(kopfzeile);
			fw.write(kopfzeile+"\n");
			for (int i=0;i < dl.getElementCount();i++ ){
				System.out.println("int i:"+i+dl.get(i).toString());
				fw.write(dl.get(i).artNr+";"+
						dl.get(i).einheit+";"+
						dl.get(i).f1+";"+
						dl.get(i).f2+";"+
						dl.get(i).f3+";"+
						dl.get(i).datum+"\n");
			}
			fw.close();
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
	}

	
}

und hier die Liste:

public class DatenListe<T> {

	private T[] array;
	private int nextFreeSlot=0;
	
	public DatenListe(int groese){
		array =(T[]) new Object[groese];
	}
	
	public void add(T o){
		if (nextFreeSlot==array.length){
			throw new IllegalStateException("Liste ist voll!");
		}
		array[nextFreeSlot]=o;
		//System.out.println(o);
		nextFreeSlot++;
		
	}
	
	public T get(int index){
		return array[index];
	}
	
	public int getGroese(){
		return array.length;
	}
	
	public int getElementCount(){
		return nextFreeSlot;
	}
}

In der Liste werd ich noch was basteln müssen das der Datensatz auch gelöscht wird aber ich weis nicht ob ich dann die Liste nach dem gelöschten Satz neu generieren muss.

MfG Fritz

 

[Beni]

ist beschrieben das Man ein Event zusammenbauen muss und es an das Model senden muss.
Muss ich dafür erst einen Listener in dem Model adden der dann auf das Event reagiert oder geht das automatisch?

Wo steht das? Da steht, dass man ein Event bauen muss, und das Model dieses Event verschicken soll. Du musst keine TableModelListener implementieren, du musst sie aufrufen.
Hast du das Beispiel zu "addVehicle" mal angeschaut? Das ist genau das was du selbst bauen musst (nur dass es bei dir halt ein Element gelöscht wird. Das Prinzip ist dasselbe).

 

[kleinfritzchen]

Hallo, ich hab folgendes implementiert:

public void delZeile(int rowIndex){
		dl.del(rowIndex);
	TableModelEvent e=new	TableModelEvent(this,rowIndex,rowIndex,
				TableModelEvent.ALL_COLUMNS,TableModelEvent.DELETE);
	for(TableModelListener l : tableListener){
        l.tableChanged(e);
        fireTableDataChanged();
		}
    
	}

Das funktioniert für das InvTableModel und die Liste.
Problem ist jetzt noch was ist am geschicktesten, ein neues AuswertModel erzeugen oder die dl neu einlesen. bei größeren Datenmengen muss ich erst mal sehen ob ich ein zeit oder Speicherproblem bekomme.:autsch:

MfG Fritz