String mittels RegEx filtern

[Alex04]

Hallo,
ich würde gerne einen String filtern wie nachfolgend beschrieben:

InputString:

...
{
.*.
}
...
{
.*.
}

Die Punkte stehen dabei für beliebige Zeichen. Die Sterne habe ich rein gemacht, weil verdeutlichen will, dass auch '{' und '{' Bestandteil dieses Parts sein können.

Beispiel:

Dies ist ein Test {
der Testfall {
wird }
}
xy

Ich möchte eine RegEx basteln mit der ich

der Testfall {
wird }

bekomme.

Ist das möglich? Wenn ja wie?

Viele Grüße und danke schon mal!!

 

[Matthias K.]

Hi Alex,
geht ganz einfach:

String s = "Halloooouuuuuiiii!!";
		s = s.replace("u", "");

-> Nun werden alle "u" durch "" ersetzt. Sie fallen also weg.
Dies machst du dann einfach mehrmals und der String ist sauber.

Gruß,
Matthias

 

[nrg]

also du willst dann nur einen einzigen token und zwar den, der in die äußersten 2 geschweiften klammern steht?

wenn ja

\\{.*\\}

und dann eben ggf. die zwei Klammern aussenrum noch wegnehmen.

wenn nein, erklär nochmal 😀

 

[Alex04]

Hallo, ja das kenn ich, es ist aber etwas komplizierter 😉
Ich will ein Java File auslesen in dem nur Methoden stehen.
Den Inhalt dieser Methoden will ich extrahieren.
Auf dein Beispiel bezogen reicht es mir nicht einfach u im String zu ersetzen.
Ich will alles was zwischen '{' und '}' steht haben, wobei innerhalb davon auch '{' und '}' stehen kann.

{hallo}

Ergebnis soll sein: 'hallo'

{testt{cxc}

Ergebnis soll sein: 'testt{cxc'

{testt{cxc}}vdfvdfvdfb{{{}}}

Ergebnisse sollen sein: 'testt{cxc}' und '{{}}'

{testtcxc}}

Ergebnisse sollen sein: 'testtcxc'

 

[nrg]

nachdem alle kontrollstrukturen in java so aufgebaut sind und die methoden natürlich bzgl. modifier, static, return, name und parameter ziemlich viele formen annehmen können, würde ich das gar nicht mit regex lösen sondern selbst eine split-methode bzw. einen parser schreiben.

 

[Matthias K.]

Hi Alex,
Das hier funktioniert:

String anfang = "{{{{Hello, World}bc{{{s}}}ucuscb";
		String bearbeitet = "";
		int merker1 = 0;
		
		char[] c = anfang.toCharArray();
		 
		for(int i = 0; i < c.length; i++) 
		{
			if(merker1 == 1 && c[i] == '}')
			{
				merker1 = 0;
			}
			if(merker1 == 1)
			{
			        bearbeitet = bearbeitet + c[i];
			}
			if(merker1 != 1 && c[i] == '{')
			{
				merker1 = 1;
			}						
		}
		      System.out.print(bearbeitet);

Gruß,
Matthias

 

[nrg]

für true/false nimmt man besser einen boolean und zum verketten von Strings einen StringBuilder 🙂

ansonsten geht das schon in die richtung, wobei man schon bissle mehr zu beachten hat.

 

[Matthias K.]

Hi,
von true/false habe ich mich schon lange verabschiedet,
weil nur zwei Werte mir mal große Probleme gemacht haben.
Ich denke: zu viel ist immer besser, als zu wenig.
Und ich weiss nicht, ob die andere String-Methode Vorteile hat.
Welche hat sie denn?
Würde mich interessieren.
Und welche anderen Sachen hat man noch zu beachten?

 

[nrg]

dann solltest du zu booleans ganz schnell wieder Hallo sagen 🙂. das mit einem int zu machen ist erstens speicherverbrauch (auch wenns nur 31 bits sind) und zweitens sehr schlechter stil.

Strings sind in java immutable. d.h. es wird nach jeder Verkettung ein neues String-Objekt erzeugt, was deinen Heap spamen könnte. StringBuilder verwaltet den String intern als array und ist somit deutlich performanter und schonender für den Heap. Das wird zwar vom Compiler optimiert aber soweit ich weiß auch nicht in allen Fällen also halte ich das für wichtig, das explizit zu tun.

 

[Alex04]

Also ich hätte da schon ne Lösung, dachte allerdings es geht einfacher :

//Method RegEx
private static final String JAVA_METHOD_HEAD_EXPRESSION = "( public |protected |private | static |)+[\\s]*((\\w)*(\\s)*(\\<(\\s)*[\\w\\?]+\\>)?)[\\s]+[\\w]+\\([^\\(\\}\\/\\)]*\\)[\\w\\s]*\\{";

//...
if(lWithinMethod && lCurrentLine.contains("{") && (!lCurrentLine.trim().startsWith("//") || !lCurrentLine.trim().startsWith("*"))) {
				lOpenBracketLevel+= lCurrentLine.replaceAll("[^{]", "").length();
			}
			if(lWithinMethod && lCurrentLine.contains("}") && (!lCurrentLine.trim().startsWith("//") || !lCurrentLine.trim().startsWith("*"))) {
				lOpenBracketLevel -= lCurrentLine.replaceAll("[^}]", "").length();
				if(lOpenBracketLevel == 0) {
					lWithinMethod = false;
//..

Das wars und funktioniert auch.
Ich suche mit

Pattern lPattern = Pattern.compile(JAVA_METHOD_HEAD_EXPRESSION);
		Matcher lMatcher = lPattern.matcher(lContent);
		while(lMatcher.find()) {
			int lStartOffset = lMatcher.start();
			int lOffsetEnd = lMatcher.end();
//...
}
das Ende des Methodenheaders. lMatcher.end() steht also genau beim '{'.
Dann kann ich mit ner forschleife und dem Brackets-Level bis zum Ende der Methode gehen.

Ich denke für alle anderen Tags funktioniert es analog, dachte nur es gibt vielleicht einen einfachereren Weg

Lg
Alex

 

[nrg]

naja eine methode kann auch gar kein modifier haben.

doSomething(whatever) {

}

also unterscheidet sich das schonmal syntaktisch nicht von einer while oder einem if. denk nicht, dass das mit regex so einfach/sauber machbar ist, ausser du berücksichtigst darin auch alle keywords von java, die einen body mitsichziehen, um diese dann eben auszuschließen.

zudem kommen Strings, die vllt auch einfach eine Methode drinstehen haben können (ich mein gut, das macht keine sau aber es ist theoretisch möglich 😀).

Dann hast du bei deiner Lösung Konstruktoren mit einbeschlossen. wenn du die mitzählen willst, ist ja alles klar. wenn nicht, kommst du da mit regex auch wieder schwer hin.

ausserdem könntest du dir mit einem parser auch metadaten wie classname und methodennames sammeln. du könntest auch einfach den kompletten code in einer klasse abbilden, wodurch du später auf erweiterungen sehr leicht reagieren kannst (weiß ja nicht was du noch so vor hast 🙂.

also ich empfehle nach wie vor einen parser.

edit: also ich hab jetzt deine lösung nicht getestet und auch nur kurz angeschaut. das sind alles eher Intuitivaussagen

 

[Alex04]

doSomething(whatever) {

}

geht nicht, kein return type!

Mene Expression gilt für alle syntaktisch korrekten Java-Methoden, zumindest konnte ich bisher keine Fehler sehen.
Mir gehts hier allerdings nicht wirklich um die Java Methode, sondern darum wie man alles was zwischen 2 Tags liegt rausfiltern kann, per Pattern und Matcher zB.

Nehmen wir an ich habe zwei Kennzeichen für den Start und das Ende:
//@Start
..
//@End

Keines der Tags darf ziwschen diesen beiden Tags vorkommen. Allerdings hat das Dokument mehrere solcher Stellen.
Ich will zu allen diesen Stellen jeweils den Inhalt zwischen den Tags haben.

 

[nrg]

ja hast natürlich recht aber der returntype ist völlig variabel. den kannst du demnach nie in deine regex einfließen lassen. deshalb unterscheidet es sich trotzdem nicht wirklich von einer if oder for, weil vor der if oder for theoretisch auch noch was stehen könnte (gibts zwar nicht viel möglichkeiten aber trotzdem). sowas müsstest du alles mit einbeziehen. du kannst dich nicht drauf verlassen, dass sich jeder an die konventions hält. aber es ist nur ein gut gemeinter rat. wenn du es unbedingt mit regex machen willst, tu dir keinen zwang an.

ansonsten sag doch am besten mal, was du genau machen willst. willst du irgendwas zählen (McCabe-Metrik)? willst du irgendwas auslesen?

 

[Alex04]

Danke erstmal für die Hilfe 😉

Also was ich machen will ist aus einer Java Datei, die generierten Code enthält, Usercode rauszufiltern.

Der Usercode soll vorerst nur innerhalb von Methoden vorkommen. Von mir aus muss dieser auch durch ein bestimmtes start/end-tag gekennzeichnet werden.

Am liebsten würde ich dann eben mittels einer Regex und Pattern + Matcher diese Blöcke aus dem Dokument filtern, damit ich den Usercode getrennt ablegen kann...