unnötige Übergänge auschneiden

[Gast]

ich habe ein datei

A->B [Label="0"];
B->C [Label="0"];
C->D [Label="1"];

ich möchte die "0" Labels so eliminieren, dass es nacher nur noch A->D Label="1"]; gibt. Meine Überlegung ist ein Pattern so aufzustellen

String pattern = "(.*)\\-\\>(.*)\\[label\\=\\\"(.*)\\\"\\]\\;";

Das ergibt 3 Groupen wie
group(1)=A
group(2)=B
group(3)=0

group(1)=B
group(2)=C
group(3)=0

group(1)=C
group(2)=D
group(3)=1

Danach alles, wo es group(3)=0 gibt, löschen,
damit es nur noch A->D [Label="1"]; besteht.

Wie könnte so ein Code aussehen?
Wüsste jemand ein anderes Vorgehensweise?

 

[Marco13]

Wie könnte so ein Code aussehen?
Das hängt davon ab, welche IDE man verwendet. Im einfachsten Fall schwarz, auf weißem Hintergrund.

Wüsste jemand ein anderes Vorgehensweise?
Ja.

Aber mal im ernst: Da geht es doch vermutlich(!) nicht wirklich darum, irgendwelchen Text zu ersetzen? ???:L
Was soll denn z.B. bei

A->B [Label="0"];
B->C [Label="0"];
X->Y [Label="1"];
C->D [Label="1"];

rauskommen? (Ich kann mir die Antwort schon denken, aber vielleicht regt die Frage dich ja zum Nachdenken an :wink: )

 

[xysawq]

Ich raffs nich... ich leg mich wirklich gleich hin und schlafe, 3 Stunden diese Nacht waren wohl echt zu wenig.. ach Mist, nachher ist ja Fußball... oooooohh... wieder kein Schlaf...

 

[Gast]

Es geht darum, das wenn man nicht weiter kommt , tipps bzw. ünterstüzung bekommt!

 

[Gast]

An Marco13:
Hättest du da ein Tipp für eine andere Vorgehensweise

 

[xysawq]

Na jetzt hab ich endlich das Forum verstanden, ich dachte das wäre sowas wie ein langsamer Chat wo man eben mehrere Minuten auf eine Antwort seines Gesprächspartners warten muss.

Jedenfalls danke für die Aufklärung...

 

[SlaterB]

> ein Tipp für eine andere Vorgehensweise

die Strings in Objekte umwandeln und dann Code schreiben wie

if (regel1.getZiel().equals(regel2.getStart()) && regel1.getLabel() == 0) {
  regel1.setZiel(regel2.getZiel());
  delete(regel2);
}

 

[FArt]

Na jetzt hab ich endlich das Forum verstanden, ich dachte das wäre sowas wie ein langsamer Chat wo man eben mehrere Minuten auf eine Antwort seines Gesprächspartners warten muss.

Jedenfalls danke für die Aufklärung...

Was, das ist keine Singlebörse? Ich dachte hier sind nur Freaks unterwegs, die kein Privatleben haben ... Mist... ich muss weg...

 

[Marco13]

Ja, SlaterB hat die Lösung schon angedeutet. Keiner weiß, was durch dies ominösen Zeilen beschrieben werden soll, aber für mich hört es sich erstmal so an, was wäre das irgendws Graph- oder Relation- oder Matrixartiges (meinetwegen auch ein Matroid ... glaub' ich aber nicht). Vielleicht auch eine Grammatik, in Anlehung an SlaterB. Und je nachdem, was das ganze ist, und was am Ende rauskommen soll, gibt es da unterschiedliche Ansätze. Allen gemein wäre aber vermutlich, dass sie NICHT rein textbasiert (mit RegEx) arbeiten, sondern auf Objekten, die dem entsprechen, was durch diese Zeilen beschrieben wird.

 

[Gast]

Ja, es ist ein Graph. Die Kanten mit Gewicht = 0 sollen elimiert werden,

A->B [Label="0"];
B->C [Label="0"];
C->D [Label="1"];

sodass A->D [Label="1"] entsteht.

 

[xysawq]

Ich raffs immernoch nicht, aber ihr werdet schon wissen worüber ihr redet, und SlaterB und Marco13 sind sowieso schlauer als ich (momentan, weil ich gleich einpenne ).

Mach ihr das mal, und java-forum.org ist eine Singlebörse.
89,587% hier sind Single und eine Börse ist das ja wohl offensichtlich.

 

[Marco13]

Ja, dann lies' das ganze ein, so dass du einen rudimentären Graphen hast. (Man muss ja - wie in meinem ersten Beispiel angedeutet - auch davon ausgehen, dass das ganze beliebig kompliziert werden kann, und man dann mit Textersetung und RegEx nicht mehr weit kommt).

Irgendwie erinnert mich das jetzt aber ganz striking an http://www.java-forum.org/de/viewtopic.php?p=418940 ...

Wenn du dann einen Graphen hast ... leuchtet mir zwar nicht ein, warum man bei
A -> B -> C -> D
durch die Löschung der Kanten AB und BC eine Kante AD bekommen soll, aber ... das musst du dann wissen...

 

[Gast]

ein increment fällt in meine While schleife.(Wird nur die erste Zeile rausgegeben)
Kann Jemand mir denn fehlende Teil liefern?

 

[Gast]

Sorry Code hat gefehlt

while(m.matches()) {
			if (m.group(3).equals(0)){
//			if((m.group(3).equals("0")) ) {
        		String s;
        		String z;
				s = m.group(1);
        		z = m.group(2);
        		System.out.println("Nullübergänge: ");
        		System.out.println("Start s: "+ s);
        		System.out.println("Ziel z:"+ z);
        		result.append(myLine + "\n");
			}
			else{
				System.out.println("\t\t This remains: " + myLine);
				result.append(myLine);
				result.append("\n");
				}			
			}

[/code]

 

[SlaterB]

du hast recht, was m und myLine ist, tut nichts zur Sache,
gut dass du dazu nichts postest oder erklärst

es sieht jedenfalls so aus als wäre m immer gleich, m musst du ändern?

 

[Gast]

ich ergänze das ...

try {
			String pattern = "(.*)\\-\\>(.*)\\[label\\=\\\"(.*)\\\"\\]\\;";
			Pattern p = Pattern.compile(pattern);
			Matcher m = p.matcher(myLine);

			while(m.matches()) {
			if (m.group(3).equals(0)){
        		String s;
        		String z;

                       s = m.group(1);
        		z = m.group(2);
        		System.out.println("Nullübergänge: ");
        		System.out.println("Start s: "+ s);
        		System.out.println("Ziel z:"+ z);
        		result.append(myLine + "\n");
			}
			else{
				System.out.println("\t\t This remains: " + myLine);
				result.append(myLine);
				result.append("\n");
				}			
			}
		}catch (Exception e) {
			System.err.println("Error at Processing : " + e.getMessage());
		}
		writeNewLine(result.toString());
	}

 

[SlaterB]

immer noch gilt: für m.matches() braucht es keine Schleife, solange du nicht ständig neue myLines und neue m irgendwo her bekommst,

das sollte aber besser außen passieren:

BufferedReader
while(neue Zeile) {
Matcher erstellen
if(matches) { // kein while!
...
} else {
...
}

}

 

[Gast]

Danke!

 

[Marco13]

Poste mal dein Programm, wenn es fertig ist

 

[Gast]

Jetzt habe ich mein eingelesene Datei wie z.B....

A->B [Label="0"];
B->C [Label="0"];
C->D [Label="1"];

mit

String filename = "digraph1";
			FileInputStream fstream = new FileInputStream(filename);
			DataInputStream in = new DataInputStream(fstream);
			BufferedReader br = new BufferedReader(new InputStreamReader(in));
			String strLine;
			while ((strLine = br.readLine()) != null) {
				String pattern = "(.*)\\-\\>(.*)\\[label\\=\\\"(.*)\\\"\\]\\;";
				Pattern p = Pattern.compile(pattern);
				Matcher m = p.matcher(strLine);
if (m.matches()) {
					s = m.group(1);
					z = m.group(2);
					l = m.group(3);
					if (l.equals("0")) {
						
						System.out.println("Nullübergänge: " );
						
						myS =s;;
						myZ =z;
						
					strLine = strLine.replace(strLine, " ");
					System.out.println(strLine);
	
					} else {
						System.out.println(strLine);
						System.out.println("s =: "+s);
						System.out.println("Z =: "+z);
						System.out.println("l =:"+ l);
						result.append(strLine + "\n");
					}}

in den Pattern... (PS: das unten ist mein Ergebnis aufm Console(ohne Überflüssiges ))

myS=:A
myZ=: B

myS=:B
myZ=: C

C->D [Label="1"];
s =:C
z =: D
l =:1
myS=:null
myZ=: null



......umgewandelt

mein Ziel ist dann myZ und s zu verglichen, und falls dass die gleich sind ,s mit myS zu ersetzen.

Es klappt aber nicht....

ich vermute das den Vergleich nur in den Zeilen passiert.
Wie könnte ich das für das gesamte Text durchführen?

vielleicht besser das gesamte Code

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Beispiel1 {
	StringBuffer result = new StringBuffer();
	String s; //Anfangknoten
	String z; //Endknoten
	String l; //Labels
	String myS; //Anfangknoten von Nullübergänge
	String myZ; //EndKnoeten von Nullübergänge

	private void readRecords() {
		String filename = "digraph1";
		System.out.println(">>> read records ...");
		try {
			FileInputStream fstream = new FileInputStream(filename);
			DataInputStream in = new DataInputStream(fstream);
			BufferedReader br = new BufferedReader(new InputStreamReader(in));
			String strLine;
			while ((strLine = br.readLine()) != null) {
				String pattern = "(.*)\\-\\>(.*)\\[label\\=\\\"(.*)\\\"\\]\\;";
				Pattern p = Pattern.compile(pattern);
				Matcher m = p.matcher(strLine);
				if (m.matches()) {
					s = m.group(1);
					z = m.group(2);
					l = m.group(3);
					if (l.equals("0")) {
						
						System.out.println("Nullübergänge: " );
						
						myS =s;;
						myZ =z;
						
					strLine = strLine.replace(strLine, " ");
					System.out.println(strLine);
	
					} else {
						System.out.println(strLine);
						System.out.println("s =: "+s);
						System.out.println("Z =: "+z);
						System.out.println("l =:"+ l);
						result.append(strLine + "\n");
					}
					processRecords(strLine, s, z);
					
				}
			}
			in.close();
		} catch (Exception e) {
			System.err.println("Error: " + e.getMessage());
		}
	}

	private void processRecords(String myLine, String x, String y) {
		System.out.println("> process records ...");
		System.out.println("myS :" + myS);
		System.out.println("myZ :" + myZ);

		try {
			if (myZ.equals(s))  {

				System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Foung match");
			}
		} catch (Exception e) {
			System.err.println("Error at Processing : " + e.getMessage());
		}
		writeNewLine(result.toString());
	}

	private void writeNewLine(String line) {
		FileOutputStream fout;
		try {
			fout = new FileOutputStream(
					"C:\\Dokumente und Einstellungen\\mathenge\\Eigene Dateien\\MyOutPut\\Beispiel1.txt");
			new PrintStream(fout).println(line);
			fout.close();
		} catch (IOException e) {
			System.err.println("Unable to write to file");
			System.exit(-1);
		}
	}

	public static void main(String[] args) {
		System.out.println("start program ...");
		Beispiel1 x = new Beispiel1();
		x.readRecords();
		System.out.println("program finished ...");
	}
}

 

[SlaterB]

Tipp: entfernde den Datei-Einlese-Code und arbeite mit einem Array oder einer Liste von Strings im Programm definiert,
dann kann es jeder testen,

und dann bitte nochmal in Worten, was ungefähr passieren soll und stattdessen passiert,
die wievielte Zeile der Datei (des String-Arrays) Probleme macht usw.

nur mit Code und
> s =:C
> z =: D
> l =:1
kann man eher wenig anfangen

 

[Marco13]

s = Start
z = Ziel
l = Label

Ein bißchen Phantasie und Intutition (und eine Aufopferungsbreitschaft, die so unerschöpflich ist, dass man sich so eine Eingabedatei bastelt, auch wenn kein Grund zu der Annahme besteht, dass das ganze überhaupt funktionieren kann) wird man doch wohl erwarten dürfen!

 

[Gast]

Die Anfang- und End-Knoten von den Nullübergänge sollen in myStart bzw myZiel gespeichert werden(Zeile 139- 140), dannn wird die Übergänge(sprich Zeile) gelöscht. (143-151).
Amsonsten sollen die Anfangknoten in start gespeichert werden, und die Endknoten in ziel.
In der 170. Zeile soll myZiel und start vergliechen werden, aber das passiert nur zeilenweise und nicht für die gesamte Datei, wie ich es eigentlich machen möchte. Wie soll ich das abändern.

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Vector;
import java.util.regex.*;
public class MyPattern {
	StringBuffer result = new StringBuffer();
	String start; //Anfangknoten
	String ziel; //Endknoten
	String label; //Labels
	String myStart; //Anfangknoten von Nullübergänge
	String myZiel; //EndKnoeten von Nullübergänge
	
	static String[] data = new String[]{
		"digraph g {",
			"graph [mindist=\"20\" minlen=\"30\" overlap=\"false\" packmode=\"true\"]",
			"node [fontsize=\"10\"]",
			"edge [fontsize=\"12\"]",
			"PROCESS_MGR_MSG_RECEIVED_END->ORDER_CREATE     [label=\"268386\"];",
			"INITIATOR_ENGINE_END->CORRELATOR_DELAY   [label=\"29901\"];",
			"PROCESS_ENGINE_END->BEFORE_SEND_JMS_MSG  [label=\"3937\"];",
			"AFW_NODECON_EXECUTE_END->ORDER_UPDATE    [label=\"766\"];",
			"AFW_NODECON_EXECUTE_START->AFW_NODECON_EXECUTE_END   [label=\"335\"];",
			"ORDER_EXECUTED->AFW_BUILD_TASK_START     [label=\"261\"];",
			"ORDER_UPDATED->WLH_RECEIVER_DELAY  [label=\"232\"];",
			"ORDER_CREATE->ORDER_CREATED  [label=\"150\"];",
			"PROCESS_MGR_CREATE_PROC_START->PROCESS_MGR_CREATE_PROC_END [label=\"83\"];",
			"ORDER_CREATED->ORDER_EXECUTED [label=\"65\"];",
			"ORDER_SUCCEEDED->ORDER_REMOVED     [label=\"52\"];",
			"ORDER_UPDATE->ORDER_SUCCEEDED [label=\"47\"];",
			"RULEENGINE_CFG_RELOAD_END->JMS_INV_BEFORE_RQST_WITH_PROPS  [label=\"47\"];",
			"WLH_RECEIVER_END->ORDER_CREATE     [label=\"488\"];",
			"SERVICE_INVOKER_START->PROCESS_ENGINE_END      [label=\"45\"];",
			"JMS_INV_BEFORE_RQST_WITH_PROPS->JMS_INV_AFTER_RQST_WITH_PROPS    [label=\"45\"];",
			"PROCESS_MGR_TEMPLATE_FOUND->PROCESS_MGR_DEF_FOUND    [label=\"38\"];",
			"CACHE_MANAGER_WAIT_RECEIVE_START->PROCESS_MGR_START  [label=\"35\"];",
			"PROCESS_MGR_INSTANCE_FOUND->SERVICE_INVOKER_START    [label=\"32\"];",
			"RULEENGINE_CFG_RELOAD_START->RULEENGINE_CFG_RELOAD_END     [label=\"25\"];",
			"ORDER_REMOVED->ORDER_UPDATED [label=\"22\"];",
			"SERVICE_INVOKER_END->SERVICE_INVOKER_START     [label=\"19\"];",
			"STORE_SRV_ATTACH_END->ORDER_UPDATE [label=\"236\"];",
			"TP_GET_DATA_LOOKUP_ENTITY_START->TP_GET_DATA_LOOKUP_ENTITY_END   [label=\"13\"];",
			"STORE_ATTACHMENT_END->PROCESS_MGR_MSG_RECEIVED_START [label=\"12\"];",
			"MESSAGE_ADAPTER_INPUT_MSG_END->CLASSIFIER_END  [label=\"9\"];",
			"INIT_AFTER_DECIDER_ASYNC->INITIATOR_ENGINE_START     [label=\"6\"];",
			"CLASSIFIER_START->CLASSIFIER_END   [label=\"34\"];",
			"WLH_RECEIVER_DELAY->WLH_RECEIVER_START   [label=\"6\"];",
			"JMS_INV_BEFORE_RQST_WITH_PROPS->INITIATOR_ENGINE_START     [label=\"44\"];",
			"TP_GET_DATA_LOOKUP_PARAMS_START->TP_GET_DATA_LOOKUP_PARAMS_END   [label=\"4\"];",
			"PROCESS_MGR_DEF_FOUND->PROCESS_MGR_RUNTIME_OBJ_CREATED     [label=\"4\"];",
			"HF_START->HF_END  [label=\"2\"];",
			"BIC_NODE_CONV_START->BIC_NODE_CONV_END   [label=\"29\"];",
			"INIT_AFTER_DECIDER_ASYNC->PROCESS_MGR_START    [label=\"28\"];",
			"PROCESS_MGR_START->PROCESS_MGR_TEMPLATE_FOUND  [label=\"1\"];",
			"PROCESS_MGR_CREATE_PROC_END->INITIATOR_ENGINE_END    [label=\"1\"];",
			"AFW_BUILD_TASK_START->AFW_BUILD_TASK_END [label=\"1\"];",
			"CLASSIFIER_END->MESSAGE_ADAPTER_OUTPUT_MSG_START     [label=\"1\"];",
			"SERVICE_INVOKER_END->PROCESS_INSTANCE_FINAL    [label=\"1\"];",
			"MESSAGE_ADAPTER_INPUT_MSG_START->CLASSIFIER_START    [label=\"1\"];",
			"HF_ATTACH_END->HF_START [label=\"0\"];",
			"CORRELATOR_START->CORRELATOR_STORE_ATTACH_START      [label=\"0\"];",
			"MESSAGE_ADAPTER_INPUT_MSG_START->MESSAGE_ADAPTER_INPUT_MSG_END   [label=\"0\"];",
			"INITIATOR_ENGINE_START->CACHE_MANAGER_WAIT_RECEIVE_START   [label=\"0\"];",
			"WLH_RECEIVER_START->STORE_ATTACHMENT_START     [label=\"0\"];",
			"BIC_NODE_END->AFW_NODECON_EXECUTE_END    [label=\"5\"];",
			"AFW_NODECON_EXECUTE_START->BIC_NODE_START      [label=\"5\"];",
			"BIC_NODE_START->BIC_NODE_CONV_START [label=\"5\"];",
			"INIT_BEFORE_DECIDER_ASYNC->RULEENGINE_BEFORE_DECIDE  [label=\"0\"];",
			"HF_ATTACH_START->HF_ATTACH_END     [label=\"0\"];",
			"PROCESS_INSTANCE_FINAL->PROCESS_MGR_MSG_RECEIVED_END [label=\"0\"];",
			"CORRELATOR_STORE_ATTACH_START->STORE_ATTACHMENT_START      [label=\"0\"];",
			"PROCESS_MGR_MSG_RECEIVED_START->PROCESS_MGR_INSTANCE_FOUND [label=\"0\"];",
			"SERVICE_INVOKER_END->PROCESS_INSTANCE_RUNNING  [label=\"0\"];",
			"ORDER_DETAILS_ADAPTER_START->ORDER_DETAILS_ADAPTER_END     [label=\"2\"];",
			"HF_END->INIT_BEFORE_DECIDER_ASYNC  [label=\"0\"];",
			"MESSAGE_ADAPTER_INPUT_MSG_END->CLASSIFIER_START      [label=\"1\"];",
			"STORE_ATTACHMENT_START->STORE_ATTACHMENT_END   [label=\"0\"];",
			"MESSAGE_ADAPTER_INPUT_MSG_END->TP_GET_DATA_LOOKUP_ENTITY_START   [label=\"0\"];",
			"RULEENGINE_BEFORE_DECIDE->RULEENGINE_CFG_RELOAD_START      [label=\"0\"];",
			"PROCESS_MGR_MSG_RECEIVED_END->WLH_RECEIVER_END [label=\"0\"];",
			"CACHE_MANAGER_WAIT_RECEIVE_START->JMS_INV_AFTER_RQST_WITH_PROPS  [label=\"1\"];",
			"MESSAGE_ADAPTER_INPUT_MSG_END->TP_GET_DATA_LOOKUP_PARAMS_START   [label=\"0\"];",
			"PROCESS_MGR_RUNTIME_OBJ_CREATED->PROCESS_MGR_CREATE_PROC_START   [label=\"0\"];",
			"AFW_NODECON_EXECUTE_START->STORE_SRV_ATTACH_START    [label=\"1\"];",
			"CORRELATOR_END->PROCESS_MGR_MSG_RECEIVED_START [label=\"0\"];",
			"SERVICE_INVOKER_START->ORDER_DETAILS_ADAPTER_START   [label=\"0\"];",
			"AFW_BUILD_TASK_END->AFW_NODECON_EXECUTE_START  [label=\"0\"];",
			"STORE_ATTACHMENT_END->CORRELATOR_STORE_ATTACH_END    [label=\"0\"];",
			"PROCESS_INSTANCE_RUNNING->PROCESS_MGR_MSG_RECEIVED_END     [label=\"0\"];",
			"BIC_NODE_CONV_END->BIC_NODE_END    [label=\"0\"];",
			"TP_GET_DATA_LOOKUP_PARAMS_END->MESSAGE_ADAPTER_OUTPUT_MSG_START  [label=\"0\"];",
			"STORE_SRV_ATTACH_END->AFW_NODECON_EXECUTE_END  [label=\"1\"];",
			"TP_GET_DATA_LOOKUP_ENTITY_END->MESSAGE_ADAPTER_OUTPUT_MSG_START  [label=\"0\"];",
			"SERVICE_INVOKER_START->MESSAGE_ADAPTER_INPUT_MSG_START     [label=\"0\"];",
			"STORE_SRV_ATTACH_START->AFW_NODECON_EXECUTE_END      [label=\"1\"];",
			"CORRELATOR_DELAY->CORRELATOR_START [label=\"0\"];",
			"MESSAGE_ADAPTER_OUTPUT_MSG_END->SERVICE_INVOKER_END  [label=\"0\"];",
			"INIT_AFTER_DECIDER_ASYNC->CACHE_MANAGER_WAIT_RECEIVE_START [label=\"0\"];",
			"JMS_INV_AFTER_RQST_WITH_PROPS->RULEENGINE_AFTER_DECIDE     [label=\"0\"];",
			"MESSAGE_ADAPTER_OUTPUT_MSG_START->MESSAGE_ADAPTER_OUTPUT_MSG_END [label=\"0\"];",
			"INITIATOR_ENGINE_START->JMS_INV_AFTER_RQST_WITH_PROPS      [label=\"0\"];",
			"ORDER_DETAILS_ADAPTER_END->PROCESS_ENGINE_END  [label=\"0\"];",
			"RULEENGINE_AFTER_DECIDE->INIT_AFTER_DECIDER_ASYNC    [label=\"0\"];",
			"CACHE_MANAGER_WAIT_RECEIVE_START->RULEENGINE_AFTER_DECIDE  [label=\"3\"];",
			"CORRELATOR_STORE_ATTACH_END->CORRELATOR_END    [label=\"0\"];",
			"JMS_INV_AFTER_RQST_WITH_PROPS->INITIATOR_ENGINE_START      [label=\"1\"];",
			"JMS_INV_AFTER_RQST_WITH_PROPS->CACHE_MANAGER_WAIT_RECEIVE_START  [label=\"1\"];",
			"RULEENGINE_AFTER_DECIDE->INITIATOR_ENGINE_START      [label=\"0\"];",
			"STORE_SRV_ATTACH_START->STORE_SRV_ATTACH_END   [label=\"0\"];",
			"CACHE_MANAGER_WAIT_RECEIVE_START->INIT_AFTER_DECIDER_ASYNC [label=\"1\"];",
			"INITIATOR_ENGINE_START->INIT_AFTER_DECIDER_ASYNC     [label=\"0\"];",
			"RULEENGINE_AFTER_DECIDE->CACHE_MANAGER_WAIT_RECEIVE_START  [label=\"0\"];",
			"STORE_ATTACHMENT_END->STORE_ATTACHMENT_START   [label=\"0\"];",
			"AFW_NODECON_EXECUTE_END->STORE_SRV_ATTACH_END  [label=\"0\"];",
			"AFW_NODECON_EXECUTE_END->STORE_SRV_ATTACH_START      [label=\"0\"];",
			"CLASSIFIER_START->MESSAGE_ADAPTER_INPUT_MSG_END      [label=\"0\"];",
			"INITIATOR_ENGINE_START->RULEENGINE_AFTER_DECIDE      [label=\"0\"];",
			"}"

    };
	private void readRecords() {
	String filename = "digraph1";
		System.out.println(">>> read records ...");
		try {
			FileInputStream fstream = new FileInputStream(filename);
			DataInputStream in = new DataInputStream(fstream);
			BufferedReader br = new BufferedReader(new InputStreamReader(in));
			String strLine;
			while ((strLine = br.readLine()) != null) {
				String pattern = "(.*)\\-\\>(.*)\\[label\\=\\\"(.*)\\\"\\]\\;";
				Pattern p = Pattern.compile(pattern);
				Matcher m = p.matcher(strLine);
				if (m.matches()) {
					start = m.group(1);
					ziel = m.group(2);
					label = m.group(3);
					if (label.equals("0")) {
						System.out.println("Nullübergänge: " );
						myStart ="";
						myZiel ="";
						myStart =start;
						myZiel =ziel;
						System.out.println("myStart =:"+myStart);
						System.out.println("myZiel =:"+myZiel);
					strLine = strLine.replace(strLine, " ");
					} else {
						System.out.println("start =: "+start);
						System.out.println("Ziel =: "+ziel);
						System.out.println("label =:"+ label);
						result.append(strLine + "\n");
					}
					processRecords(strLine, start, ziel);
				}
			}
			in.close();
		} catch (Exception e) {
			System.err.println("Error: " + e.getMessage());
		}
	}

	private void processRecords(String myLine, String x, String y) {

		try {
			System.out.println("To Compare: " +start + " && "+myZiel + "\n");
			if (myZiel.equals(start))  {
			System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Foung match");
			myLine = myLine.replace(start, myStart);
			
			}
		} catch (Exception e) {
			System.err.println("Error at Processing : " + e.getMessage());
		}
		writeNewLine(result.toString());
	}

	private void writeNewLine(String line) {
		FileOutputStream fout;
		try {
			fout = new FileOutputStream(
					"C:\\Dokumente und Einstellungen\\mathenge\\Eigene Dateien\\MyOutPut\\MyPattern.txt");
			new PrintStream(fout).println(line);
			fout.close();
		} catch (IOException e) {
			System.err.println("Unable to write to file");
			System.exit(-1);
		}
	}

	public static void main(String[] args) {
		System.out.println("start program ...");
		MyPattern x = new MyPattern();
		x.readRecords();
		System.out.println("program finished ...");
		
	}
}

 

[SlaterB]

ohwe, hoffentlich hattest du nicht zuviel Arbeit, das alles ins Programm einzutragen,
hätte gedacht, dass klar wäre, dass 1-3 Zeilen reichen,
zum Glück hast du nicht 10.000 in deiner Datei

----------

habe dein Programmzum Testen weiter vereinfacht, so dass es nun ausführbar ist, und ohne unleserliche try/catch,
dann gibts aber gleich ne Exception,
myZiel wird erst gesetzt, wenn ein label=0 gefunden wird,
in processRecords() aber schon vorher verwendet in Zeilen mit label != 0,

da gehts also schonmal nicht voran,
schaue dir folgenden Code an und wenn du ein Problem offen hast,
dann versuche diesmal bitte, entsprechene Test-Zeilen zu erstellen

public class MyPattern
{
    StringBuffer result = new StringBuffer();
    String start; // Anfangknoten
    String ziel; // Endknoten
    String label; // Labels
    String myStart; // Anfangknoten von Nullübergänge
    String myZiel; // EndKnoeten von Nullübergänge

    static String[] data = new String[]
        {"X->Y [label=\"1\"];",

        "A->B [label=\"0\"];",

        "B->C [label=\"0\"];",

        "C->D [label=\"1\"];"

        };

    private void readRecords()
    {
        System.out.println(">>> read records ...");
        for (String strLine : data)
        {
            String pattern = "(.*)\\-\\>(.*)\\[label\\=\\\"(.*)\\\"\\]\\;";
            Pattern p = Pattern.compile(pattern);
            Matcher m = p.matcher(strLine);
            if (m.matches())
            {
                start = m.group(1);
                ziel = m.group(2);
                label = m.group(3);
                if (label.equals("0"))
                {
                    System.out.println("Nullübergänge: ");
                    myStart = "";
                    myZiel = "";
                    myStart = start;
                    myZiel = ziel;
                    System.out.println("myStart =:" + myStart);
                    System.out.println("myZiel =:" + myZiel);
                    strLine = strLine.replace(strLine, " ");
                }
                else
                {
                    System.out.println("start =: " + start);
                    System.out.println("Ziel =: " + ziel);
                    System.out.println("label =:" + label);
                    result.append(strLine + "\n");
                }
                processRecords(strLine, start, ziel);
            }
        }
    }

    private void processRecords(String myLine, String x, String y)
    {

        System.out.println("To Compare: " + start + " && " + myZiel + "\n");
        if (myZiel.equals(start))
        {
            System.out.println(">>>>>Foung match");
            myLine = myLine.replace(start, myStart);
        }
    }

    public static void main(String[] args)
    {
        System.out.println("start program ...");
        MyPattern x = new MyPattern();
        x.readRecords();
        System.out.println("program finished ...");
    }
}

---------

> String pattern = "(.*)\\-\\>(.*)\\[label\\=\\\"(.*)\\\"\\]\\;";
> Pattern p = Pattern.compile(pattern);

mal kurz auch Performanz: so ein Pattern kann einmal vor der Schleife erzeugt oder gleich statisch abgelegt werden,
bringt nix, das im Program zigmal auszuführen

 

[Gast]

könnte jemand mir ein Code liefern, wie ich die alle Objekte in mein Vector beschreiben kann..

ich habe folgendes:

Vector lRecords = new Vector();
lRecords.add (strLine);

mit lRecords.size() weiss ich, dass die Objekte drin sind.

(für alle Elemente bzw. Objekte in Vector lRecords) // hier happerts

{

if (start.equals(myZiel)){
				System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Found Match");
	}
}

 

[SlaterB]

was bedeutet es, 'Objekte in einem Vector zu beschreiben'?
was hat das mit Variablen wie start und myZiel zu tun?
und hat das noch irgendwas mit dem vorherigen zu tun?


ich frage extra naiv um dir aufzuzeigen, welch merkwürdige Frage du stellst,
außer mir wird wahrscheinlich eh kaum noch jemand antworten


edit: falls es nur um die Deklaration der Schleife geht:
for (String st : collection)
{
}

oder ohne Java 5 per for-i-Schleife:

for (int i=0; i<list.length; i++) {
String st = list.get(i);
}

 

[Gast]

Irgendwie komme ich nicht dahin wo ich möchte. Da ich mit meinem bisherigen Methoden nicht weiter gekommen bin, möchte ich was anders aussprobieren.

Und zwar aus meine Strings...
{"X->Y [label=\"1\"];",

"A->B [label=\"0\"];",

"B->C [label=\"0\"];",

"C->D [label=\"1\"];"

};

....Transistionen daraus bilden...
so etwa
"X->Y [label=\"1\"];"
"A->B[label=\"0\"]; ->C[label=\"0\"];->D[label=\"1\"];

Danach sollen die Übergänge mit Null weggelassen werden, dass es etwa so

"X->Y [label=\"1\"];"
"A->D[label=\"1\"];

bleibt.
Bin um jeden Vorschlag dankbar.

 

[SlaterB]

Tipp:

die Strings in Objekte umwandeln und dann Code schreiben wie

if (regel1.getZiel().equals(regel2.getStart()) && regel1.getLabel() == 0) {
  regel1.setZiel(regel2.getZiel());
  delete(regel2);
}

alles andere ist wirklich übel

 

[Gast]

ich komme leider nicht darauf, wie ich das mit den regel1 und regel2 machen soll.
Muss dich nerven und bitten...
Könntest du mir einen Code liefern, der funktioniert. Brauche das so um weiter zu kommen und bin seit Tagen beim Versuchen..

 

[SlaterB]

wenn das Problem zu schwer für dich, dann lohnt sich die Bearbeitung nicht, dann reibst du dich daran auf,
andere die Arbeit machen zu lassen ist natürlich auch keine Lösung,

arbeite dich Schritt für Schritt voran, die hast doch bisher eh schon die einzelnen Teile aus so einem
immer noch namenlosen String, ich nenne ihn nun mal 'Regel', extrahiert,

statt das ganze aber kompliziert in Laufvariablen zu speichern machst du nun ordentliche Objekte

class Regel {

Exemplarvaraiblen für begin, end, label, einfache getter + setter

}

alle Zeilen in einer einfachen Schleife umwandeln, jede zunächst nur für sich betrachten,
dann hast du eine Liste von Regel-Objekten,

danach dann die Liste durcharbeiten und benachbarte Objekte vergleichen