# JTable komplette Daten auslesen



## flipo84 (3. Mai 2007)

Hallo Leute, 

ich hab ein kleines Suchprogramm programmiert, welche geladene Datein durchsucht und das Ergebnis in einer JTable ausgibt.
Nun müsste ich diese daten aus der Tabelle auslesen und dies speichern können.
Hab mir die Funktion speichern schon geschrieben.... dieser schaut wie folgt aus.

```
if(info.equals("saveDataFile"))
    { 
      
     // JTable jTable1 =((MainFrame)view).getJTable1();
      
    	JTextArea jTextArea=((MainFrame)view).getJTextArea();
        openFile.setCurrentDirectory(new File(".")); //das Ausgangsverzeichnis der Dialoge ist das Verzeichnis in dem das Programm läuft    
        String schreiben;        
        if(openFile.showSaveDialog(view)==0)//Dialog liefert 0 zurück wenn er nicht abgebrochen wurde.
        {
        DateiName = openFile.getSelectedFile();
          //  tf_speichern.setText(""+sf);
            try{            
              out = new PrintWriter(new FileWriter(DateiName)); //Datei zum Schreiben öffnen
              schreiben = jTextArea.getText();
              out.println(schreiben); //Schreiben
              out.flush();          //der Speicher wird gelehrt, damit die Datei völlig zu Ende geschrieben wird.
              out.close();           //Schließen der Datei
             }catch(Exception ex2){System.out.println(ex2);}  //Bei Fehlern werden diese in der Konsole ausgegeben     
          }
          else{
            JOptionPane.showMessageDialog(view,"Keine Datei zum Speichern gewählt!","SPEICHERN",JOptionPane.ERROR_MESSAGE);  // Modales Fenster
          }
  }
```
Wenn ich einen eingegeben Wert aus einer JTextArea nehme, dann speichert er mir das auch, aber wie kann ich denn kompletten Inhalt meiner  JTable übergeben?


----------



## Snape (4. Mai 2007)

Na wie sollen die Daten schon ausgelesen werden? Eine Tabelle ist eine Darstellung eines zweidimensionalen Arrays. Also musst Du über die Zeilen iterieren und pro Zeile die einzelnen Spaltenwerte auslesen. Oder worin besteht das Problem?


----------



## flipo84 (4. Mai 2007)

Wie mach ich das denn, kannst mir mal ein kleines Beispiel schreiben


----------



## zerix (4. Mai 2007)

Hallo,

mit

```
table.getValueAt(x,y);
```
kommst du an deine Werte in der Tabelle ran.

MFG
zEriX


----------



## flipo84 (4. Mai 2007)

Je nach dem was meine Suche ergibt, werden die Zeilen und Spalten meiner JTable festgelegt und erzeugt. Und meine Ausgabe in die Tabelle mache ich wie folgt:

```
((MainFrame) view).getJTable1().setValueAt(row[0], zahl - 1, 0);
          ((MainFrame) view).getJTable1().setValueAt(row[1], zahl - 1, 1);
          ((MainFrame) view).getJTable1().setValueAt(row[2], zahl - 1, 2);
          ((MainFrame) view).getJTable1().setValueAt(row[3], zahl - 1, 3);
          ((MainFrame) view).getJTable1().setValueAt(row[4], zahl - 1, 4);
```
wobei Zahl eine einfach Laufvariable ist die vorher auf null gesetzt wird und das minus eins damit er auch bei der Stelle 0/0 anfängt zu schreiben aber wie bekomme ich das jetzt in meine Speichern Funktion?


```
try
        {
          out = new PrintWriter(new FileWriter(DateiName)); // Datei zum Schreiben öffnen
          schreiben = jTextArea.getText();
          out.println(schreiben); // Schreiben
          out.flush(); // der Speicher wird gelehrt, damit die Datei völlig zu Ende geschrieben                       
          out.close(); // Schließen der Datei
        }
        catch(Exception ex2)
        {
          System.out.println(ex2);
```
Das ist der Ausschnitt wo ich mein zu speichernder Text momentan aus einer JTextArea nehme und das speichern klappt auch, aber wie übergeben ich die Werte der erzeguten Tabelle?


----------



## inter (4. Mai 2007)

Du solltest Deine Daten erstmal in eine Datenstruktur einlesen.
Dann kannst Du diese in einer Tabelle darstellen oder auch speichern. Direkt in die Tabelle einlesen und von da aus speichern macht es doch sehr unübersichtlich. Vielleicht willst Du ja auch später noch etwas anderes mit den Daten machen.

Du hast ja schon eine Datenstruktur (den Array "row"). Die scheint aus 5 unterschiedlichen Einzeldaten zu bestehen. Beschreib die Struktur Deiner Daten doch mal näher. Dann können wir Dir vielleicht einen konkreteren Vorschlag machen.


----------



## flipo84 (4. Mai 2007)

Also ich durchsuche ein LogDatei.
Die LogDaten sind immer in Bereich1|Bereich2|Bereich3|Bereich4|Bereich5 geteilt und werden immer mit einem | getrennt. Lauf da mit einem StrinTokenizer drüber der die jeweilige Zeile danach trennt und in ein String Array speichert.
Danach durchsuche ich dann quasi Zeile für zeile und geb mir das Ergebni, wenn ein Datenblock in meiner Suche enthalte ist die zeile wieder in meiner Tabelle aus.
Jetzt will ich quasi den Inhalt meiner Tabelle also mein Suchergebnis mir abspeichern.
Weiß aber nicht wie ich es hinbekomme meinem Speichern Klasse die Anzahl der row zu übergeben...


----------



## inter (4. Mai 2007)

Also hier mal ein Vorschlag von mir wie Du Dein ausgelesenes Log in eine Datenstruktur einließt, die freundlicherweise in einer Datei speicherbar ist. Dazu nehme die beiden folgenden Klassen "Log" und "LogEntry". An der main-Methode zum Testen siehst Du wie Du sie nutzt.


```
import java.io.*;
import java.util.*;

public class Log {
    private ArrayList logEntries;
    
    public Log() {
        logEntries = new ArrayList();
    }
    
    public void add(LogEntry newEntry) {
        logEntries.add(newEntry);
    }
    
    public void readOriginalLogFile(String path) {
        logEntries.clear();
        // Hier das LogFile einlesen
        // Da kannst Du deine alte Methode einbauen.
        // logEntries.add(new LogEntry(row[0], row[1], row[2], row[3], row[4]);
    }
    
    public void writeLogToFile(String path) {
        try {
            FileOutputStream fos = new FileOutputStream(path);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(logEntries);    
            oos.close();
        }
        catch (Exception ex) {
            System.out.println("Fehler beim Dateizugriff. Message: " + ex.getMessage());
        }
    }
    
    public void readLogFromFile(String path) {
        try {
            FileInputStream fis = new FileInputStream(path);
            ObjectInputStream ois = new ObjectInputStream(fis);

            logEntries = (ArrayList) ois.readObject();

            ois.close();
        }
        catch (Exception ex) {
            System.out.println("Fehler beim Dateizugriff. Message: " + ex.getMessage());
        }
    }
    
    /**
     * Zum Testen.
     * Overrides @see java.lang.Object#toString()
     */
    public String toString() {
        String tmpStr = "";
        Iterator it = logEntries.listIterator();
        while(it.hasNext()) {
            tmpStr += it.next().toString() + "\n";
        }
        return tmpStr;
    }
    
    /**
     * Zum Testen.
     * @param args
     */
    public static void main(String[] args) {
        Log testLog = null;
        if(args[0].equals("1")) {
            System.out.println("Schreibe Log in Datei.");
            testLog = new Log();
            testLog.add(new LogEntry("Daten A1", "Daten A2", "Daten A3", "Daten A4", "Daten A5"));
            testLog.add(new LogEntry("Daten B1", "Daten B2", "Daten B3", "Daten B4", "Daten B5"));
            testLog.add(new LogEntry("Daten C1", "Daten C2", "Daten C3", "Daten C4", "Daten C5"));
            System.out.print(testLog.toString());
            testLog.writeLogToFile("c:\\testlog.dat");
        
        } else if(args[0].equals("2")) {
            System.out.println("Lade Log aus Datei.");
            testLog = new Log();
            testLog.readLogFromFile("c:\\testlog.dat");
            System.out.print(testLog.toString());            
        }
    }
}
```


```
import java.io.*;

public class LogEntry implements Serializable {
    public static final long serialVersionUID = 1L;

    private String bereich[];
    
    /**
     * Leerer Eintrag
     *
     */
    public LogEntry() {
        bereich = new String[5];
        for(int i = 0; i<5; i++) {
            bereich[i] = "";
        }
    }
    
    /**
     * Legt einen Eintrag aus Strings an.
     * 
     * @param bereich1
     * @param bereich2
     * @param bereich3
     * @param bereich4
     * @param bereich5
     */
    public LogEntry(String bereich1, 
                    String bereich2, 
                    String bereich3,
                    String bereich4,
                    String bereich5) {
        bereich = new String[5];
        bereich[0] = bereich1;
        bereich[1] = bereich2;
        bereich[2] = bereich3;
        bereich[3] = bereich4;
        bereich[4] = bereich5;
    }
 
    public String toString() {
        String tmpStr = "";
        tmpStr = bereich[0] + " | " + bereich[1] + " | " + bereich[2] + " | " + bereich[3] + " | " + bereich[4];
        return tmpStr;
    }
}
```

Jetzt musst Du nur noch Deiner Tabelle beibringen wie sie Objekte vom Typ "Log" darstellt. Falls Du Dich dazu entschließt kann ich Dir dabei gerne weiterhelfen.


----------



## ShakalX (5. Februar 2013)

Hey ich rufe diese Thema mal wieder weil es fast genau das Problemm ist was ich habe


```
import java.io.File;
import java.util.Vector;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.jaudiotagger.audio.AudioFile;
import org.jaudiotagger.audio.AudioFileIO;
import org.jaudiotagger.audio.AudioHeader;
import org.jaudiotagger.tag.FieldKey;
import org.jaudiotagger.tag.Tag;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class Laden {
	private File file = null;
	private String path;
	private double time;
	private String artist;
	private String title;
	private String album;
	private int track;
	Vector<Track> trackList = new Vector<Track>();
	JFileChooser fc = new JFileChooser();
	FileNameExtensionFilter filter = new FileNameExtensionFilter("MP3 Dateien",
			"mp3");

	public void loadStream(ModelTable mTable) {
		try {
			fc.setDialogType(JFileChooser.OPEN_DIALOG);
			fc.setFileFilter(filter);
			int state = fc.showOpenDialog(null);
			path = fc.getSelectedFile().getPath();
			file = new File(path);
			AudioFile mp3file = AudioFileIO.read(file);
			Tag tag = mp3file.getTag();
			AudioHeader audioHeader = mp3file.getAudioHeader();

			track = Integer.parseInt(tag.getFirst(FieldKey.TRACK));
			artist = tag.getFirst(FieldKey.ARTIST);
			time = audioHeader.getTrackLength() / 59;
			album = tag.getFirst(FieldKey.ALBUM);
			title = tag.getFirst(FieldKey.TITLE);
			Track newTrack = new Track(track, title, artist, time, album);
			trackList.add(newTrack);
			DocumentBuilderFactory docFactory = DocumentBuilderFactory
					.newInstance();
			DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
			Document docXml = docBuilder.newDocument();
			docFactory.setNamespaceAware(true);

			Element root = docXml.createElement("music");
			docXml.appendChild(root);
			for (int i = 0; i < trackList.size(); i++) {
				Element mp3 = docXml.createElement("MP3");
				root.appendChild(mp3);

				Element track = docXml.createElement("track");
				track.appendChild(docXml.createTextNode(String
						.valueOf(trackList.get(i).getTrack())));
				mp3.appendChild(track);

				Element title = docXml.createElement("title");
				title.appendChild(docXml.createTextNode(String
						.valueOf(trackList.get(i).getTitle())));
				mp3.appendChild(title);

				Element artist = docXml.createElement("artist");
				artist.appendChild(docXml.createTextNode(String
						.valueOf(trackList.get(i).getArtist())));
				mp3.appendChild(artist);

				Element length = docXml.createElement("length");
				length.appendChild(docXml.createTextNode(String
						.valueOf(trackList.get(i).getTime())));
				mp3.appendChild(length);

				Element album = docXml.createElement("album");
				album.appendChild(docXml.createTextNode(String
						.valueOf(trackList.get(i).getAlbum())));
				mp3.appendChild(album);
			}
			TransformerFactory transformerFactory = TransformerFactory
					.newInstance();
			Transformer transformer = transformerFactory.newTransformer();
			DOMSource source = new DOMSource(docXml);
			StreamResult result = new StreamResult(new File("xml/libary.xml"));
			transformer.transform(source, result);

			System.out.println("File saved!");

			mTable.setTracklist(newTrack);
			XMLValidator xmlvali = new XMLValidator();
			xmlvali.validate(docXml, true);

		} catch (Exception e) {
		}

	}

	public Vector<Track> getTrackList() {
		return trackList;
	}

}
```


```
import java.util.Vector;

import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.TableModel;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class ModelTable implements TableModel {
	private Vector mp3file = new Vector();
	private Vector listeners = new Vector();
	private Track trackList;
	private NodeList nList;
	private Document doc;

	public void addTableModelListener(TableModelListener listener) {
		listeners.add(listener);
	}

	public void removeTableModelListener(TableModelListener listener) {
		listeners.remove(listener);
	}

	/**
	 * public void addTrack(Vector<Track> trackList2) { int index =
	 * mp3file.size(); mp3file.add(trackList2);
	 * 
	 * /**try { DocumentBuilderFactory dbf =
	 * DocumentBuilderFactory.newInstance(); DocumentBuilder db =
	 * dbf.newDocumentBuilder(); doc = db.parse(trackList2); nList =
	 * doc.getElementsByTagName("MP3");
	 * 
	 * } catch (Exception e) { e.printStackTrace(); }
	 * 
	 * TableModelEvent e = new TableModelEvent(this, index, index,
	 * TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT);
	 * 
	 * for (int i = 0, n = listeners.size(); i < n; i++) { ((TableModelListener)
	 * listeners.get(i)).tableChanged(e); } }
	 **/

	private static String getTagValue(String sTag, Element eElement) {
		NodeList nlList = eElement.getElementsByTagName(sTag).item(0)
				.getChildNodes();

		Node nValue = (Node) nlList.item(0);

		return nValue.getNodeValue();
	}

	// Eine Angabe, welchen Typ von Objekten in den Columns angezeigt werden
	// soll
	public Class getColumnClass(int columnIndex) {
		switch (columnIndex) {
		case 0:
			return Integer.class;
		case 1:
			return String.class;
		case 2:
			return String.class;
		case 3:
			return Double.class;
		case 4:
			return String.class;
		default:
			return null;
		}
	}

	public int getColumnCount() {
		return 5;
	}

	public String getColumnName(int column) {
		switch (column) {
		case 0:
			return "Track";
		case 1:
			return "Titel";
		case 2:
			return "Künstler";
		case 3:
			return "Zeit";
		case 4:
			return "Album";
		default:
			return null;
		}
	}

	public int getRowCount() {
		return mp3file.size();
	}

	public Object getValueAt(int rowIndex, int columnIndex) {

		Track track = (Track) mp3file.get(rowIndex);
		switch (columnIndex) {
		case 0:
			return new Integer(track.getTrack());
		case 1:
			return track.getTitle();
		case 2:
			return track.getArtist();
		case 3:
			return new Double(track.getTime());
		case 4:
			return track.getAlbum();
		default:
			return null;
		}

	}

	public boolean isCellEditable(int rowIndex, int columnIndex) {
		return true;
	}

	public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
		Track track = (Track) mp3file.get(rowIndex);
		switch (columnIndex) {
		case 0:
			track.setTrack(((Integer)aValue).intValue());
			break;
		case 1:
			track.setTitle((String)aValue);
			break;
		case 2:
			track.setArtist((String)aValue);
			break;
		case 3:
			track.setTime(((Double)aValue).doubleValue());
			break;
		case 4:
			track.setAlbum((String)aValue);
			break;
			}
	}

	public void setTracklist(Track newTrack) {
		this.trackList = newTrack;
		int index = mp3file.size();
		mp3file.add(newTrack);
		TableModelEvent e = new TableModelEvent(this, index, index,
				TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT);

		for (int i = 0, n = listeners.size(); i < n; i++) {
			((TableModelListener) listeners.get(i)).tableChanged(e);
		}
	}

}
```

Das sind meine klassen Laden (womit ich die MP3 einlade) und  JTableModel wo ich das alles anzeige alles klappt einwandfrei Daten einlesen usw, nun möchte ich wenn man die Tracks eingelesen hat und zb den Artisten oder Track verändert das er diese wieder abspeichert in eine XML. Könnte mir jemand ein Code beispiel schreiben denn ich bin mit meinem Latein am ende


----------



## zerix (7. Februar 2013)

Hallo,

woran hängt es denn?

Viele Grüße

Sascha


----------



## ShakalX (7. Februar 2013)

Komplett daran alles was in der JTable drin steht wieder so abspeichern wie es zuvor in der xml gespeichert wird


----------

