RegEx Pattern Matcher

[membersound]

Hallo,

ich zerlege eine File mit nem RegEx Pattern.
Die File ist zB so aufgebaut:

one##
two##
one##two##three##
...

            Pattern pat = Pattern.compile("[^##]+");
            Matcher mat = pat.matcher(strLine);

Allerdings wird dadurch kein leeres Element erkannt:
one####three##
Dort würde mir das zweite Element fehlen, und statt dessen das dritten Element an die zweite Stelle rücken.
Wie kann ich das detektieren?

Danke

 

[Peter W. Marth]

Hallo,

der Matcher dient ja nur der Mustererkennung, das Zerlegen von Strings funktioniert mit split() auch mit "leeren Feldern":

        String s = "one####three##";
        String[] a = s.split( "##" );
        for( String t : a ) {
            System.out.println( "t=" + t );
        }

 

[eRaaaa]

Ganz genau habe ich jetzt das Problem nicht verstanden, aber mit Matcher+Pattern ginge das auch irgendwie bestimmt. Ist es so vlt. gemeint:

		String s = "one####three##";
		Pattern pat = Pattern.compile(".*?##");
		Matcher mat = pat.matcher(s);
		while(mat.find()){
			System.out.println(mat.group());
		}

???:L

 

[truesoul]

So sollte es gehen. Da spielt auch die Anzahl der # keine Rolle:

String text = "zwei##hallo";
String array [] = text .split("[^\\w+]");
        for(String g: array){
            if(!g.isEmpty())
                System.out.println(g);
        }

Gruß

 

[membersound]

Sorry, hatte irgendwie vergessen die Zerlegung zu posten:

            while (mat.find()) {
                newString[i] = mat.group(0);
                i++;
            }

Die Anzahl der ## SOLL aber eine Rolle spielen. Also es müssen genau 2 sein, und wenn danach noch 2 weitere kommen muss ein leerer String erzeugt werden.

 

[Peter W. Marth]

Dann ist der Ansatz von eRaaaa genau der richtige.

 

[truesoul]

Dann hast du ja schon die fast komplette Lösung erhalten (Siehe eRaaaa)

 

[membersound]

Nicht wirklich?

Ich kriegs nicht hin.
Mein Teststring ist grade:

one##
##two##three
one####three

 

[Peter W. Marth]

Wenn man vor dem Erzeugen des Matchers die ggf. fehlenden ## am Ende anfügt, dann geht das.

        if( !s.endsWith( "##" ) ) {
            s += "##";
        }
        mat = pattern.matcher( s );
...

 

[membersound]

Ich check immer noch nicht was ich denn jetzt ändern muss, damit ich das bekomme was ich möchte.

Ich möchte:

one
two

three

"[^##]+" ergibt:

one
two
three

".*?##" ergibt:

one##
two##
##
three##

public class testclass {
    public static void main(String args[]) {
        int i = 0;
        String[] newString = new String[10];
        String strLine = "one##two####three##";
            Pattern pat = Pattern.compile("[^##]+");
            Matcher mat = pat.matcher(strLine);
            while (mat.find()) {

                newString[i] = mat.group(0);
                System.out.println(newString[i]);
                i++;
            }
    }
}

 

[eRaaaa]

Dann mache halt eine Gruppe

		int i = 0;
		String[] newString = new String[10];
		String strLine = "one##two####three##";
		Matcher mat = Pattern.compile("(.*?)##").matcher(strLine);
		while (mat.find()) {
			newString[i] = mat.group(1);
			System.out.println(newString[i++]);
		}

 

[membersound]

Astrein man! vielen Dank!

 

[membersound]

Jetzt müsste ich nur noch Steuerzeichen mit erkennen können. Aus der Dokumentation lese ich heraus, dass das mit "\s" geht.

Aber wie bastel ich das denn jetzt da rein? Ich hab schon alles durchprobiert und krieg es einfach nicht hin :noe:

(Ein String zwischen zwei ## kommt zB aus einem Textfeld, in dem auch Zeilenumbrüche vorkommen. Ich lese eine komplette Zeile dann mit readLine() ein, aber dort wie eben der Zeilenumbruch steht wirds chaotisch. Er wird bisher ja nicht erkannt.
"((.|\\s)*?)##" schien mir bisher am logischsten, funktioniert aber auch nicht...)


/edit: ok das Hauptproblem ist eher: wie bringe ich readLine() dazu, bis zum Zeilenende zu lesen, also Steuerzeichen zwischendurch trotzdem mitzunehmen?

 

[eRaaaa]

Anhand eines Beispiels (mit Erklärung: was willst du als Ergebnis, was bekommst du etc.) ist so etwas denke ich immer besser erklärt und andere können viel besser helfen.

/edit: ok das Hauptproblem ist eher: wie bringe ich readLine() dazu, bis zum Zeilenende zu lesen, also Steuerzeichen zwischendurch trotzdem mitzunehmen?

Von welchen Steuerzeichen reden wir hier?
readLine:

Reads a line of text. A line is considered to be terminated by any one of a line feed ('\n'), a carriage return ('\r'), or a carriage return followed immediately by a linefeed.

Da kannst du nichts dran ändern. Wenn du also Zeilenumbrüche etc. "überlesen" möchtest bzw möchtest dass diese dann mit zu deinem String gehören und du eher bis zu den nächsten ## lesen willst (habe ich dich da überhaupt richtig verstanden?), würde ich dir den Scanner empfehlen mit DOTALL noch als Zusatz im Pattern, so dass wir dann also das Pattern "(?s)(.*?)##" haben.
Beispiel:

		String strLine = "one##two####three##\nhallo welt\nfoobar\ntwo##two##";
		Scanner sc = new Scanner(strLine); //hier dann natürlich nicht den Teststring nehmen, sondern dein File
		while(sc.findWithinHorizon("(?s)(.*?)##", 0) != null){
			String s = sc.match().group(1);
			System.out.println(Arrays.toString(s.toCharArray())); //nur für Testzwecke ums besser zu verdeutlichen
		}

\nhallo welt\nfoobar\ntwo##

sollte also als ein String erkannt werden ja?

 

[membersound]

Ja, du hast mich genau richtig verstanden, und es funktioniert auch schon echt gut, danke!

Einziges Problem ist noch, dass Steuerzeichen von der oberen Line in den neuen String mit reingeschleppt werden, zu sehen unten bei "String1":

public class testclass {
    public static void main(String args[]) throws UnsupportedEncodingException, FileNotFoundException {
        LineNumberReader strLine = new LineNumberReader(new InputStreamReader(new FileInputStream("testfile.txt"), "ISO-8859-1"));
        /*file contains:
         * my teststring##
         * one##two####three##\nhallo welt\nfoobar\ntwo##two##
         */
        Scanner sc = new Scanner(strLine);
        
        int i = 0;
        String[] s = new String[10];
        
        while (sc.findWithinHorizon("(?s)(.*?)##", 0) != null) {
            s[i] = sc.match().group(1);
            System.out.println("String" + i + ": " + s[i]);
            i++;
        }
    }
}

Output:

String0: my teststring
String1: 
one
String2: two
String3: 
String4: three
String5: \nhallo welt\nfoobar\ntwo
String6: two

 

[eRaaaa]

Mhm? Verstehe ich nicht, das ist doch das was du wolltest (Steuerzeichen mit in den String). Ist doch klar dass dann wenn du ein line terminator vor dem one hast und dann println machst, dass die dann in zwei Reihen dargestellt werden.
Wenn das nicht gewünscht ist und du hinterher halt die line terminators doch löschen willst, musst du eben nochmal replace aufrufen oder so.(s.trim() evtl...) ..:bahnhof:???:L

 

[membersound]

Ja stimmt, mit trim() würde das gehen.

Das Problem ist halt, dass am Schluss jede Line ein bestimmtes Objekt repräsentieren wird. Und dafür müsste ich halt EndOfLine irgendwie erkennen. Deshalb hatte ich readLine() ursprünglich genutzt.

Also ich müsste halt noch irgendwie erkennen, dass nach "my teststring" eine newLine() beginnt...