Zusammenhänge einer MAP

[NerdiiXxX]

Hallo zusammen habe eine Frage
Und zwar, ich hab derzeit eine map die folgenden aufbau hat:

static TreeMap<String, ArrayList<String>> a7CallExecStorProd = new TreeMap<String, ArrayList<String>>();

Darin befinden sich derzeit z.B. folgende werte
(String und Arraylist werden bei mir durch ";" sichtbar getrennt)
(elemente der Arraylist durch ","
x1 ; x2 , x3 , x4 , x5 , x6 , x7 , x8
x2 ; x3 , x4
x3 ; x4 , x5
x4 ; x6 , x7 , x8
x8 ; x9 , x10 , x11
x11 ; x12

Meine frage ist jetzt, wie und ob ich das am besten in einer art baumstruktur auslesen aknn...
die Ausgabe im nachhinein soll die abhängigkeiten der einzelnen Keys zu den Values darstellen
In diesem beisipel soll sie so aussehen:
X1 hat eine beziehung zu x2, x2 wiederum zu x3, welche wiederrum zu x4 eine aufbaut, die wiederum zu x6 eine aufbaut, zu x7 und zu x8, ebenso hat x1 -> x2 -> x3 eine bezieung mit x5

x1 -> x2 -> x3 -> x4
x1 -> x2 -> x3 -> x5
x1 -> x2 -> x4 -> x6
x1 -> x2 -> x4 -> x7
x1 -> x2 -> x4 -> x8
x1 -> x3 -> x4 -> x6
x1 -> x3 -> x4 -> x7
x1 -> x3 -> x4 -> x8

und so weiter

Hoffe das war verständlich und ihr könnt mir weiterhelfen ich verzweifle derzeit daran!
Vielen Dank!

 

[NerdiiXxXx]

hat denn wirklich keiner eine idee?
wäre echt dringend und vor allem wichtig für mein Projekt
Danke bereits im voraus!

 

[SlaterB]

eine Stunde ist bisschen knapp an warten

was ist denn exakt dein Ziel? als Datenstruktur ist deine Map schon eine gute Grundlage,
wenn du weißt dass alles mit x1 anfängt und zusammenhängt, dann hast du auch den Start zum Durchlauf,

eine mögliche Rekusion wäre

Start: rek(x1);

rek(Kette) {
  suche Nachfolger des letzten Kettenelements in Map
  keine Nachfolger? -> Kette fertig, irgendwas damit machen, speichern, ausgeben, ..
  sonst:
  for (alle Nachfolger) {
     rek(kette + neues Element);
  }
}

schon fertig, sowas in der Art?

 

[chalkbag]

Klingt für mich nach Mantelbindung aus Datenbanksystemen, aber egal.

An sich Geschmacksache, du kannst eine eigene Datenstruktur erzeugen, z.b. wie folgt:

//achtung Pseudocode

class rowElement{

final String name;
final ArrayList<String> childRef;

public rowElement(final String vName, ArrayList vChildRef) {
    this.childRef = vChildRef;
    this.name = vName;
}

public ArrayList<String> getchildRefs() {
    // evtl. hier copy verwenden
    return this.childRef;
}

public String getName() {
    return this.name;
}


}

was aber nicht notwendig ist. Und dann schreibst du eine iterative oder noch besser rekursive Methode welche die Liste deiner Elemente durchgeht.

//achtung Pseudocode

public void walkTreeStep(final String element, final String currentRef) {
    ArrayList<String> currentList = map.get(element);
    if (currentList.length == 0) {
        System.out.println(currentRef);
        return;
    }
    for (String c: currentList) {
         walkTreeStep(c, currentRef+", "+c);
    }

}

Ob der Code so richtig ist kann ich nicht sagen, aber einfach ausprobieren. Die Idee sollte klar sein damit?

 

[NerdiiXxX]

also würde man es anhand einer baumstruktur betrachten wäre x1 die wurzel des baumes und ich will damit bezwecken, dass
alle möglichen Wege ausgegeben werden wie in dem beispiel veranschaulicht...
nur bekomm ich das beim besten willen nicht hin. =(

vielen dank schon mal Slater

 

[Nerdiixxx]

Hallo chalkbag,

vielen Dank schon mal für deine Bemühungen,

Meine arraylist sieht derzeit aus wie gehabt:
x1 ; x2 , x3 , x4 , x5 , x6 , x7 , x8
x2 ; x3 , x4
x3 ; x4 , x5
x4 ; x6 , x7 , x8
x8 ; x9 , x10 , x11
x11 ; x12

Vor dem Semikolon ist der Key(String), dahinter das Value(Arraylist<String>)
Name der Map lassen wir mal auf "map"

Habe deine klasse erstellt
allerdings is mir noch cniht ganz klar, was du mit "copy verwenden" meinst?
wärst du so nett mir das noch zu erklären
bin leider noch nciht soweit, das übersteigt mein können bisher was du hier angefertigt hast ^^

habwe die void methode so übernommen
kleinen schönheitsfehler ausgebessert "size()" statt length bei arraylist
und sie in der main methode aufgerufen allerdings bekomm ich keine ausgabe =/

Vielen Dank bereits im Voraus

 

[chalkbag]

Hallo,

die Klasse rowElement brauchst du nicht zwangsweise, also können wir sie auch erstmal weglassen.
(Mit copy meinte ich, das du die ArrayListe kopierst bevor du sie zurück gibst, da du sonst mittels einer Getter Methode die Liste manipulieren könntest, aber das hat nichts mit dem Thema zu tun, also auch erstmal egal).

Ob die void Methode stimmt kann ich nicht sagen, hab sie nur hier im Forum eingetippt, durchaus möglich das ich auch einen Denkfehler habe.

Als map meinte ich deine a7CallExecStorProd TreeMap.

Aufruf geht dann mit dem ersten Schlüssel der TreeMap. Also dort wo x1 steht (a7CallExecStorProd.getKeySet().get(0) oder so, also den ersten Schlüssel erfragen).

Vielleicht hilft dir auch der Pseudocode von SlaterB mehr, der macht unterm Strich das gleiche nur halt in echter Sprache erklärt.

[edit] könnte auch sein, dass ich nicht prüfen muss ob die Liste leer ist, sondern ob null. Weil wenn Schlüssel nicht in Map, bekomm ich wohl auch keine Arraylist zurück. Wie gesagt, das war nur pseudocode und ist sicherlich noch etwas anzupassen.

 

[Nerdiixxx]

vielleicht scheiter ich auch daran, dass ich ihm das falsche element bzw currentRef übergebe.
was hast du dafür jeweils vorgesehenw enn ich fragen darf?

 

[chalkbag]

der erste Aufruf folgt mit dem ersten Schlüssel der Treemap, "x1", und als currentRef "" bzw new String().

 

[Nerdiixxx]

oke bin jetzt mal beim bugfixen...
ich übergebe ihm dem ersten key sieht dann so aus:

walkTreeStep(a7CallExecStorProd.firstKey(), new String());

in der currentList beinhaltet jetzt vorerst erst alle elemente der Arraylis der Treemap vom schlüssel(x1), nach dem ersten durchlauf is currentRef ", X2" und läuft danach in einen nullpointer exception =/

 

[chalkbag]

public static void walkTreeStep(final String element, final String currentRef) {
	    ArrayList<String> currentList = myMap.get(element);
	    if (currentList == null || currentList.size() == 0) {
	        System.out.println(currentRef);
	        return;
	    }
	    for (String c: currentList) {
	         walkTreeStep(c, currentRef+", "+c);
	    }
	 
	}

rufe ich momentan mit

walkTreeStep("x1","x1");

was sehr unschön ist, aber ich denke du könntest schauen, ob das Ergebnis stimmt :rtfm:

 

[Nerdiiixxx]

Also bis hier her schon mal vielen herzlichen Dankd ass du dir die Zeit für mich nimmst

das ergebnis scheint mir noch recht suspekt =/ er spukt mir jede mögliche kombination, die möglich sind mit den übergebenen parametern.
ich glaube ich zeige dir gleich anhand einer grafik wie es eig gemeint war. einen moment bitte.

 

[Nerdiiix3]

soooo hier hab ich das mal eben grafisch hingezaubert:

http://img717.imageshack.us/img717/4083/teeeest.jpg
X1 ruft direkt auf:
x2, x3, x5, x7, x8, x10

x2 ruft direkt auf:
x3

x3 ruft direkt auf:
x4

x4 ruft direkt auf:
x5

x5 ruft direkt auf:
x6

Sos ieht die Treemap aus:
Keys: Values:

x1 x2, x3, x5, x7, x8, x10
x2 x3
x3 x4
x4 x5
x5 x6
x6 x7

Die Ausgabe die erzeugt wierden soll soll anhand der grafik so aussehen:
x1 -> x2 -> x3-> x4 -> x5 -> x6
x1 -> x3 -> x4 -> x5 -> x6
x1 -> x5 -> x6


Das selbe prinzip für x7-x11

 

[SlaterB]

poste doch deinen Code, was vor allem noch fehlt ist eine main-Methode mit Aufbau der Beispiel-Map,
dann kann man korrigieren, falls etwas zu korrigieren ist

 

[Nerdiiix3]

Mein Code ist etwas lang,
ich analysiere ein datenbankskript mithilfe von pattern matchern und dem bufferedreader, mit diesen ergebnissen befülle ich eine arraylist, mit welchen wiederrum ich die Map erstelle.

Mit den "x1" und so weiter habe ich das nur etwas vereinfacht aber heir ist der code.

package Find;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.io.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeMap;
import java.util.Map.Entry;

public class TestFind {

	// Set Charset
	Charset cs = Charset.forName("UTF-8");
	// create Patter/Matches
	static String suchtext = "CREATE PROCEDURE";
	static String suchtext2 = "EXEC\t";
	// Create arraylists
	static ArrayList<String> readline = new ArrayList<String>();
	static ArrayList<String> createProcedure = new ArrayList<String>();
	static ArrayList<String> createExecStoProd = new ArrayList<String>();
	static ArrayList<String> createStoProdTable = new ArrayList<String>();
	static ArrayList<String> empty = new ArrayList<String>();
	static ArrayList<String> a7dboarray = new ArrayList<String>();

	static List<String> a3CallExecStorProd = new ArrayList<String>();
	static TreeMap<String, ArrayList<String>> a7CallExecStorProd = new TreeMap<String, ArrayList<String>>();

	String test = "";
	String output = "";
	int counter = 0;

	String loadFile = "//RNMC0F21/P875413$/P875413.HOME/Redirected_Profile/Desktop/TSQL/TSQL-Programmcode.txt";

	public void CreateExecArray() {
		try {
			FileInputStream fh = new FileInputStream(loadFile);
			DataInputStream in = new DataInputStream(fh);
			BufferedReader br = new BufferedReader(
					new InputStreamReader(in, cs));
			String zeile = "";

			Pattern p = Pattern.compile(suchtext);
			Pattern e = Pattern.compile(suchtext2);
			int count = 0;

			while ((zeile = br.readLine()) != null) {
				++count;

				if (p.matcher(zeile).find() == true) {
					int start = zeile.lastIndexOf("[");
					int finish = zeile.lastIndexOf("]") + 1;
					createExecStoProd.add(zeile.substring(start, finish));
				}
				if (e.matcher(zeile).find() == true) {
					int start = zeile.lastIndexOf("[");
					createExecStoProd.add("'" + zeile.substring(start));
				}

			}

			in.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void GetCallAndStoredProc() {
		int arrayposition = 0;
		boolean basereport = false;
		ArrayList<String> temp = new ArrayList<String>();

		for (int i = 0; i < createExecStoProd.size(); i++) {
			if (createExecStoProd.get(i).contains("basereports")) {
				// createExecStoProd.add(arrayposition,
				temp.add(createExecStoProd.get(i));
				createExecStoProd.remove(i);
				arrayposition++;
				basereport = true;

			}
			while (i < createExecStoProd.size() && basereport == true) {
				if (createExecStoProd.get(i).startsWith("'")) {
					temp.add(createExecStoProd.get(i));
					createExecStoProd.remove(i);
					arrayposition++;
					continue;
				} else {
					basereport = false;
				}

			}
		}
		createExecStoProd.addAll(0, temp);
	}

	public void GetCallAndStoredProc2() {
		String old = null;
		boolean checker = true;
		boolean checker2 = false;
		empty.add(" ");

		for (final String s : createExecStoProd) {
			if (s.startsWith("'")) {
				a7dboarray.add(s.replaceAll("'", ""));
				checker = false;
				checker2 = false;
			} else {

				if (a7dboarray.size() >= 1) {
					checker2 = true;
				} else {
					checker2 = false;
				}
				if (checker2 == true) {
					Collections.sort(a7dboarray);
					a7CallExecStorProd.put(old, new ArrayList<String>(
							a7dboarray));
					a7dboarray.clear();

				}
				old = s;
				checker = true;

			}

		}
		if (a7dboarray.size() >= 1) {
			a7CallExecStorProd.put(old, new ArrayList<String>(a7dboarray));
		}
	}


	public void walkTreeStep(final String element, final String currentRef) {
		ArrayList<String> currentList = a7CallExecStorProd.get(element);
		if (currentList == null || currentList.size() == 0) {
			System.out.println(currentRef);
			return;
		} else {

			for (String c : currentList) {
				walkTreeStep(c, currentRef + ", " + c);
			}
		}
	}

	public TestFind() {
		CreateExecArray();
		GetCallAndStoredProc();
		GetCallAndStoredProc2();
		walkTreeStep(a7CallExecStorProd.firstKey(), a7CallExecStorProd.firstKey());
		// output();

	}
	public static void main(String[] args) throws FileNotFoundException,
			IOException {
		// TODO Auto-generated method stub
		 new TestFind();
	}

}

 

[SlaterB]

du hattest keine Vermutung, was mein Ziel war mit dem Wunsch an dich, Code zu posten?
dass es um das Ausprobieren der besprochenen Funktionalität geht?
dass dein Code mit nicht vorhandener DB usw. kaum hilft?

mangels Mitarbeit von deiner Seite (positiver kann ich es nicht ausdrücken ) musste ich also selber ein Testprogramm bauen, welches von jedermann leicht auszuprobieren ist:

public class Test
{
    static Map<String, List<String>> map = new HashMap<String, List<String>>();

    public static void main(String[] args)
    {
        add("x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8");
        add("x2", "x3", "x4");
        add("x3", "x4", "x5");
        add("x4", "x6", "x7", "x8");
        add("x8", "x9", "x10", "x11");
        add("x11", "x12");
        walkTreeStep("x1", "x1");

    }

    private static void add(String key, String... values)
    {
        map.put(key, Arrays.asList(values));
    }

    public static void walkTreeStep(final String element, final String currentRef)
    {
        List<String> currentList = map.get(element);
        if (currentList == null || currentList.size() == 0)
        {
            System.out.println(currentRef);
            return;
        }
        else
        {
            for (String c : currentList)
            {
                walkTreeStep(c, currentRef + ", " + c);
            }
        }
    }
}

die Ausgabe dieses Programms ist in der Tat etwas länger, 20 Kombinationen oder so,

jetzt fällt mir auf, dass dein Screenshot überhaupt nicht mehr zur ursprünglichen Map-Beschreibung passt?
X5 leitet im Bild beispielsweise auf X6 weiter, in der ursprünglichen Beschreibung fehlt dies

im Testprogramm kannst du die Map auf die korrekten neuen Einstellungen umändern und dann diskutieren,
falls es etwas zu diskutieren gibt,
was in deinem DB-Programm darüber hinaus falsch läuft kann wohl kaum jemand beurteilen

bzw. das arbeitet mit Dateien, da hättest du ja eine Datei mit posten können.. bzw. mache das noch wenn es dazu Fragen gibt

 

[chalkbag]

Sos ieht die Treemap aus:
Keys: Values:

x1 x2, x3, x5, x7, x8, x10
x2 x3
x3 x4
x4 x5
x5 x6
x6 x7

Die Ausgabe die erzeugt wierden soll soll anhand der grafik so aussehen:
x1 -> x2 -> x3-> x4 -> x5 -> x6
x1 -> x3 -> x4 -> x5 -> x6
x1 -> x5 -> x6

Überdenk das mal, dass ist falsch, da ich z.B. von x6 noch zu x7 komme.

Mein Programm erzeugt
x1, x2, x3, x4, x5, x6, x7
x1, x3, x4, x5, x6, x7
x1, x5, x6, x7
x1, x7
x1, x8
x1, x10
x1, x8
was nach meiner Logik korrekt wäre. Wenn das nicht so aussehen soll, dann muss die TreeMap eben entsprechend aussehen.

 

[SlaterB]

oh, stimmt, inzwischen ist ja von einer neuen Map die Rede,
wie auch immer, korrekt eingeben, dann funktioniert es auch

 

[Nerdiiix3]

Ja da muss ich dir recht geben da hättest du recht
allerdings hat der Pfad: x1 -> x2 -> x3-> x4 -> x5 -> x6
Laut dem Bild keine Direkte Verbindung mehr zu x7, weshalb x7 sich an dieser Reihe nciht mit einreihen dürfte

Ohh man ich hab bereits Kopfschmerzen, sitze hier mit 3 Kollegen und wir sind nicht in der Lage, das zu Lösen ohne euch wären wir noch weiter hinten
Vielen Dank soweit

 

[SlaterB]

ich weiß nicht ob dein letztes Posting ausdrückte, dass das Problem gelöst ist,
aber der einzige Grund für x7 in der Lösung ist genau der dass eben x6->x7 in der Map enthalten ist,

warum musst du wissen, entweder streichen oder deinen parse-Code überprüfen,
an der Analyse der Map liegt es nicht..

 

[Nerdiiix3]

Hallo Slater und Chalkbag

vielen Dank, es funktioniert nun alles wie es funktionieren sollte(Vorerst)
Das ding hatte mir die letzten 2 Tage starke Kopfschmerzen bereitet, war gestern nicht mehr so ganz in der lage alles zu überblicken.
Hattest natürlich vollkommen recht Slater.

VIELEN HERZLICHEN DANK euch Beiden.
Soviel an dieser Stelle noch angemerkt =)


eines hab ich allerdings noch.
Gibt es eine Möglichkeit, die Mapeinträge(Values) in der reihenfolge auszugeben wie ich sie einlese

sprich:
Wenn ich das hinzufüge:
x1 ; x4 , x3 , x5 , x8 , x6 , x7 , x2
x2 ; x3 , x4
x3 ; x4 , x5
x4 ; x6 , x7 , x8
x8 ; x9 , x10 , x11
x11 ; x12

Dass die Map diese Reihenfolge auch beibehält und auch nach dieser Reihenfolge vorgeht?

 

[SlaterB]

LinkedHashMap

 

[Nerdiiix3]

super dankeschön, eine letzte Bitte hätte ich, bevor wir das thema als erledigt ansehen können

Was passiert in der Methode genau?
Als Azubi ist das neu und etwas schwer nachvollziehbar für mich.


Vielen vielen Dank euch beiden!! =)

 

[SlaterB]

'was passiert' ist nie eine gute Frage, jeden Befehl einzeln solltest du kennen oder nachfragen,
insgesamt passiert eben die Summe dieser Dinge,

Rekursion kann bisschen verwirrend sein, verfolge die wiederholte Ausführung Schritt für Schritt mit zunächst einfachen Beispiel und dann immer komplexer (1 Eintrag, 2 Einträge usw.)

 

[Nerdiiiix3]

Oke, wir haben es debuggt und schritt für schritt die variablen verglichen und so zumindest einen anhaltspunkt bekommen.

eine Frage:
Kann man irgendwie eine art Durchschnittswert zu testzwecken ausrechnen Ausgehend davon dass:
Insgesamt beinhalten die verschiedenen "x" die wir als keys besetzt haben 158 einträge

also
Values von x1 + values von x2 + values von x3 +....
ergeben 158...
insgesamt gibt es 47x also von x1 bis x47
isgesamt beinhaltet meine Arraylist nämlich
9778 Einträge

 

[SlaterB]

verstehe ich nicht genau, vielleicht wäre es einfacher wenn du den Durchschnitt für eines der bekannten Beispiele angibst