JAVA JTree rekursiv umschreiben

[SX15]

Hallo , ich habe eine Frage:

Ich habe mittlerweile mein damaliges Problem mit dem Baum etc gelöst. Nun kam aber ein weiteres auf.

Es soll ein JTree angelegt werden, der als oberste Wurzel Berechtigungsgruppen aus einer Datenbank enthält . Die habe ich auch schon rausgelsen alles fertig. Sind etwas 50 Stück und sehen etwa so aus:

BG_ID (Bsp.: 5), BG_BEZEICHNUNG(Bsp.: Administration)

darunter kommen Prozessgruppen die etwa so ausehen:

PG_ID (Bsp.: 4), PG_BEZEICHNUNG(Bsp.: anlegen)

Damit man Berechtigungsgruppen und Prozessgruppen zuordnen kann gibt es eine Beziheungstabelle zwischen berechtigungsgruppen und Prozessgruppen:

BG_ID (Bsp.: 5), PG_ID(Bsp.:4)

Dadurch kann man beispielsweise die Administration mit der Berechtigungsgruppen ID (5) der Prozessgruppe "anlegen" mit der Prozessketten ID (4) genau zuordenen und als Ast im Jtree darutner schreiben, denn
BG_ID (Bsp.: 5), gehört zu G_ID(Bsp.:4)

Unter den Prozessgruppen gibt nochmals Prozessgruppen, da eine Prozessgruppe einer anderen Prozessgruppe zugeordnet sein KANN. Und diese wiederum KANN einer anderen auch wieder zugeordnet sein, sodass ich das nicht mit eienr normalen Schleife darstellen kann.
Dafür habe ich eine Beziehungstablle

PG_ID_VON(Bsp:4) ; PG_ID_ZU(Bsp.:7)

Mithilfe dieser beziehugnstablle kann man dann herausfindenw elche PG zu welcher PG gehört.

Ich habe den JTREE bereits, allerdings NICHT rekursiv, was heißen mag:
Er zeigt mir alle ebrechtigungsgruppen an, die dazugehörigen Prozessgruppen, aber nicht die DARUNTERLIEGENDEN PROZESSGRUPPEN, odnern gleich die Funktion.

Wichtig noch eine Prozessgruppe muss nicht unbedingt mit eienr Funktion enden sondern kann auch mit eienr anderen Prozessgruppe enden und muss nicht ubnbedingt eine Funktion haben.


DAS GANZE SIEHT ETWAS SO AUS..

WURZEL
--> Berechtigungsgruppe
.......--> PROZESSGRUPPE
..............--> (HIER SOLL NUN DIE UNTERPROZESSGRUPPE HIN WENN ES EINE GIBT)
.......................--> (ZUM SCHLUSS FALS VORHANDEN DIE FUNKTION)

JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// Erzeugen des Wurzelverzeichnisses
		//-----------------------------------------------------------------------------------------------------------------------------------
		
		DefaultMutableTreeNode root = new DefaultMutableTreeNode("BERECHTIGUNGSGRUPPEN - PROZESSGRUPPEN - FNKTIONEN");
		
		// Erzeugen des Verzeichnisses : Berechtigungsgruppen
		//-----------------------------------------------------------------------------------------------------------------------------------	
		for (java.util.Map.Entry<java.lang.Integer, java.util.ArrayList<Integer>> entry : Beziehung_BG_PG
				.entrySet()) {
			// System.out.println(benutzerGruppen_BG.get(entry.getKey()));
			DefaultMutableTreeNode node = new DefaultMutableTreeNode(
					benutzerGruppen_BG.get(entry.getKey()));
			root.add(node);
			java.util.ArrayList<Integer> wertliste = (java.util.ArrayList) entry.getValue();

			// Erzeugen des Verzeichnisses: Prozessgruppen
			//-----------------------------------------------------------------------------------------------------------------------------------
			
			for (Integer pg : wertliste) {
				
				DefaultMutableTreeNode nodePG = new DefaultMutableTreeNode(
						benutzerGruppen_PG.get(pg));
				node.add(nodePG);
				
				
				// Erzeugen zweier Untergruppen für die nachfolgenden Inhalte	
				//-----------------------------------------------------------------------------------------------------------------------------------
				
								
					//for (Integer a=0 ; a < 1; a++){
					DefaultMutableTreeNode nodekn1 = new DefaultMutableTreeNode("Prozessgruppen in Prozessgruppen");
					DefaultMutableTreeNode nodekn2 = new DefaultMutableTreeNode("Funktionen");
					//DefaultMutableTreeNode nodekn3 = new DefaultMutableTreeNode("Funktionen in anderen Prozessgruppen");
					
						nodePG.add(nodekn1);
						nodePG.add(nodekn2);
					//	nodePG.add(nodekn3);
					
					
						// Erzeugen des Verzeichnisses Funktionen 
						//-----------------------------------------------------------------------------------------------------------------------------------
												
					if (Beziehung_PG_Funktionen.get(pg) != null) {
					// Für Prozessgruppe pg alle Funktionen ermitteln und ann
					// nodePG anhängen
					for (Integer funktionsNR : Beziehung_PG_Funktionen.get(pg)) {
						//System.out.println(funktionsNR);
						DefaultMutableTreeNode nodeFkt = new DefaultMutableTreeNode(
								benutzerGruppen_Funk.get(funktionsNR));
						nodekn2.add(nodeFkt);
	
						//-----PROZESSGRUPPEN ZU PROZESSGRUPPEN--------------------------------------------------------------------------------
					for (java.util.Map.Entry<java.lang.Integer, java.util.ArrayList<Integer>> entry3 : Beziehung_PG_PG
							.entrySet()) {
					DefaultMutableTreeNode PGPG = new DefaultMutableTreeNode(
							benutzerGruppen_PG.get(entry3.getKey()));
					nodekn1.add(PGPG);
					//----------------------------------------------------------------------------------------------------------------------

					}
					}
			}
					}	
		}

			JTree tree = new JTree(root);
			frame.add(new JScrollPane(tree));
			frame.pack();
			frame.setVisible(true);.edit();

 

[SX15]

KAnn mir hier niemand helfen ?

 

[ARadauer]

Beziehung_PG_Funktionen ??? camelCase hab ich schon 3 mal gesagt!!!

Stell mir bitte mal deinen gesamten Code und Testdatein online, dann schau ich mir das an...

 

[SX15]

Aber bitte , du musst dir ncht die Arbeit machen das alles neuzumachen, ich weiss das einige Fehler drinne sind und das man bestimmte Sachen bei Java nicht macht, das werd eich beim nächsten Programm berücksichtigen, Es geht mir hier ausdchlißelich u den Baum der rekursiv sein soll . Die VAribalen stehen ja beim Code dabei wenn ihr die braucht weil ich habe mir schon ein beispiel reausgesucht womit man den baum rekursic v machen kann aber das bringt mir garnichts ich lerne Java erst sein 2 Wochen deswegen hilft es mir weitaus mehr wenn ich einenf ertigen Code habe der funzt und ich dann schauen kann wie da sgeht (jede rlernt anderster) Ich lerner so am besten habe ich schon oft festgestellt. DER BAUM (von wo man alles startet)

import java.awt.Button;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;

import org.omg.CORBA.PUBLIC_MEMBER;

import sun.misc.Sort;

import com.sun.org.apache.xalan.internal.xsltc.runtime.Node;

import fieloperations.DateiLesen;

public class Baum {

	private static final DefaultMutableTreeNode node = null;
	static java.util.HashMap<java.lang.Integer, java.lang.String> benutzerGruppen_BG = null;
	static java.util.HashMap<java.lang.Integer, java.lang.String> benutzerGruppen_PG = null;
	static java.util.HashMap<java.lang.Integer, java.lang.String> benutzerGruppen_Funk = null;
	static java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> Beziehung_BG_PG = null;
	static java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> Beziehung_PG_PG = null;
	static java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> Beziehung_PG_Funktionen = null;
	
	public static void erzeugeBaum()
		{
		
//------------------------------------------------------------------------------------------------------------------------------------
// AUFBAU DES JTREE BAUMMODELLS 
// Durch die einzelnen for-Schleifen wird dem Tree davor immer ein neues "Child" Oder "Ast" angehängt.
//------------------------------------------------------------------------------------------------------------------------------------
	
		
																								
		
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// Erzeugen des Wurzelverzeichnisses
		//-----------------------------------------------------------------------------------------------------------------------------------
		
		DefaultMutableTreeNode root = new DefaultMutableTreeNode("BERECHTIGUNGSGRUPPEN - PROZESSGRUPPEN - FNKTIONEN");
		
		// Erzeugen des Verzeichnisses : Berechtigungsgruppen
		//-----------------------------------------------------------------------------------------------------------------------------------	
		for (Map.Entry<Integer, ArrayList<Integer>> entry : Beziehung_BG_PG
				.entrySet()) {
			// System.out.println(benutzerGruppen_BG.get(entry.getKey()));
			DefaultMutableTreeNode node = new DefaultMutableTreeNode(
					benutzerGruppen_BG.get(entry.getKey()));
			root.add(node);
			ArrayList<Integer> wertliste = (ArrayList) entry.getValue();

			// Erzeugen des Verzeichnisses: Prozessgruppen
			//-----------------------------------------------------------------------------------------------------------------------------------
			
			for (Integer pg : wertliste) {
				
				DefaultMutableTreeNode nodePG = new DefaultMutableTreeNode(
						benutzerGruppen_PG.get(pg));
				node.add(nodePG);
				
			
				// Erzeugen zweier Untergruppen für die nachfolgenden Inhalte	
				//-----------------------------------------------------------------------------------------------------------------------------------
				
								
					//for (Integer a=0 ; a < 1; a++){
					DefaultMutableTreeNode nodekn1 = new DefaultMutableTreeNode("Prozessgruppen in Prozessgruppen");
					DefaultMutableTreeNode nodekn2 = new DefaultMutableTreeNode("Funktionen");
					//DefaultMutableTreeNode nodekn3 = new DefaultMutableTreeNode("Funktionen in anderen Prozessgruppen");
					
						nodePG.add(nodekn1);
						nodePG.add(nodekn2);
					//	nodePG.add(nodekn3);
					
					
						// Erzeugen des Verzeichnisses Funktionen 
						//-----------------------------------------------------------------------------------------------------------------------------------
												
					if (Beziehung_PG_Funktionen.get(pg) != null) {
					// Für Prozessgruppe pg alle Funktionen ermitteln und ann
					// nodePG anhängen
					for (Integer funktionsNR : Beziehung_PG_Funktionen.get(pg)) {
						//System.out.println(funktionsNR);
						DefaultMutableTreeNode nodeFkt = new DefaultMutableTreeNode(
								benutzerGruppen_Funk.get(funktionsNR));
						nodekn2.add(nodeFkt);
					}
						//-----PROZESSGRUPPEN ZU PROZESSGRUPPEN--------------------------------------------------------------------------------
						if (Beziehung_PG_PG.get(pg) != null) {
							// Für Prozessgruppe pg alle Funktionen ermitteln und ann
							// nodePG anhängen
							for (Integer p2g : wertliste) {
								
								DefaultMutableTreeNode nodePG1 = new DefaultMutableTreeNode(
										benutzerGruppen_PG.get(p2g));
								nodekn1.add(nodePG1);

										

										DefaultMutableTreeNode nodekn22 = new DefaultMutableTreeNode("Funktionen");
//										DefaultMutableTreeNode nodepgpgpg = new DefaultMutableTreeNode("Unterprozessgruppen in Uterprozessgruppen");
											nodePG1.add(nodekn22);
//											nodePG1.add(nodepgpgpg);
										
											
											if (Beziehung_PG_Funktionen.get(pg) != null) {
											
												// Für Prozessgruppe pg alle Funktionen ermitteln und ann
												// nodePG anhängen
												for (Integer funktionsNR : Beziehung_PG_Funktionen.get(pg)) {
													//System.out.println(funktionsNR);
													DefaultMutableTreeNode nodeFkt2 = new DefaultMutableTreeNode(
															benutzerGruppen_Funk.get(funktionsNR));
													nodekn22.add(nodeFkt2);
													
													
													
//													if (Beziehung_PG_PG.get(p2g) != null) {
//														if (Beziehung_PG_Funktionen.get(pg) != null){
//														// Für Prozessgruppe pg alle Funktionen ermitteln und ann
//														// nodePG anhängen
//														for (Integer p3g : wertliste) {
//															
//															DefaultMutableTreeNode nodePGpg2 = new DefaultMutableTreeNode(
//																	benutzerGruppen_PG.get(p2g));
//															nodepgpgpg.add(nodePGpg2);}

													
								
									
					}
			}
					}	}}}
		}

			JTree tree = new JTree(root);
			frame.add(new JScrollPane(tree));
			frame.pack();
			frame.setVisible(true);	
		
	
//REKURSION
			

//-----------------------------------------------------------------------------------------------------------------------------------------
//ZWEITER BAUM FUNKTIONEN - PROZESSGRUPPEN
//-----------------------------------------------------------------------------------------------------------------------------------------	

	
	
			JFrame frame2 = new JFrame();
			frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			
		// Erzeugen des Wurzelverzeichnisses
	    //-----------------------------------------------------------------------------------------------------------------------------------
			
			DefaultMutableTreeNode baum2 = new DefaultMutableTreeNode("FUNKTIONEN- PROZESSGRUPPEN");
			
	    // Erzeugen des Verzeichnisses : Berechtigungsgruppen
	    //-----------------------------------------------------------------------------------------------------------------------------------	
			for (java.util.Map.Entry<java.lang.Integer, java.util.ArrayList<Integer>> entry33 : Beziehung_PG_Funktionen
					.entrySet()) {
				// System.out.println(benutzerGruppen_BG.get(entry.getKey()));
				DefaultMutableTreeNode node33 = new DefaultMutableTreeNode(
						benutzerGruppen_Funk.get(entry33.getKey()));
				baum2.add(node33);
				java.util.ArrayList<Integer> wertliste2 = (java.util.ArrayList) entry33.getValue();

				for (Integer pg : wertliste2) {
					
					DefaultMutableTreeNode nodePG = new DefaultMutableTreeNode(
							benutzerGruppen_PG.get(pg));
					node33.add(nodePG);
				
					DefaultMutableTreeNode node1001 = new DefaultMutableTreeNode("Berechtigungsgruppen");
					DefaultMutableTreeNode node1002 = new DefaultMutableTreeNode("Unterprozessgruppen");
						nodePG.add(node1001);
						nodePG.add(node1002);
						
						
						if (Beziehung_PG_PG.get(pg) != null) {
							
							// Für Prozessgruppe pg alle Funktionen ermitteln und ann
							// nodePG anhängen
							for (Integer bg : Beziehung_PG_PG.get(pg)) {
								//System.out.println(funktionsNR);
								DefaultMutableTreeNode nodeFkt2 = new DefaultMutableTreeNode(
										benutzerGruppen_PG.get(bg));
								node1002.add(nodeFkt2);
								
								if (Beziehung_BG_PG.get(pg) != null) {
									
									// Für Prozessgruppe pg alle Funktionen ermitteln und ann
									// nodePG anhängen
									for (Integer bg1 : Beziehung_BG_PG.get(pg)) {
										//System.out.println(funktionsNR);
										DefaultMutableTreeNode nodeFkt3 = new DefaultMutableTreeNode(
												benutzerGruppen_BG.get(bg1));
										nodeFkt2.add(nodeFkt3);
									
									
									
										
										
						
								
//						JFrame frame5 = new JFrame();
//						frame5.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//						
//						DefaultMutableTreeNode baum6 = new DefaultMutableTreeNode("WURZEL");
//
//						for (int i=0;i<benutzerGruppen_Funk.size();i++){
//						
//			public DefaultMutableTreeNode node = new DefaultMutableTreeNode(benutzerGruppen_Funk.get(pg));
//					 DefaultMutableTreeNode node2 = new DefaultMutableTreeNode(benutzerGruppen_PG.get(pg));
//						
//						if (Beziehung_PG_Funktionen.get(pg) != null) {
//								
//							}
//								localParent = addComponents(localNode, localParent);
//				             parent = add(localParent); 
//
//							
//							}
				
//							else{			
//							   			
//								addNodeToTree(node2, node);  			
//							}
////							
//							
//			}
//						
//						return parent;
//						
//				 
//				
//				
//				public static Node addNodeToTree(DefaultMutableTreeNode node, Node parent){
//					
//				                // Setze alle Atribute, bei mir z.B. setUserObject(), etc.	
//					    parent.add(node);
//				    	return parent;
					
					
					
		///HIER//
					
					
					
			
		
				
						
				}}}}}}
			

				JTree tree2 = new JTree(baum2);
				frame2.add(new JScrollPane(tree2));
				frame2.pack();
				frame2.setVisible(true);	
				
				
			
				
//-----------------------------------------------------------------------------------------------------------------------------------------
//DRITTER BAUM PROZESSGRUPPEN - PROZESSGRUPPEN
//-----------------------------------------------------------------------------------------------------------------------------------------	

					
					
							JFrame frame3 = new JFrame();
							frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
							
						// Erzeugen des Wurzelverzeichnisses
					    //-----------------------------------------------------------------------------------------------------------------------------------
							
							DefaultMutableTreeNode baum3 = new DefaultMutableTreeNode("PROZESSGRUPPEN - PROZESSGRUPPEN");
							
					    // Erzeugen des Verzeichnisses : Berechtigungsgruppen
					    //-----------------------------------------------------------------------------------------------------------------------------------	
							for (java.util.Map.Entry<java.lang.Integer, java.util.ArrayList<Integer>> entry33 : Beziehung_PG_PG
									.entrySet()) {
								// System.out.println(benutzerGruppen_BG.get(entry.getKey()));
								DefaultMutableTreeNode node44 = new DefaultMutableTreeNode(
										benutzerGruppen_PG.get(entry33.getKey()));
								baum3.add(node44);
								java.util.ArrayList<Integer> wertliste3 = (java.util.ArrayList) entry33.getValue();

								for (Integer pg : wertliste3) {
									
									DefaultMutableTreeNode nodePG = new DefaultMutableTreeNode(
											benutzerGruppen_PG.get(pg));
									node44.add(nodePG);
							
						
								
										
								}}
							

								JTree tree3 = new JTree(baum3);
								frame3.add(new JScrollPane(tree3));
								frame3.pack();
								frame3.setVisible(true);	
		}
	
	
private static Object addNodeToTree(DefaultMutableTreeNode node2,
			DefaultMutableTreeNode node) {
		// TODO Auto-generated method stub
		return null;
	}


//	
//	public static Node addComponents(DefaultMutableTreeNode node, Node parent){
//		
//		for (int i=0;i<node.getChildCount();i++){
//			
//			localNode = (DefaultMutableTreeNode) node.getChildAt(i);
//			localParent = new Node();
//		
//			if(localNode.isLeaf()){
//				
//			}
//				
//				parent = addNodeToTree(localNode, parent);
//			
//			}
//
//			else{			
//			   			
//    			localParent = addComponents(localNode, localParent);
//             parent = add(localParent);    			
//			}
//			
//		 }
//		
//		return parent;
//		
//} 
//
//
//public static Node addNodeToTree(DefaultMutableTreeNode node, Node parent){
//	
//                // Setze alle Atribute, bei mir z.B. setUserObject(), etc.	
//	    parent.add(node);
//    	return parent;
//	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
//-----------------------------------------------------------------------------------------------------------------------------------------
//START DES PROGRAMMES/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------------------------------------------------------------------
	public static void main(String[] args) throws SQLException{
	
		
		String entschei = javax.swing.JOptionPane.showInputDialog("DATENBANK (1) Or CSV Files (2)");
		int i = Integer.parseInt(entschei);
		
	switch (i)
	{
	case 1:
		
		System.out.println("DB");	
		SQL dbReader = new SQL();
		benutzerGruppen_BG = dbReader.stammdatenEinlesen("select BG_ID, BEZEICHNUNG from uk3i01.vm_berechtgruppe order by BG_ID asc with ur;", "BG_ID", "BEZEICHNUNG");
		benutzerGruppen_PG = dbReader.stammdatenEinlesen("select PG_ID,BEZEICHNUNG from uk3i01.vm_prozessgruppe order by PG_ID asc with ur;",  "PG_ID", "BEZEICHNUNG");
		benutzerGruppen_Funk = dbReader.stammdatenEinlesen("select FKT_ID,TECHNISCHERNAME from uk3i01.vm_funktion order by FKT_ID asc  with ur;","FKT_ID","TECHNISCHERNAME");
		Beziehung_BG_PG = dbReader.beziehungEinlesen("select BG_ID,PG_ID  from uk3i01.vm_BG_zu_PG order by BG_ID asc with ur;", "BG_ID","PG_ID");
		Beziehung_PG_PG = dbReader.beziehungEinlesen("select PG_ID_VON,PG_ID_ZU  from uk3i01.vm_PG_zu_PG order by PG_ID_VON asc	with ur;","PG_ID_VON","PG_ID_ZU");
		Beziehung_PG_Funktionen = dbReader.beziehungEinlesen("select FKT_ID,PG_ID from uk3i01.vm_PG_ZU_FKT order by FKT_ID asc with ur;","FKT_ID","PG_ID");
		erzeugeBaum();
	break;
	case 2:
		System.out.println("CSV-DATEI einlesen");
		
//------------------------------------------------------------------------------------------------------------------------------------
// EINLESEN DER CSV - DATEIEN                               
//-----------------------------------------------------------------------------------------------------------------------------------

	
		// WICHTIG+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		// Beim Einlesen aus einem anderen Pfad bitte nach der Variable Berechtigungsgruppen,Prozessgruppen,Funktio, Bez_BG_PG,Bez_PG_PG und 
		//    Bez_PG_FK ein ";//" setzten !!!
		// WICHTIG+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		
				
		String Berechtigungsgruppen = javax.swing.JOptionPane.showInputDialog("Bitte geben Sie den Pfad der CSV Datei ein, welche die Berechtigungsgruppen enthält.");
		String Prozessgruppen = javax.swing.JOptionPane.showInputDialog("Bitte geben Sie den Pfad der CSV Datei ein, welche die Prozessgruppen enthält.");
		String Funktio = javax.swing.JOptionPane.showInputDialog("Bitte geben Sie den Pfad der CSV Datei ein, welche die Funktionen enthält.");
		String Bez_BG_PG = javax.swing.JOptionPane.showInputDialog("Bitte geben Sie den Pfad der CSV Datei ein, welche die Beziehungen Berechtigungs.Gruppe - Prozess.Gruppe enthält.");
		String Bez_PG_PG = javax.swing.JOptionPane.showInputDialog("Bitte geben Sie den Pfad der CSV Datei ein, welche die Beziehungen Prozess.Gruppe - Prozess.Gruppe enthält.");
		String Bez_PG_FK = javax.swing.JOptionPane.showInputDialog("Bitte geben Sie den Pfad der CSV Datei ein, welche die Beziehungen Prozess.Gruppe - Funktionen enthält.");
		java.lang.String datei_benutzergruppen_BG = Berechtigungsgruppen= "C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/Benutzergruppen.csv";
		java.lang.String datei_benutzergruppen_PG = Prozessgruppen= "C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/Prozessgruppen.csv";
		java.lang.String datei_benutzergruppen_Funk =  Funktio="C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/Funktionen.csv";
		java.lang.String datei_Beziehung_BG_PG =  Bez_BG_PG="C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/BG-PG.csv";
		java.lang.String datei_Beziehung_PG_PG = Bez_PG_PG="C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/PG-PG.csv";
		java.lang.String datei_Beziehung_PG_Funktionen = Bez_PG_FK ="C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/PG-FK.csv";

//------------------------------------------------------------------------------------------------------------------------------------
// EINLESEN DER EINZELNEN DATENSÄTZE MIT HILFE DER KLASSE DATEILESEN.JAVA
//------------------------------------------------------------------------------------------------------------------------------------
		
		DateiLesen reader = new DateiLesen();
		benutzerGruppen_BG = reader
				.StammdatenEinlesen(datei_benutzergruppen_BG);
		benutzerGruppen_PG = reader
				.StammdatenEinlesen(datei_benutzergruppen_PG);
		benutzerGruppen_Funk = reader
				.StammdatenEinlesen(datei_benutzergruppen_Funk);
		Beziehung_BG_PG = reader.BeziehungEinlesen(datei_Beziehung_BG_PG);
		Beziehung_PG_PG = reader.BeziehungEinlesen(datei_Beziehung_PG_PG);
		Beziehung_PG_Funktionen = reader
				.BeziehungEinlesen(datei_Beziehung_PG_Funktionen);

			
		erzeugeBaum();
						
		break;
	default:
		System.out.println("Keine gültige Eingabe");
	}
	//System.exit(0);
	}

	

	private java.util.ArrayList<java.lang.String> ermittleProzessGruppenZuBerechtigungsGruppe(
			java.lang.Integer berechtigungsId) {

		return null;
	}

}.edit();

Dateien werden hier eingelsen:

package fieloperations;
import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;
import java.util.HashMap;



public class DateiLesen {
	
//--------------------------------------------------------------------------------------------------------------------------------------
// EINLESEN VON BERECHTIGUNGSGRUPPE, PROZESSGRUPPEN UND VON FUNKTIONEN ALS HASHMAP
//--------------------------------------------------------------------------------------------------------------------------------------
	
	public java.util.HashMap<java.lang.Integer, java.lang.String> StammdatenEinlesen(java.lang.String dateiName) {
		
		java.util.HashMap<java.lang.Integer, java.lang.String> gruppen_BG = new java.util.HashMap<java.lang.Integer, java.lang.String>();
		 
		
		Integer key_BG = null;
		String value_BG = null;
	
		try {
			BufferedReader in = new BufferedReader(new FileReader(dateiName));
			String zeile = null;
			while ((zeile = in.readLine()) != null) {
				
				int semiPos = zeile.indexOf(";");
				key_BG = Integer.parseInt(zeile.substring(0, semiPos));
				value_BG = zeile.substring(semiPos+1);
				gruppen_BG.put(key_BG, value_BG);
				
				//System.out.println("Schlüssel: " + key_BG + " Wert: " + value_BG);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return gruppen_BG;
	}
	
	
//--------------------------------------------------------------------------------------------------------------------------------------
//   EINLESEN VON ALLEN BEZIHEUNGSTABELLEN ALS TREEMAP
//--------------------------------------------------------------------------------------------------------------------------------------
	
	public java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> BeziehungEinlesen(java.lang.String dateiName) {
		
		Integer key_Bez = null;
		Integer key_Bez_alt =1;
		Integer value_Bez = null;
		java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> gruppen_Bez = new java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>>();
		java.util.ArrayList<java.lang.Integer> values = new java.util.ArrayList<java.lang.Integer>();
	
		try {
			BufferedReader in = new BufferedReader(new FileReader(dateiName));
			String zeile = null;
			while ((zeile = in.readLine()) != null) {
				int semiPos = zeile.indexOf(";");
				
				// Key und Value lesen 
				key_Bez = Integer.parseInt(zeile.substring(0, semiPos));
				value_Bez = Integer.parseInt(zeile.substring(semiPos+1));
				
				// Wenn key sich nicht geändert hat: in Value-Liste für den Key neuen Value aufnehmen
				if(key_Bez == key_Bez_alt){
					values.add(value_Bez);
				// Wenn key sich geändert hat:;  
					} else {	
					gruppen_Bez.put(key_Bez_alt, values);
					values = new java.util.ArrayList<Integer>();
					values.add(value_Bez);
				}
				key_Bez_alt = key_Bez;
			}
			if(!values.isEmpty()) {
				gruppen_Bez.put(key_Bez_alt, values);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return gruppen_Bez;
	}
	
}
.edit();

So und nun zu den testdaten:

Ich kann dies enicht ganz hierreinfügen (Datenschutz) aber einen Ausschnitt. Sie werden als CSV aufgerufen im Programmcode:

schcike ich dir per PM

 

[SX15]

Über eine SQL Datenbank wird hier eingelsen:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Array;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.TreeMap;

//------------------------------------------------------------------------------------------------------------------------------------
// VERBINDUNG ZUR DATENBANK HERSTELLEN                              
//-----------------------------------------------------------------------------------------------------------------------------------

public class SQL {

	Connection con = null;

	// Konstruktor
	public SQL() throws SQLException {

		try {
			// Load the JDBC driver
			String driverName = "unwischtisch ;)";
			Class.forName(driverName);
			// Create a connection to the database
			//String serverName = ";)";
			//String mydatabase = ";)";
			String url =";)"
				//"jdbc:db2:" + serverName + "/" + mydatabase; // a JDBC
			// url
			String username = ";)))";
			String password = ";)))";
			con = DriverManager.getConnection(url, username, password);

			System.out.println("Erfolg");
		} catch (ClassNotFoundException e) {
			System.out.println("Could not find the database driver.");

		} catch (SQLException e) {
			System.out.println("Could not find the database.");

		}
		
			
		
	}
//--------------------------------------------------------------------------------------------------------------------------------------
// MANUELLER VERBINDUNGSTEST (wird nicht automatisch durchlaufen)                             
//--------------------------------------------------------------------------------------------------------------------------------------
	
	public static void main(String[] args) throws Exception {
	      SQL test = new SQL();
	      
	      
	       Statement st = test.con.createStatement();
			ResultSet berechtigungsgruppe = null;
			berechtigungsgruppe = st.executeQuery("Select * from uk3i01.vm_prozessgruppe where PG_ID = 122;");

	      
	      
	      System.out.println(berechtigungsgruppe.toString());
	    }

	
// --------------------------------------------------------------------------------------------------------------------------------------
// EINLESEN VON ALLEN BEZUGSTABELLEN ALS HASHMAP
// --------------------------------------------------------------------------------------------------------------------------------------
	
	public java.util.HashMap<java.lang.Integer, java.lang.String> stammdatenEinlesen(
			java.lang.String statement, java.lang.String spalte1, java.lang.String spalte2) throws SQLException {

		Statement st = null;
		st = con.createStatement();
		ResultSet berechtigungsgruppe = null;
		System.out.println(statement.toString());
		berechtigungsgruppe = st.executeQuery(statement);

		java.util.HashMap<java.lang.Integer, java.lang.String> gruppen_BG = new java.util.HashMap<java.lang.Integer, java.lang.String>();
		
		while (berechtigungsgruppe.next()) {
			Integer bg_id = Integer.parseInt(berechtigungsgruppe
					.getString(spalte1));
			String bezeichnung = berechtigungsgruppe.getString(spalte2);
			gruppen_BG.put(bg_id, bezeichnung);
		}
		return gruppen_BG;
	}

// --------------------------------------------------------------------------------------------------------------------------------------
// EINLESEN VON ALLEN BEZIHUNGSTABELLEN ALS TREEMAP
// --------------------------------------------------------------------------------------------------------------------------------------

	public java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> beziehungEinlesen(
			java.lang.String statement, java.lang.String spalte1, java.lang.String spalte2) throws SQLException {

		Statement st = null;
		st = con.createStatement();
		Integer bg_id_alt =1;
		ResultSet berechtigungsgruppe = null;
		Integer value_Bez = null;
		java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> gruppen_Bez = new java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>>();
		java.util.ArrayList<java.lang.Integer> values = new java.util.ArrayList<java.lang.Integer>();
		
		berechtigungsgruppe = st.executeQuery(statement);

		
		
		while (berechtigungsgruppe.next()) {
			Integer bg_id = Integer.parseInt(berechtigungsgruppe
					.getString(spalte1));
			value_Bez = Integer.parseInt(berechtigungsgruppe.getString(spalte2));
			
			if(bg_id == bg_id_alt){
				values.add(value_Bez);
			// Wenn key sich geändert hat:;  
				} else {	
				gruppen_Bez.put(bg_id_alt, values);
				values = new java.util.ArrayList<Integer>();
				values.add(value_Bez);
			}
			bg_id_alt = bg_id;
	}		
			if(!values.isEmpty()) {
				gruppen_Bez.put(bg_id_alt, values);
			

		}
		return gruppen_Bez;
	

	}}

.edit();

 

[SX15]

mehr habe ich net