Rekursion und ArrayList

[nieselfriem]

Hallo!

Ich habe ein kleines Programm in dem ich eine XML per DOM parsen lasse. Dieses arbeitet nun rekursiv die ganzen Knoten rekursiv durch. Nun möchte ich nun die enthaltenen Werte in einer ArrayList speichern lassen. Nu wird aber nach meiner bisherigen Methode zu viel in die Liste eingespeichert, da natürlich dieser aufruf list.add(..) ebenfalls rekursiv aufgerufen wird. Nur finde ich bishher keine Idee das Problem zu beheben.
Statt das die folgende XML Datei

<?xml version="1.0" encoding="UTF-8"?>

<bewerberliste>   
   <bewerber>
      <vorname>Georg</vorname>
      <name>Gutsche</name>
      <beruf>Schlosser</beruf>
      <fuhrerschein klasse="pkw">ja</fuhrerschein>
   </bewerber>
   <bewerber>
      <vorname>Olaf</vorname>
      <name>Vormelchert</name>
      <beruf>Baecker</beruf>
      <fuhrerschein klasse="lkw">ja</fuhrerschein>
   </bewerber>
</bewerberliste>

wird die liste jedoch wie folgt aufgebaut:

 Element bewerberliste
 Element bewerber

Georg
Georg
Georg


Georg
Gutsche
Georg
Gutsche
Georg
Gutsche

Georg
Gutsche
Schlosser
Georg
Gutsche
Schlosser
Georg
Gutsche
Schlosser


Georg
Gutsche
Schlosser
ja
Georg
Gutsche
Schlosser
ja
Georg
Gutsche
Schlosser
ja
Georg
Gutsche
Schlosser
ja
Georg
Gutsche
Schlosser
ja


Gutsche
Schlosser
ja


Georg
Gutsche
Schlosser
ja
Olaf
Georg
Gutsche
Schlosser
ja
Olaf
Georg
Gutsche
Schlosser
ja
Olaf


Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert


Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker

Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker
ja
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker
ja
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker
ja
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker
ja
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker
ja
Georg
Gutsche
Schlosser
ja
Olaf
Vormelchert
Baecker
ja

static void unterbaumDurchlaufen(Node knoten) {
    	if (knoten == null) {
    		return;
    	}
    	anzahlKnoten++;
    	
    	if(knoten.getNodeType()==Node.ELEMENT_NODE) {
    		anzahlElemente++;
    		System.console().printf("\n");
    		System.console().printf(" Element %s", knoten.getNodeName());
    		NamedNodeMap attribs = knoten.getAttributes();
    		int anz = attribs.getLength();
    		
    		for(int i=0;i<anz;i++) {
    			Node tmp = attribs.item(i);
    			System.console().printf("\t Attribut "+tmp.getNodeName()
    													  + " = "+tmp.getNodeValue());
      	    }//for
    	}//if
    	if(knoten!=null && knoten.getNodeType() == Node.TEXT_NODE) {
    		if (knoten.getNodeValue()!="") {
    		
    			 String value=knoten.getNodeValue().trim();
    			 if (value.length() > 0) {
    			   System.out.println("Der Wert des Knoten ist: "+value);
    			    al.add(value);//Einfügen in ArrayList (Problem rekuriver merfacher Aufruf)
    		     }
    		}
    	}
    	NodeList kinder = knoten.getChildNodes();
    	
    	if(kinder == null)
    		return;
    		
    	int anzahl = kinder.getLength();
    	
    	for(int i=0; i<anzahl;i++)
    		unterbaumDurchlaufen(kinder.item(i));
    
        for(String item: al) {
    	    System.out.println(item);
        }
    }//unterbaumDurchlaufen
}

Nun benötige ich einen Denkanstoss bzw. bestenfalls einen Vorschlag wie ich dieses Problem behebe.

Gruß niesel

 

[Dit]

Wenn mich nicht alles täuscht liegt dein Fehler hier:

al.add(value);//Einfügen in ArrayList (Problem rekuriver merfacher Aufruf)

In deinem Fall wird diese Methode ja öfters aufgerufen, als dir lieb ist, also musst du am besten fragen, ob diese Element bereits drin ist.

in etwa so:

if (!al.contains(value)){
al.add(value)
}

Dann hast du zumindest keine doppelten Elemente mehr drin, die Frage ist, ob Namen etc. doppelt vorkommen dürfen? dann klappt das natürlich nicht mehr!

 

[nieselfriem]

ja leider fürfen Elemente doppelt vorkommen...

 

[Dit]

Ich weiß ja nicht wofür du es verwenden willst, aber mir scheint es das eine Hashmap da besser wäre.

Sowas in die Richtung:

Hashmap mit Index oder String / ArrayList

Dann hast du jeden Knoten in unter eigenem Index (o.ä.) abgelegt, und behälst ein wenig die XML Struktur bei, in jeder Array List darfst du dann auch wieder gleiche Namen verwenden...

wie willst du sonst die Bewerber auseinander halten?

EDIT hier als Beispiel:

Hashmap<Index, ArrayList> test;

1 / ArrayList(x,x,x,x)
2 / ArrayList(x,x,x,x)

etc..

 

[nieselfriem]

Im Grunde geht es darum, das aus jedem Bewerber später eine SQL-Input-Anweisung entstehen soll, dai dann in eine Datenbank eingetragen werden soll.
Die XML Dateim soll von einer Webseite stammen wo eine Onlinebewerbungsformular in PHP existiert. Dieses soll dann in eine Javaapplikation + lokaler Datenbank importiert werden können. So der Plan...


Gruß niesel

 

[Dit]

Gerade dann macht die vorgeschlagene Lösung doch mehr Sinn, immerhin wird es auch für jeden Bewerber einen Datenbank Eintrag geben.

Wenn du es alles in einer ArrayList speichern würdes, könntest du diese ja nur Parsen indem du Beispielsweiße sagst, jede 4 Stelle ist ein Bruch!
In der vorgeschlagenenen Lösung könntest du dir das sparen, und hättest die Probleme beim einlesen nicht. Das verschachteln in einer HashMap kann auch von Vorteil sein!

Die kannst du nachher in einer Forschleife mit einem Index und size der Hashmap einfach wieder rausholen und in der Datenbank speichern.

 

[nieselfriem]

Danke für den Tipp. Ich werde es mal probieren und dir bei erfolg mitteilen

 

[Dit]

Gerne! über eine Rückmeldung freut man sich immer!

übrigens kannst du dann auch jede eigene ArrayList mit Contains abprüfen! du macht am Schleifenanfang (nicht in der Schleife) eine neue ArrayList mit Key (index oder String) und prüfst diese in der Schleife auf contains, nach der Schleife fügst du diese in deine Hashmap ein!

das ergebnis müsste dann das sein, was ich dir eben geschrieben, unter jedem Index hast du deine Bewerber sortiert! (je nachdem was du als Key nimmst, hast du sogar nen Identifier um auch einen bestimmten Benutzer einfach aus der Hashmap zu holen).