RegExpressions schlagen fehl.

[eNc]

Hallo... ich habe eine Datei naus der ich die Zeilen einzeln auslese und dann will ich verschiedene Informationen aus diesen Zeilen Lesen... das will ich sehr komfortabel über regexpressions machen.

so sehen z.B. die Zeilen aus, aus denen ich die informationen gewinnen will...:

E -> F [label="2,130"];
D -> F [label="5,130"];
F -> G [label="5,120"];
G -> H [label="5,100"];
A [label="A,5"];
B [label="B,4"];
C [label="C,3"];

wenn so ein Pfeil drinne ist... dann will ich (in der ersten Zeile) z.B. E, F, 2, 130 haben...
wenn ich z.B. bei Zeile 5 bin... will ich A, 5 erhalten...


Hier mein Code... es wird mir immer eine IllegalStateException ausgeworfen...

	public void readFile() {
		try {
			FileReader fReader = new FileReader(filename);
			BufferedReader bReader = new BufferedReader(fReader);
			String line;
			
			String regEdges = "^\\s*(\\w+)\\s*->\\s*(\\w+)\\s*\\[label=\"(\\d+),(\\d+)\"\\];\\s*$";
			Pattern patternEdges = Pattern.compile(regEdges);

			String regNodes = "^\\s*(\\w+)\\s*\\[label=\"(\\w+),(\\d+)\"\\];\\s*$";
			Pattern patternNodes = Pattern.compile(regNodes);
			Matcher matches;
			

			while ((line = bReader.readLine()) != null) {
				try {
					if (Pattern.matches(regEdges, line)) { // create a new edge
						matches = patternEdges.matcher(line);
						this.edges.add(new Edge(matches.group(1),
												matches.group(2),
												Integer.parseInt(matches.group(3)),
												Integer.parseInt(matches.group(4))));
					} else if (Pattern.matches(regNodes, line)) { // create a new node
						matches = patternNodes.matcher(line);
						if (matches.group(1).equals(matches.group(2)))
							this.nodes.add(new Node(matches.group(1), Integer.parseInt(matches.group(3))));
					}

				} catch (IndexOutOfBoundsException e) {
					e.printStackTrace();
				} catch (IllegalStateException e) {
					e.printStackTrace();
				}
				
			}

			bReader.close();
			fReader.close();
	
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (PatternSyntaxException e) {
			e.printStackTrace();
		}
	}

hier nochmal bei rafb der Code...:
http://rafb.net/paste/results/RdTAjj82.html

Danke für eure Hilfe...

 

[Illuvatar]

Poste mal die genaue Fehlermeldung (Stacktrace)

 

[eNc]

java.lang.IllegalStateException: No match found
	at java.util.regex.Matcher.group(Unknown Source)
	at RouteFileReader.readFile(RouteFileReader.java:41)
	at Navigation.<init>(Navigation.java:24)
	at NavigationLabTestCase.testDistance(NavigationLabTestCase.java:140)
	at NavigationLabTestCase.testFile1_A_C_Distance(NavigationLabTestCase.java:49)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at junit.framework.TestCase.runTest(TestCase.java:164)
	at junit.framework.TestCase.runBare(TestCase.java:130)
	at junit.framework.TestResult$1.protect(TestResult.java:110)
	at junit.framework.TestResult.runProtected(TestResult.java:128)
	at junit.framework.TestResult.run(TestResult.java:113)
	at junit.framework.TestCase.run(TestCase.java:120)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:478)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:344)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)

 

[André Uhres]

matches.find() fehlt nach matches = patternEdges.matcher(line); und nach matches = patternNodes.matcher(line); .
Hier ist eine Lösung mit nur einem Regex und ohne Gruppen (die Treffer werden einfach aufgelistet):

   public void readFile() {
        try {
            FileReader fReader = new FileReader(filename);
            BufferedReader bReader = new BufferedReader(fReader);
            String line;
            String regex = "(?<=\\A|[-> ]|[=\"])\\w+|\\d+";
            Pattern pattern = Pattern.compile(regex);
            Matcher matches;
            ArrayList<String> r = new ArrayList<String>();
            while ((line = bReader.readLine()) != null) {
                r.clear();
                try {
                    matches = pattern.matcher(line);
                    while (matches.find())  r.add(matches.group());
                    if (r.size() == 4) { // create a new edge
                        this.edges.add(new Edge(r.get(0), r.get(1), 
                                Integer.parseInt(r.get(2)), Integer.parseInt(r.get(3))));
                    } else if (r.size() == 3 && r.get(0).equals(r.get(1))) { // create a new node
                        this.nodes.add(new Node(r.get(0), Integer.parseInt(r.get(2))));
                    }
                } catch (IndexOutOfBoundsException e) {
                    e.printStackTrace();
                } catch (IllegalStateException e) {
                    e.printStackTrace();
                }
            }
            bReader.close();
            fReader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (PatternSyntaxException e) {
            e.printStackTrace();
        }
    }

 

[bygones]

also ich finde den regex

[^(label)\\W]+

schöner... matcht beides und holt die infos raus... wie dann der unterschied gemacht wird ist dir überlassen (vll. über ne Liste oder über nen Array oder so)

 

[André Uhres]

also ich finde den regex

[^(label)\\W]+

schöner... matcht beides und holt die infos raus... wie dann der unterschied gemacht wird ist dir überlassen (vll. über ne Liste oder über nen Array oder so)

Ist interessant. Kommt im Endeffekt auf meine Lösung raus.
Nur finde ich Negationen manchmal gefährlich.
Wenn man jetzt z.B. Label statt label schreibt, funzt es net mehr.

 

[bygones]

dann halt dem Pattern oder dem Matcher - weiß nimmer genau welchem - sagen er soll groß und kleinschreibung ignorieren...

 

[André Uhres]

dann halt dem Pattern oder dem Matcher - weiß nimmer genau welchem - sagen er soll groß und kleinschreibung ignorieren...

Wie du siehst, musst du bei jeder Änderung in der Schreibweise von Dingen die
eigentlich nichts direkt mit den eigentlichen Werten zu tun haben, deinen Code wieder anpassen.
Daher ist es besser wenn man (so weit es geht) positive Bedingungen den negativen vorzieht.