# Spezieller Regex gesucht



## Vatar (8. Juni 2005)

Moinsen.
Ich muss aus einem String, genauer gesagt aus einem tag den Wert eines bestimmten Attributes auslesen.
z.B.:
	
	
	



```
vcc:rowLabelCellProperty column="0" row="0" colSpan="2" align="left" value="Lieferantenname"
```
Daraus benötige ich z.b nur den Wert von value. 
Ich arbeite mit JRegex (da ich ein perlscript auf java umstellen muss).
Geht es irgendwie, dass ich aus dem String nur das heraushole was zwischen value=" und dem folgenden" steht.

Ich brauche wirklich dringend Hilfe (seh nur noch irgendwelche Regex rumfliegen mit denen ich nix anzufangen weiß    )


----------



## HermeZ (8. Juni 2005)

Hallo,
ich habe gerade keine zeit dir den Ausdruck zu erstellen, aber schau mal hier nach 
http://weitz.de/files/regex-coach.exe
das Programm ist cool, damit kannst du genau sehen welche teile des strings du mit dem Ausdruck erfasst hast;
gruss

*edit
ps etwa so müsste der Ausdruck aussehen:
[value][=]["][\w]*["]
dann musst du ihn nur noch zurechtschneiden...


----------



## Thomas Darimont (8. Juni 2005)

Hallo!

Vielleicht so?

```
/**
 * 
 */
package de.tutorials;

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

/**
 * @author Tom
 * 
 */
public class Foo {
	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String str = "vcc:rowLabelCellProperty column=\"0\" row=\"0\" colSpan=\"2\" align=\"left\" value=\"Lieferantenname\"";

		String regex = ".*value=\"(.*)\".*";
		Matcher matcher = Pattern.compile(regex).matcher(str);
		if (matcher.find()) {
			System.out.println(matcher.group(1));
		}

	}
}
```

Gruß tom


----------



## Vatar (9. Juni 2005)

Spitzenmäßig.

Der Regex Coach is auch gut (werd ihn wohl noch oft konsolidieren müssen   ) 

thx

edit:
hab zufällig noch ein Tool gefunden, welches die Java Regex nutzt und nach einem ersten Test noch etwas besser ist wie der Regex Coach.
guckst du hier


----------



## Vatar (11. Juli 2005)

jetzt hab ich doch noch ein Problem mit dem Regex vom Tom. Es könnte ja sein, dass value nicht am Ende steht sondern mittendrin. In diesem Falle gibt er mir für group(1) alles ab value=" bis zum letzten " aus. Er soll aber nur bis zum nächsten " gehen.

Habs mal so probiert (funktioniert aber nicht):
	
	
	



```
String regex = "  .*value=\"([a-zA-Z[^\"]])\"  "
```
thx


----------



## elmato (11. Juli 2005)

Versuch mal das hier..

```
(.*value=\")(\\w+)
```
du musst dann nur auf grou(2) matchen


----------



## Vatar (11. Juli 2005)

Danke für die fixe Antwort.
Funktioniert aber noch nicht ganz.
	
	
	



```
value="Buyer name"
```
Mit diesem Regex gibt er nur "Buyer" aus.


----------



## elmato (11. Juli 2005)

```
(.*value=\")(\\w.*)
```
nu aber ^^

//edit nein doch noch nicht moment bitte..


----------



## Vatar (11. Juli 2005)

Leider nein. Den hatte ich auch schon ausprobiert
Jetzt bekomm ich genau das selbe Ergebnis wie am Anfang: Buyer name" sorted="true"


```
Teststring: <vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"Buyer name\" sorted=\"true\" />
```


----------



## elmato (11. Juli 2005)

also hiermit ging es bei mir jetzt

```
.*value="(\b.*?)".*
```

edit:
\b kann auch durch \w ersetzt werden..
mfg

edit edit 

```
.*value=\"(\\w.*?)\".*
```
so muss das netuerlich sein..


----------



## Vatar (11. Juli 2005)

Super Danke.
Regex sind wirklich ne feine Sache, aber bis man da erstmal durchsteigt.


----------



## Thomas Darimont (11. Juli 2005)

Hallo!


```
/**
    * 
    */
   package de.tutorials;
   
   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
   
   /**
    * @author Tom
    * 
    */
   public class Foo {
   	/**
   	 * @param args
   	 */
   	public static void main(String[] args) {
   
 		String str = "<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"Buyer name\" sorted=\"true\" />";
   
   		String regex = "value=\"([^\"]*)";
   		Matcher matcher = Pattern.compile(regex).matcher(str);
   		if (matcher.find()) {
   			System.out.println(matcher.group(1));
   		}
   
   	}
   }
```
 
   gruß Tom


----------



## Vatar (13. Juli 2005)

Nochmal Danke für die Hilfe, aber ich hab schon wieder ein Problem     

Es kann ja nun sein, dass dieser Tag mehrfach auftaucht. Kann ich irgendwie durch den Matcher iterieren, oder muss ich umständlich den endindex des ersten Ergebnisses nehmen und die Suche ab dieser Stelle erneut durchführen?

thx


----------



## Vatar (13. Juli 2005)

Ok. Den nächsten Match sucht die find()-Methode 
Das funktioniert auch ganz gut mit einfachen Sachen:
	
	
	



```
String test = "Stück für Stück wird ein test getestet";
        String regex = "Stück";

        Matcher matcher = Pattern.compile(regex).matcher(test);
        if(matcher.find()){
            System.out.println(matcher.group());
            if(matcher.find(matcher.end())){
                System.out.println(matcher.group(1));
            }

        }
Ausgabe:
Stück
Stück
```
Aber mit dem Tag und group(1) funktioniert das nicht. Ich hab einfach den Tag noch zweimal angefügt und den value geändert -> er gibt mir aber immer den value des letzten Tags aus, obwohl er mir doch eigentlich die ersten beiden geben müsste (nach meiner Logik)


----------



## Vatar (13. Juli 2005)

```
public static void main( String[] args ) {
        String test = "<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"Buyer name\" sorted=\"true\" />" +
                "blabla<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"test string\" sorted=\"true\" />" + 
                "huibla<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"nochmal\" sorted=\"true\" />";
        String regex = " .*value=\"(\\w.*?)\" ";

        Matcher matcher = Pattern.compile(regex).matcher(test);
        while(matcher.find()){
            System.out.println(matcher.group(1) + "\t" + matcher.start());
        }
    }
```
Sehr seltsam: Wenn ich das ausführe gibt er mir aus: nochmal   24. Anscheinend beginnt er am Ende des Strings (denn sonst müsste der startindex des matches ja wesentlich höher sein).

Wenn ich diesen String + regex mit dem oben verlinkten RegexTester durchführe funktioniert es so wie es soll. Bei "next match" gibt er mir nacheinander (in der richtigen Reighenfolge) die values aus.


----------



## elmato (13. Juli 2005)

Das Problem hier(frag mich aber bitte nicht wieso  ) ist das der ganze Text hintereinander steht...

```
String test = "<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"Buyer name\" sorted=\"true\" />\n" +
                "blabla<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"test string\" sorted=\"true\" />\n" + 
                "huibla<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"nochmal\" sorted=\"true\" />\n";
```
fuegst du wie hier gezeigt ein \n am ende jedes Strings ein dann klappt es..


----------



## Thomas Darimont (13. Juli 2005)

Hallo!

  wie wärs denn damit:

```
package de.tutorials;
  
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  public class RegexExample {
  
  	 public static void main( String[] args ) {
 			String test = "<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"Buyer name\" sorted=\"true\" />" +
 			 "blabla<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"test string\" sorted=\"true\" />" + 
 			 "huibla<vcc:headingCellProperty column=\"3\" row=\"0\" width=\"125\" value=\"nochmal\" sorted=\"true\" />";
  			String regex = "value=\"([^\"]*)";
  
  			Matcher matcher = Pattern.compile(regex).matcher(test);
  			while(matcher.find()){
 				System.out.println(matcher.group(1));
  			}
  		}
  }
```
 
 Ausgabe:
 Buyer name
 test string
 nochmal

  Gruß Tom


----------



## Vatar (13. Juli 2005)

Danke Danke Danke jetzt kann ich endlich weitermachen.
Ich versteh aber trotzdem ncht ganz warum der vorherige regex bei dem tool funktioniert hat.


----------



## elmato (13. Juli 2005)

Ich hatte es auch in einem RegEx Tester versucht und es klappte, bis mir dann auffiehl das die Zeilen untereinander standen und nicht hintereinander..evt war das bei dir ja auch so...
Aber Thomas hat ja eine Loesung fuer alles


----------



## Vatar (15. Juli 2005)

Und weiter gehts.
Neben den speziellen Tags brauch ich teilweise auch noch den Inhalt von normalen HTML-Tags. Diese Tags werden in einer txt angegeben

```
<td class="dunkelBlauWeiss">Lieferantennummer / AdressIndex<br>(local supplier code)</td> // hier brauch ich den Inhalt

<td><vcc:textFieldComponent size="12" width="110" maxlength="30" name="NUMMER" /></td> // hier brauch ich ihn nicht
```


```
String regex = "<td.*>(.*)</td>" // wird im Programm je nach spezifizierten Tag zusammengebastelt
```
Leider bekomme ich hier nur *local supplier code* zurück.
Ich hab schon mit [^br] usw rumprobiert, aber dann stimmen andere Sachen nicht mehr.
Er soll also in der Gruppe einfach die <br>-Tags mitnehmen.

thx


----------



## elmato (15. Juli 2005)

Naja man muss ja auch nicht alles mir RegEx machen, schau die mal das an
http://www.tutorials.de/tutorials202949.html&highlight=html+links
vielleicht hilft es dir ja weiter, wenn nicht dann melde dich doch bitte nochmal
mfg


----------



## Vatar (18. Juli 2005)

Danke für den Tip.
Aber aus Gründen der konsistenz (im Code) und konfigurierbarkeit nützt mir das nichts.
Es geht bei dem Tool um Übersetzung von JSPs. Relevante JSP- und HTML-tags können in externen txt-files angegeben werden. Mit diesen Angaben werden dann die Regexe zusammengebastelt. Dieser HTMLEditor ist schon gut, aber da die relevanten HTML-Tags sich ändern können kann ich dass nicht hardcoden *htmlDoc.getIterator(HTML.Tag.A)(* (An dieser Stelle müsste halt was dynamisches stehen).


----------



## elmato (18. Juli 2005)

Vatar hat gesagt.:
			
		

> Und weiter gehts.
> Neben den speziellen Tags brauch ich teilweise auch noch den Inhalt von normalen HTML-Tags. Diese Tags werden in einer txt angegeben
> 
> ```
> ...


Was meinst du mit br-Tags mitnehmen?, soll er das br rausloeschen?

//edit: Oder moechetst du *Lieferantennummer / AdressIndex<br>(local supplier code)*
diesen ganzen Text haben?


----------



## Vatar (18. Juli 2005)

Genau: ich brauche den gesammten Content zwischen öffnenden und schließenden Tag.
Also *Lieferantennummer / AdressIndex<br>(local supplier code)* als Ergebnis.


----------



## elmato (18. Juli 2005)

```
<td.*?>(.*<br>.*?)</td>
```
bringt das gewuenschte Ergebnis bei mir.
mfg

edit: Aber auch nur wenn die Zeilen untereinander stehen, nicht wenn sie hintereinander sind...


----------



## Vatar (18. Juli 2005)

Danke, aber leider taucht der <br>-Tag nicht immer auf.

```
public static void main( String[] args ) {
        String test =   "<td class=\"blauDunkelBlau\">Lieferantennummer / AdressIndex<br>(local supplier code)</td>" + 
                        "<td class=\"blauDunkelBlau\">hallo</td>";

        String regex = "<td.*?>(.*<br>.*?)</td>";

        Matcher matcher = Pattern.compile( regex ).matcher( test );
        int i = 0;
        while( matcher.find() ) {
            System.out.println( ++i + "\t" + matcher.group( 1 ) );
        }
    }
```
In diesem Fall sollte er
1	Lieferantennummer / AdressIndex<br>(local supplier code)
2       hallo
ausgeben.


Habs nochmal verändert (soweit ich die Regex bisher verstanden habe) aber dann liefert er mir zu viel (1	Lieferantennummer / AdressIndex<br>(local supplier code)</td><td class="blauDunkelBlau">hallo)
*(<td.*?>(.*[<br>]?.*?)</td>*


----------



## elmato (18. Juli 2005)

```
<td.*?>(\\w.*?[<br>]?.*?)</td>
```
damit klappt es(ich hoffe da kommt nicht noch was  )
mfg


----------



## Vatar (18. Juli 2005)

was so ein \\w nicht alles ausmacht.  

Super. Funktioniert bestens.


----------



## Vatar (21. Juli 2005)

Keine Angst. Ich brauche keine Hilfe für einen neuen Regex  ;-).  Aber ich brauche Hilfe bei der Nutzung der Engine.

Nachdem nun alle relevanten Texte aus meinem Content-String extrahiert wurden (Dank eurer Hilfe    ), muss ich nun an diese Stelle ( group(1) ) andere Texte einfügen.

Dies endet in einer netten Endlosschleife und ersetzt auch sehr seltsam 

```
public static void main( String[] args ) {
        String test =   "<td class=\"blauDunkelBlau\"><div>Lieferantennummer / AdressIndex<br/>(local supplier code)</div></td> \n" + 
                        "<td class=\"blauDunkelBlau\">hallo</td>\n" + 
                        "<td>Test</td>\n" + 
                        "<tr><td>&nbsp;</td><td valign='top'><table width='0' border='0' cellspacing='1' cellpadding='0'><tr><td><a href='<fwk:dialog_getFunctionAsUrl function=\"lb&RUN_IN_MAINTENANCE_APPLICATION=true\" />' target=\"frameLowContent\" onmouseover=\"status='LoadBalancer Monitoring';return true;\" onmouseout=\"status='Lima On Web Maintenance' ;return true;\"><img src='/low/img/core/strich.gif' width='7' height='7' border='0'></a></td><td class='menuBlattTd'>&nbsp;</td></tr></table></td><td colspan='1'><a href='<fwk:dialog_getFunctionAsUrl function=\"lb&RUN_IN_MAINTENANCE_APPLICATION=true\" />' target=\"frameLowContent\" class='menuBlatt' onmouseover=\"status='LoadBalancer Monitoring';return true;\" onmouseout=\"status='Lima On Web Maintenance';return true;\">LoadBalancer Monitoring</a></td></tr>";

        String regex = ">(\\w.*?[<br>]?.*?)</";

        Matcher matcher = Pattern.compile( regex ).matcher( test );
        while( matcher.find() ) {
           System.out.println(matcher.replaceAll("bla"));  
        }
    }
```


```
Matcher matcher = Pattern.compile( regex ).matcher( test );
        while( matcher.find() ) {
           matcher.group(1). -> keine Ahnung
        }
```
Man könnte jetzt natürlich annehmen dass ich, nachdem ich alle Texte habe, einfach so vorgehen könnte:
	
	
	



```
content = content.replaceAll(alterText, neuerText)
```
Das funktioniert aber nicht, da es auch kurze Texte (Kürzel) gibt welche auch in anderen Tags/Attributen vorkommen können.
Er muss also wie beim extrahieren nach den Tags suchen und dann den Substring der aktuellen Gruppe 1 austauschen.

Ich hoffe ihr könnt mir nochmal helfen.
Thx

[EDIT]

```
Matcher matcher = Pattern.compile( regex ).matcher( test );
        int lenth = test.length();
        while( matcher.find() ) {
           int start = matcher.start(1);
           int end = matcher.end(1);
           
           System.out.println("Start: " + start + "\t" + "Ende: " + end);
           if(start < end && end < lenth){
               String before = test.substring(0, start - 1);
               String after = test.substring(end, lenth);
               test = before + "REPLACEMENT" + after;
           }
        }
```
 Hierbei bekomme ich eine ArrayIndexOutOfBoundsException bei test.substring(end, length) die ich überhaupt nicht nachvollziehen kann (auch nicht mit dem debugger).
Das lustige ist:
Wenn ich dies ausführe komme ich soweit
_Start: 32	Ende: 89	Länge: 932
Start: 129	Ende: 134	Länge: 932_
Und wenn ich *after = test.substring(end)* mache
_Start: 32	Ende: 89	Länge: 932
Start: 129	Ende: 134	Länge: 932
Start: 144	Ende: 148	Länge: 932
Start: 895	Ende: 918	Länge: 932_
Obwohl es ja eigentlich beide male genau das gleiche sein sollte.
  

Desweiteren stellt dieser Lösungsansatz einen extremen Objektoverkill dar (grob gerechnet 50000-60000 String-Objekte).


----------



## elmato (21. Juli 2005)

hmm, also mein Vorschlag waere einen StringBuffer zu benutzen mit der methode

```
replace(int start, int end, String str);
```
die start und endwerte sind bei mir 

```
matcher.start() + 1;
und
matcher.end() -2;
```
warum das so ist ist mir auch nicht ganz klar...
mfg


----------



## Vatar (21. Juli 2005)

Danke. Aber die ArrayIndexOutOfBoundsException ist immer noch. Ich hab rausgefunden, dass er intern den String kürzer führt als er ist.

```
String test = "<td class=\"blauDunkelBlau\"><div>Lieferantennummer / AdressIndex<br/>(local supplier code)</div></td> \n" + 
                        "<td class=\"blauDunkelBlau\">hallo</td>\n" + 
                        "<td>Test</td>\n"+ 
                        "<tr><td>&nbsp;</td><td valign='top'><table width='0' border='0' cellspacing='1' cellpadding='0'><tr><td><a href='<fwk:dialog_getFunctionAsUrl function=\"lb&RUN_IN_MAINTENANCE_APPLICATION=true\" />' target=\"frameLowContent\" onmouseover=\"status='LoadBalancer Monitoring';return true;\" onmouseout=\"status='Lima On Web Maintenance' ;return true;\"><img src='/low/img/core/strich.gif' width='7' height='7' border='0'></a></td><td class='menuBlattTd'>&nbsp;</td></tr></table></td><td colspan='1'><a href='<fwk:dialog_getFunctionAsUrl function=\"lb&RUN_IN_MAINTENANCE_APPLICATION=true\" />' target=\"frameLowContent\" class='menuBlatt' onmouseover=\"status='LoadBalancer Monitoring';return true;\" onmouseout=\"status='Lima On Web Maintenance';return true;\">LoadBalancer Monitoring</a></td></tr>";

System.out.println(test.length);
```
gibt mir eine Länge von 932 aus, aber intern führt er den String mit einer Länge von 896.   
Ich habs auch schon mit kürzeren String versucht -> immer das gleiche.

[EDIT]Man bin ich doooooof.
Der matcher ist ja schon fertig, und hat demnach noch die alte Länge und wenn ich ein replace mache, ändert sich ja die Länge.


----------



## Vatar (21. Juli 2005)

Hat sich erledigt. Funktioniert bestens.

```
public static void main( String[] args ) {
        String test = "<td class=\"blauDunkelBlau\"><div>Lieferantennummer / AdressIndex<br/>(local supplier code)</div></td> \n"
                + "<td class=\"blauDunkelBlau\">hallo</td>\n"
                + "<td>Test</td>\n"
                + "<tr><td>&nbsp;</td><td valign='top'><table width='0' border='0' cellspacing='1' cellpadding='0'><tr><td><a href='<fwk:dialog_getFunctionAsUrl function=\"lb&RUN_IN_MAINTENANCE_APPLICATION=true\" />' target=\"frameLowContent\" onmouseover=\"status='LoadBalancer Monitoring';return true;\" onmouseout=\"status='Lima On Web Maintenance' ;return true;\"><img src='/low/img/core/strich.gif' width='7' height='7' border='0'></a></td><td class='menuBlattTd'>&nbsp;</td></tr></table></td><td colspan='1'><a href='<fwk:dialog_getFunctionAsUrl function=\"lb&RUN_IN_MAINTENANCE_APPLICATION=true\" />' target=\"frameLowContent\" class='menuBlatt' onmouseover=\"status='LoadBalancer Monitoring';return true;\" onmouseout=\"status='Lima On Web Maintenance';return true;\">LoadBalancer Monitoring</a></td></tr>";

        StringBuffer sb = new StringBuffer( test );
        String regex = ">(\\w.*?[<br>]?.*?)</";

        Matcher matcher = Pattern.compile( regex ).matcher( test );
        ArrayList startListe = new ArrayList();
        ArrayList endeListe = new ArrayList();
        while( matcher.find() ) {
            startListe.add( new Integer( matcher.start( 1 ) ) );
            endeListe.add( new Integer( matcher.end( 1 ) ) );
        }
        for(int i=startListe.size() - 1; i>=0; i--){
            sb.replace( ((Integer)startListe.get(i)).intValue(), ((Integer)endeListe.get(i)).intValue(), "REPLACEMENT");
            System.out.println(i);
        }
        System.out.println( sb.toString() );
    }
```

Einfach alle Start und Ende Indexe speichern und den String von hinten aufarbeiten.


----------



## Vatar (2. August 2005)

*So, ein allerletztes mal bräuchte ich noch eure Hilfe.*

Da Tags ja bekanntlich geschachtelt werden können muss ich meinen Parser noch um eine Kleinigkeit  erweitern. Es kann also vorkommen dass der Text den ich extrahiert habe wiederum Tags enthällt. Aus diesem Text möchte ich dann wiederum nur den reinen Inhalt haben und zwar mit einem möglichst variablen Regex (nur ein tag davor oder danach, davor und danach, ...)

Ich hatte mir das bisher so gedacht (keine JavaSyntax). 
TestString:
	
	
	



```
<div>Zuordnung Prozessbeteiligte f&uuml;r <low:toolTip name="OP" bean="<%=LowWebappInfermWebSymbols.TIMEPERIOD_RESULT_VIEW%>"/> <low:toolTip name="TIME_PERIODE" bean="<%=LowWebappInfermWebSymbols.TIMEPERIOD_RESULT_VIEW%>"/>
```
Regex

```
(<\w.*?>)?(\w.*?)(</?\w.*?/?>)
```
 Das funktioniert auch mit einem Variablem Tag zu Beginn (oder eben keiner zu Beginn) wunderbar. Ich lasse mir dann den Text von Gruppe2 geben.

Die Erweiterung 
	
	
	



```
(<\w.*?>)?(\w.*?)(</?\w.*?/?>)?
```
 liefert mir aber leider nicht mehr den gesammten Text der Gruppe2 mit dem ersten Match, sondern jedes Zeichen einzeln nach dem ersten tag bis zum Schluss.

Kurz und knapp: Das ergebnis muss _Zuordnung Prozessbeteiligte f&uuml;r_ sein egal davor und/oder danach ein Tag steht.

thx


----------



## elmato (2. August 2005)

keine ahnung ob ich dich richtig verstanden habe aber schau mal ob es das ist was du suchst

```
(<\w.*?>)?(\w.*?)(</?\w.*?/?>).*?
```


----------



## Vatar (3. August 2005)

Schon etwas besser.
<tag>text<tag> -> funktioniert
text<tag>         -> funktioniert
<tag>text         -> funktioniert nicht
text                  -> funktioniert nicht
Die beiden letzen versionen *müssen* sein. Ich kapier diese Regex-Engine nicht so ganz. Von der Logik her müsste eas doch funktionieren, vor allem da der anfangstag ja schon variabel funktioniert.


----------



## elmato (3. August 2005)

Poste mal bitte alle varianten die du getestet haben moechtest, ich kappier leider nicht was du gerne moechtest, also bitte alle 4 Varianten als String einmal posten...
mfg


----------



## Vatar (3. August 2005)

Wieder mal Danke für deine Zeit.


```
<div>TEST</div>
```


```
<div>TEST
```


```
TEST<vcc:linkComponent value="bla"/>
```


```
TEST
```

Er soll immer TEST ausgeben.


----------



## jorgeHX (5. August 2005)

Moin,
kann ich mit so einem Pattern einen String auch auf folgende Zeichen prüfen:

\ / : * ? " < > |

Wenn ja, wie sieht das ganze denn dann aus?

Danke


----------



## Vatar (5. August 2005)

```
public class Tester {

	public static void main(String[] args) {
		String a = "aaaa ? kadlj | djasldj <> adaslkdj :ljasdka \\asldja / adlasdjh \"";
		String regex = ("\\?|\\||:|\\\\|/|<|>|\"");
		Matcher m = Pattern.compile(regex).matcher(a);
		while(m.find())
			System.out.println(m.group());
	}
}
```
Das gibt dir die gefundenen Zeichen aus.
\, |, ?,. sind Sonderzeichen der Regexengine und müssen escaped werden, da \ aber auch schon für Java ein Steuerzeichen ist musst du, um ein \ der Regexengine mitzuteilen \\ schreiben. Das ganze wird noch etwas verückter wenn du nach einem \ in deinem String suchst. Dann muss du insgesammt 4x *\* schreiben: 2 Steuerzeichen in Java damit bei der Regexengine auch 2 \ ankommen, das erste ist wiederum ein Steuerzeichen für die Regexengine.

Ich hoffe das war nicht zu verwirrend


----------



## jorgeHX (5. August 2005)

super, danke dir.

muss * auch besonders behandelt werden?


----------



## jorgeHX (5. August 2005)

Sorry, aber ich habe das gerade mal getestet. Leider findet der bei mir nichts.
Biste sicher, dass das alles ok ist?

Danke für die Hilfe schon jetzt.


----------



## elmato (5. August 2005)

SO ich hab's fast aber leider auch nur fast

```
String g = "<a>test</a>\n" +
		"test</a>\n"+
		"<a>test\n"+
		"test\n";
		Matcher m= Pattern.compile("<{0,1}\\w*?>{0,1}(\\w*)<{0,1}").matcher(g);
		while(m.find()){
			System.out.println(m.group(1));
		}
```
liefert ansich alles korrekt zurueck. Das einzige Problem ist das die ganzen "a" mit ausgegeben werden und ich weiss nicht wieso, da ich nur eine Captouring Group habe :| aber vielleicht weisst du ja von hier aus weiter...
Wenn sich noch was aendert melde ich mich wieder 
mgf


----------



## Vatar (5. August 2005)

jorgeHX hat gesagt.:
			
		

> Sorry, aber ich habe das gerade mal getestet. Leider findet der bei mir nichts.
> Biste sicher, dass das alles ok ist?
> 
> Danke für die Hilfe schon jetzt.


Also wenn ich genau das was ich oben geschrieben habe bei mir laufen lasse (Copy&Paste) dann gibt er mir alle Zeichen aus die er findet.


*@elmato*
Vielen Dank. Ich denke den Rest krieg ich noch irgendwie hin.
Thx Thx Thx


----------



## jorgeHX (6. August 2005)

Sorry, hatte was falsch eingefügt. Läuft super.
Danke

Mit * lautet dann:

String regex = ("\\?|\\||:|\\*|\\\\|/|<|>|\"");


----------



## Vatar (31. August 2005)

Ich wollte nur mal die Lösung für mein Problem mit den geschachtelten Tags posten (für Interesierte).


```
public class Main {

    /**
     * @param args
     */
    public static void main( String[] args ) {
       /* Testfälle */
//        String test = "<td> blablabla       <tag dsd> blubblub</td>";
//        String test = "<td> bla > dasd      </td>";
//        String test = "<td> bla <tag>       </td>";
        String test = "<td><tag>blablabla</td>";
//        String test = "<td> <tag1   <tag2>  tag1>bla   </td>";
//        String test = "<td colspan=\"2\" align=\"center\" class=\"blauDunkelBlau\">AAAAA<low:dropdownComponent name=\"<%=LowWebappInfermWebSymbols.OPTION_BEAN_ZEITRAUM%>\" optionBean=\"<%=LowWebappInfermWebSymbols.OP_ZEITRAUM_DROP_DOWN_OPTIONS_LIST%>\" optionBeanProperty=\"DropDown\" selectionBean=\"<%=LowWebappInfermWebSymbols.OP_ZEITRAUM_DROP_DOWN_OPTIONS_LIST%>\" selectionBeanProperty=\"Selection\" action=\"true\" width=\"160\" maxDisplayedChars=\"33\" /></td>";

        Matcher m = Pattern.compile("<td.*?>(.*?[<br>]?.*?)</td>").matcher(test);
        ReplacementList list = new ReplacementList();

        StringBuffer sb = new StringBuffer(test);
        System.out.println(sb);
        
        while(m.find()){
            search2(list, m, 0, m.group(1));
        }

        
        Iterator it = list.getMap();
        while(it.hasNext()){
            Entry entry = (Entry)it.next();
            ReplaceObject r = (ReplaceObject)entry.getValue();
            
            int position = r.getStartPosition();
            int end = r.getEndPosition();
            sb.replace(position, end, "Hallo");
        }
        
        System.out.println(sb.toString());
    }
    
   
    public static void search2 (ReplacementList list, Matcher m, int appendIndex, String s){
        if(s.matches("<a href.*?") == false){
            int opened = 0;
            int closed = 0;
            int closedTagPosition = 0;
            
            int firstOpenTag = s.indexOf("<");
            int firstCloseTag = s.indexOf(">");
            
            char[] a = null;
            int arrayStartPosition = 0;
            
            if( (firstOpenTag != -1 && firstCloseTag == -1) || (firstOpenTag == -1 && firstCloseTag != -1) || (firstOpenTag == -1 && firstCloseTag == -1) ){
                if(s.length() > 0)
                    list.add(m.start(1) + appendIndex, m.start(1) + appendIndex + s.length(), s);
            }
            else if(firstOpenTag > 0){
                String text = s.substring(0, firstOpenTag);
                if(text.length() > 0)
                    list.add(m.start(1) + appendIndex, m.start(1) + appendIndex + firstOpenTag, text);
                a = s.substring(firstOpenTag, s.length()).toCharArray();
                arrayStartPosition = firstOpenTag;
            }
            else{
                a = s.toCharArray();
            }

            String nextString = null;
            if( a != null){
                for(int i=0; i<a.length; i++){
                    if(a[i] == '<')
                        opened++;
                    else if(a[i] == '>')
                        closed++;
                    
                    if(opened == closed){
                        closedTagPosition = i;
                        nextString = s.substring(arrayStartPosition + closedTagPosition + 1, s.length());
                        break;
                    }
                }
            }
            
            if(nextString != null && nextString.length() > 0)
                search2(list, m, arrayStartPosition + closedTagPosition+1, nextString);
        }
    }
```

ReplaceObject:

```
import java.util.Comparator;


public class ReplaceObject {

    private int startPosition;
    private int endPosition;
    private String germanText;
    
    
    protected ReplaceObject( int startPosition, int endPosition, String germanText ){
        this.startPosition = startPosition;
        this.endPosition = endPosition;
        this.germanText = germanText;
    }
    
   
    public int getStartPosition(){
        return startPosition;
    }
    
    public int getEndPosition(){
        return endPosition;
    }
    
    public String getGermanText(){
        return germanText;
    }
}// end Class
```

ReplacementList

```
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;


public class ReplacementList implements Comparator{

    private TreeMap replaceObjects;
    
    protected ReplacementList (){
        replaceObjects = new TreeMap(this);
    }
    
    
    public void add( int startPosition, int endPosition, String germanText ){
        ReplaceObject o = new ReplaceObject( startPosition, endPosition, germanText );
        replaceObjects.put(new Integer(startPosition), o);
        
    }
    
        
    public int compare( Object o1, Object o2 ) {
        int start1 = ((Integer)o1).intValue();
        int start2 = ((Integer)o2).intValue();
        
        if(start1 < start2)
            return 1;
        else if(start1 > start2)
            return -1;
        return 0;
    }
    
    
    public Iterator getIterator(){
        return replaceObjects.entrySet().iterator();
    }
    
}// end Class
```


----------

