RegEx und Methoden

[Lukas16]

Hallo,

also ich habe einige solcher Methoden:

public void CheckMaxMPGruppe(){
		Pattern i = Pattern.compile("G[1-9]: .+ [a-zA-z] \\([0-9]\\/[1-9]\\)\n");
        Matcher j = i.matcher(input);
        boolean found = false;
        while(j.find()){
        	//System.out.println("CheckMaxMPGruppe: OK");
        	found = true;
        }
        if(!found){
        	error.append(error9);
        	error.append("\n");
        	counter++;
        }
	}

... sie funktionieren auch perfekt, nur da wird z.b nach (G1: ölasdf m (1/2)) gesucht und true zurückgegeben, aber was ist wenn ich jetzt noch ein (z.b.: G3: asdas m (1/4)) habe..... ich möchte dass das auch überprüft wird

kann mir bitte jemand helfen, bin am verzweifeln :?

Gruß
Lukas

 

[SlaterB]

was spricht gegen meinen Vorschlag im letzten Thread?
http://www.java-forum.org/de/viewtopic.php?t=53550

du hast inzwischen ja 'while' eingebaut, aber die Schleife ist ganz leer,
nach jedem find() musst du doch group() oder so aufrufen um das Ergebnis auch abzufragen?

 

[Lukas16]

ich brauche das ergebnis gar nicht abzufragen. Ich muss einen StringBuffer nach bestimmten Gruppen durchsuchen (bsp. für eine gruppe: G1: blablalb n (0/1)), wenn da drinnen ein Fehler ist soll es nur eine Meldung zurückgeben das etwas falsch ist.

 

[SlaterB]

was genau ist jetzt die Frage?
G3 wird nicht erkannt? du hast das Format etwas schwammig beschrieben, warum gehts nicht?

 

[Lukas16]

Textdokument:

G1: produktgruppe m (1/0)
P3: produkt x (1/1) [2,50€; P; 1; T]
G4: produktgruppe m (1/5)
A6: attribut m (1/5)

jetzt übeprüfe ich mit RegEx ob z.b. jede produktgruppe der Syntax entspricht (bei G1 und G4)

public void CheckSyntaxMPGruppe(){
		Pattern i = Pattern.compile("G[1-9]: .+ [a-zA-z] \\([0-9]\\/[0-9]\\)");
        Matcher j = i.matcher(input);
        boolean found = false;
        while(j.find()){
        	System.out.println("CheckSyntaxMPGruppe: " + group()); //dann schreibt es nur hin G1: produktgruppe m (1/0)
        	found = true;                                                               
        }
        if(!found) {
        	error.append(error5);
        	error.append("\n");
        	counter++;
        }
	}

ich versteh es nicht, es läuft ja in einer schleife.....wenn es ein 2. objekt findet dann muss es ja normal wieder rein gehen

 

[Lukas16]

ah es geht doch, aber es gibt immer nur eine Fehlermeldung aus....wie kann ich das machen das jedes mal ein fehler ausgegeben wird?

 

[SlaterB]

wie gesagt: du hast ne while-Schleife, die für 2x find() genau 2x durchlaufen wird,

wo könntest du wohl die Ausgabe hinschreiben, damit sie 2x erscheint?..

edit: obwohl, der Fehler erscheint bisher ja nur wenn nichts gefunden wird,
nun soll pro Treffer ein Fehler kommen? du machst aber auch Sachen..

 

[Lukas16]

ok, hab mich nicht verständlich ausgedrückt

wenn ich G1: produktgruppe x (1/0), G2: produktgruppe x (1/0) habe (beide wurden schon gefunden durch das G1: vorne) In einer anderen Methode wir überprüft ob vor der klammer ein m steht, das ist bei beiden nicht der fall, daher sollen 2 fehler ausgegeben werden.

gibt es da keine möglichkeit??

 

[SlaterB]

> In einer anderen Methode wir überprüft ob vor der klammer ein m steht, das ist bei beiden nicht der fall, daher sollen 2 fehler ausgegeben werden.
> gibt es da keine möglichkeit??


mit group() nach dem find() kannst du "G1: produktgruppe m (1/0)" oder ähnlich extrahieren
und darin nach dem m suchen oder beliebig anderes machen, wie du möchtest, klar gibts da ne Möglichkeit

was ist da jetzt die Frage?

 

[Lukas16]

hmmm

public void CheckSyntaxMPGruppe(){
		Pattern i = Pattern.compile("G[1-9]: .+ [a-zA-z] \\([0-9]\\/[0-9]\\)");
        Matcher j = i.matcher(input);
        boolean found = false;
        while(j.find()){
        	//System.out.println("CheckSyntaxMPGruppe: " + j.group());
        	found = true;
        	CheckMPGruppeMust();
        }
        if(!found) {
        	error.append(error5);
        	error.append("\n");
        	counter++;
        }
	}


public void CheckMPGruppeMust(){
		Pattern i = Pattern.compile("G[1-9]: .+ m \\([0-9]\\/[0-9]\\)\n");
        Matcher j = i.matcher(input);
        boolean found = false;
        while(j.find()){
        	found = true;
        }
        if(!found) {
        	error.append(error7);
        	error.append("\n");
        	counter++;
        }
	}

ok, ein teil von meinem beispiel:
in der 1. methode werden 2 "Gruppen" gefunden, daher wird die untere Methode aufgerufen. Wenn dort beide Gruppen nicht korrekt sind gibt es einen Fehler aus oda macht einen blödsinn (es soll genau 2 fehlermeldungen ausgeben!)

ich hoffe du verstehst es jetzt besser


PS: danke für deine hilfe

 

[SlaterB]

> Wenn dort beide Gruppen nicht korrekt sind gibt es einen Fehler aus oda macht einen blödsinn (es soll genau 2 fehlermeldungen ausgeben!)

können wir nicht mal anfangen, konkret zu werden?
was soll ich denn mit 'macht einen Blödsinn' anfangen?

--------

dein Programmaufbau ist doch Quatsch, für jedes Vorkommen Gx
rufst du CheckMPGruppeMust() auf, welches wieder den gesamten String durchsucht?

übergib nur die aktuelle Gruppe an die zweite Operation,
die dann nur für diese Gruppe prüft, ob m drin ist oder nicht,
und dafür Fehler ausgibt oder nicht (ohne while!)

 

[Lukas16]

die akutelle gruppe hole ich mir mit j.group().....d.h. Matcher matcher= i.matcher(j.group());

habe ein kleines test prog geschrieben, vielleicht kannst du mir dann so meinen Fehler besser erklären

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test { 

    public static void main(String[] args){ 
    	String input = "G13: produktgruppe m (1/0)\nG3: produktgruppe x (1/0)";
    	Pattern i = Pattern.compile("G[1-9]: .+ [a-zA-z] \\([0-9]\\/[0-9]\\)"); 
    	Matcher j = i.matcher(input); 
    	boolean found = false; 
    	while(j.find()){ 
    		System.out.println("CheckSyntaxMPGruppe: " + j.group()); 
    		found = true;                                                                
    	} 
    	if(!found) { 
    	    System.out.print("error");
    	} 
    }
    
    public static void CheckMaxMPGruppe(){
    	Pattern i = Pattern.compile("G[1-9]: .+ m \\([0-9]\\/[0-9]\\)"); 
    	Matcher matcher = i.matcher([b]j.group()[/b]); 
    	if(matcher.find()){ 
    		System.out.print("OK");                                                              
    	} 
    	else { 
    	    System.out.print("error: m fehlt");
    	} 
    }
}

 

[Lukas16]

Methodenaufruf in der while schleife habe ich vergessen zu kopieren

 

[SlaterB]

übergib nicht j, sondern j.group(), also nur einen String,
und x-ten Mal: was ist nun die Frage???
funktioniert doch, wenn du noch "G13" im String in "G1" korrigierst

 

[Lukas16]

Meine Frage (die letzte!):

eigentlich müsste ja alles funtz

>>übergib nicht j, sondern j.group(), also nur einen String, << ...versteh ich nicht, j.group() habe ich ja in der 2. Methode, aber es erkennt j nicht. Was muss ich jetzt machen?

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test { 

    public static void main(String[] args){ 
    	String input = "G1: produktgruppe m (1/0)\nG3: produktgruppe x (1/0)";
    	Pattern i = Pattern.compile("G[1-9]: .+ [a-zA-z] \\([0-9]\\/[0-9]\\)"); 
    	Matcher j = i.matcher(input); 
    	boolean found = false; 
    	while(j.find()){ 
    		System.out.println("CheckSyntaxMPGruppe: " + j.group()); //dann schreibt es nur hin G1: produktgruppe m (1/0) 
    		found = true;           
    		CheckMaxMPGruppe();
    	} 
    	if(!found) { 
    	    System.out.print("error");
    	} 
    }
    
    public static void CheckMaxMPGruppe(){
    	Pattern i = Pattern.compile("G[1-9]: .+ m \\([0-9]\\/[0-9]\\)"); 
    	Matcher matcher = i.matcher(j.group()); 
    	if(matcher.find()){ 
    		System.out.print("OK");                                                              
    	} 
    	else { 
    	    System.out.print("error");
    	} 
    }
}

DANKE
Lukas

 

[SlaterB]

noch mit statischen Variablen für die immer gleichen Pattern:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test
{
    static Pattern G_ANY = Pattern.compile("G[1-9]: .+ [a-zA-z] \\([0-9]\\/[0-9]\\)");
    static Pattern G_M = Pattern.compile("G[1-9]: .+ m \\([0-9]\\/[0-9]\\)");

    public static void main(String[] args)
    {
        String input = "G1: produktgruppe m (1/0)\nG3: produktgruppe x (1/0)";

        Matcher matcher = G_ANY.matcher(input);
        boolean found = false;
        while (matcher.find())
        {
            System.out.println("CheckSyntaxMPGruppe: " + matcher.group());
            found = true;
            CheckMaxMPGruppe(matcher.group());
        }
        if (!found)
        {
            System.out.print("error");
        }
    }

    public static void CheckMaxMPGruppe(String suchString)
    {
        Matcher matcher = G_M.matcher(suchString);
        if (matcher.find())
        {
            System.out.println("OK");
        }
        else
        {
            System.out.println("error");
        }
    }
}

 

[Lukas16]

DANKE DANKE DANKE

funktioniert perfekt!

:applaus: