XML - in "Stuktur" einlesen

[Alphagen]

Hallo liebe Community.

Vorab möchte ich erwähnen, dass ich von VB auf Java umgestiegen bin.
Nun zu meinem Problem:

Ich lesen eine XML-Datei aus, die wie folgt aufgebaut ist:
[XML]
<Haus>
<Stockwerk>
<Raum>
<Sitzplatz>E23</Sitzplatz>
<Sitzplatz>E24</Sitzplatz>
<Sitzplatz>E25</Sitzplatz>
</Raum>
<Raum>
<Sitzplatz>E22</Sitzplatz>
<Sitzplatz>E21</Sitzplatz>
</Raum>
</Stockwerk>
<Stockwerk>
<Raum>
<Sitzplatz>A10</Sitzplatz>
<Sitzplatz>A11</Sitzplatz>
</Raum>
<Raum>
<Sitzplatz>A13</Sitzplatz>
</Raum>
</Stockwerk>
</Haus>
[/XML]

Wozu diese XML dient denke ich ist klar.

Einlesen mit Java funktioniert auch wunderbar...
Jetzt möchte ich aber eben diese Daten nicht nur ausgeben sondern auch speichern. In VB ging das schön mit einer eigenen Struktur. In Java gibt es so was ja nicht.

ABER hier gibt es zum einen Arraylisten und zum anderen Klassen, Objekte, Attribute und vererbung...

Ich habe versucht Arraylisten zu verschachtel. Das sah folgendermaßen aus:

public class CLSreadHaus {

    private ArrayList<String> Sitz = new ArrayList<String>();
    private ArrayList<ArrayList> Raum = new ArrayList<ArrayList>();
    private ArrayList<ArrayList> Stock = new ArrayList<ArrayList>();
    private ArrayList<ArrayList> Haus = new ArrayList<ArrayList>();
    
    public void lesehaus_XML (String Ausgabedatei) throws ParserConfigurationException, SAXException, IOException {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document document = builder.parse(new File(Ausgabedatei));
        NodeList ndlist = document.getChildNodes();
        for (int j = 0;j<ndlist.getLength();j++) {
            rekursive_XML(ndlist.item(j));
        }
    }
    
    private void rekursive_XML (Node nd) {
        if (nd.getNodeName().equals("Stockwerk")) {
        Haus.add (Stock);
        }
        if (nd.getNodeName().equals("Raum")) {
        Stock.add (Raum);
        }
        if (nd.hasChildNodes()){
            NodeList ndl = nd.getChildNodes();
            for (int p = 0;p<ndl.getLength();p++){
                rekursive_XML(ndl.item(p));
                String str = ndl.item(p).getNodeValue();
                if (str!=null && str.trim().length()>0 && !"\n".equals(str.trim()) && !"#text".equals(str.trim())) {
                        Raum.add(Sitz);
                        Sitz.add(ndl.item(p).getParentNode().getNodeName());
                        Sitz.add(ndl.item(p).getNodeValue());                    
                }
                
            }
        }
    }
}

Problem: Es wurde immer in jede Arraylist geschrieben. Bedeutet, ausgehend von der oben stehenden XML, die "Struktur" war folgendermaßen aufgebaut:

Haus
 + Stock
   + Raum
     + Sitzplatz (8)
   + Raum
     + Sitzplatz (8)
   + Raum
     + Sitzplatz (8)
   + Raum
     + Sitzplatz (8)
+ Stock
   + Raum
     + Sitzplatz (8)
   + Raum
     + Sitzplatz (8)
   + Raum
     + Sitzplatz (8)
   + Raum
     + Sitzplatz (8)

Sie müsste aber wie folgt aussehen:

Haus
 + Stock
   + Raum
     + Sitzplatz (3)
   + Raum
     + Sitzplatz (2)
+ Stock
   + Raum
     + Sitzplatz (2)
   + Raum
     + Sitzplatz (1)

Wer kann mir helfen? Was mache ich falsch?! ^^

Ich bin auch gerne für andere Lösungsideen oder -ansätze dankbar.

Wie ich das mit Klassen lösen soll weiß ich leider auch nicht...

Ich bedanke mich schonmal im Voraus und wenns auch nur dafür ist, dass sich jemand die Zeit genommen hat um das zu lesen und den Versuch zu starten mir zu helfen.

LG Alphagen

 

[Michael...]

Ich würde da eher eigene Klassen für Haus, Stockwerk... schreiben.

Zum Problem: Die verwendest jeweils nur eine Liste zum speichern der unterschiedlichen Elemente, müsstest aber für jedes "Haus" eine neue Stockwerk Liste, für jedes Stockwerk eine neue Raumliste usw. erzeugen.

Müsste aber in VB das gleiche sein.

 

[Alphagen]

In VB habe ich mir immer einfach eine eigene Datenstruktur gebaut, die genau wie die XML aussah und die Daten reingeschrieben...

Private Type Sitz
   Name as String
End Type

Private Type Raum
   Sitz() as Sitz
End Type

Private Type Stock
   Raum() as Raum
End Type

Private Type Haus
   Stock() as Stock
End Type

Private Haus as Haus

Aber zurück zum Problem (ich glaube es ist mehr ein Verständnissproblem von mir)

Wenn ich dich richtig verstehe, dann müsste das ganze folgendermaßen aussehen (ist nur Beispielcode...)

private ArrayList<String> Sitz1 = new ArrayList<String>();
private ArrayList<String> Sitz2 = new ArrayList<String>();
private ArrayList<String> Sitz3 = new ArrayList<String>();
private ArrayList<String> Sitz4 = new ArrayList<String>();
.
.
.
private ArrayList<ArrayList> Raum1 = new ArrayList<ArrayList>();
private ArrayList<ArrayList> Raum2 = new ArrayList<ArrayList>();
private ArrayList<ArrayList> Raum3 = new ArrayList<ArrayList>();
private ArrayList<ArrayList> Raum4 = new ArrayList<ArrayList>();
private ArrayList<ArrayList> Stock1 = new ArrayList<ArrayList>();
private ArrayList<ArrayList> Stock2 = new ArrayList<ArrayList>();
private ArrayList<ArrayList> Haus = new ArrayList<ArrayList>();

Ich blick nicht mehr durch. *lacht*

Wie würdest du das denn mit Klassen lösen?

Das hab ich auch schon versucht... Aber nut mit mäßigem Erfolg, da ich wie gesagt erst vor kurzem von VB6 umgestiegen bin und mein Verständniss dafür noch ziemlich gering ist...

Ich habe versucht eine Klasse "Haus" zu schreiben, die ein Objekt der Klasse "Stock" erzeugt. Ist der Ansatz richtig? (Es hat übrigens nicht funktioniert. Aber wenn ich weiß, dass der Ansatz richtig ist, klemm ich mich dahinter! ^^). Will das ganze ja auch selber schreiben, damit ich durchblicke wie es funktioniert! ^^

Vielen dank für deine Antwort.

 

[Michael...]

eher so:

public class CLSreadHaus {
 
    private ArrayList<ArrayList> haus = new ArrayList<ArrayList>();
    private ArrayList<ArrayList> stock;
    private ArrayList<ArrayList> raum;
    
    ...
    
    private void rekursive_XML (Node nd) {
        if (nd.getNodeName().equals("Stockwerk")) {
             stock = new ArrayList<ArrayList>();
             haus.add (stock);
        }
        if (nd.getNodeName().equals("Raum")) {
             raum = new ArrayList<ArrayList>();
             stock.add (raum);
        }
        ...

Die Datenstruktur kannst Du in Java genauso nachbauen:

class Haus {
	private List<Stockwerk> stockwerkListe = new ArrayList<Stockwerk>();
	
	public void addStockwerk(Stockwerk stockwerk) {
		this.stockwerkListe.add(stockwerk);
	}
	
	public Stockwerk getStockwerk(int index) {
		return this.stockwerkListe.get(index);
	}
}

 

[Alphagen]

Das da wird jetzt sofort ausprobiert... Und wenns funktioniert, dann versuch ich es mit den Klassen... Will jetzt wissen wie das funktioniert! ^^

Danke schonmal. Gebe gleich nochmal Rückmeldung.

 

[Alphagen]

Der Vorgang mit der Arrayliste wurde getestet und für korrekt befunden!! Vielen Vielen Dank...

Die Lösung lag auf der Hand...

ICH: Am Anfang werden die Listen erzeugt und dann nur noch rein geschrieben.

DU: Jedesmal wenn der Nodename auftritt, erzeugst du eine neue Liste.

Wie sagte einst eine weise Frau? (Es war meine Mutter. *lacht*)

Hinterher ist jeder Affe ein Professor!

Nochmal vielen Dank.

Das mit den Klassen probier ich am WE aus... Das muss ja auch irgendwie zu schaffen sein.. Gebe dir dann Rückmeldung.

 

[Landei]

Lege eigene Objekte für Haus, Stockwerk, Raum an. Ein Haus hat eine Liste Stockwerke u.s.w.

Dann nimmst du eine Bibliothek wie JAXB, annotierst deine Objekte ein wenig (damit ist klar ist, welches XML-Element auf welche Datenstruktur abgebildet wird) und das Einlesen wird automatisch durchgeführt. Hier ein ganz einfaches Tutorial: JAXB Tutorial

Alternativen wären DOM oder SAX, die aber weniger bequem sind.

"Händisches" Einlesen wie du es machst ist fehleranfällig und kann nicht alle Einzelheiten des recht komplexen XML-Standards abdecken (Name-spaces, Enities, CDATA-Sections...).

 

[Alphagen]

Ui... Direkt das nächste was ich mir dann auch angucke! xD

Ich werde ja gefüttert mit Infos! Auch dir vielen Dank.

Das händische einlesen ist auch nur möglich, weil ich die XML-Datei selber generiere und somit QUASI einen internen "Standard" geschaffen habe. ;-)

Aber du hast Recht. Meine Methode ist sehr anfällig für Fehler, was auch an der laaaaaangen Code zum einlesen liegt. Je mehr man schreibt, desto mehr vertippt man sich oder kann man falsch schreiben.

Wie gesagt, ich bin euch wirklich ausgesprochen Dankbar für eure Hilfe und werde mir sowohl das mit den Klassen ansehen als auch JAXB. Was mir das Projekt aber auf jeden Fall gezeigt hat ist, dass ein Umstieg in Programmiersprachen garnicht sooo einfach ist wie immer alle sagen UND dass ich mich noch viel zu wenig mit Java beschäftigt habe.