Umlaute ersetzen
Gerald Holl
Ich möchte in einem String alle Umlaute und das scharfe s ersetzen.
Da es ja seit JDK 5.0 eine matches Methode gibt, hab ich es mit dieser
ausprobiert:
if (str.matches("/[üäöß]/")) {
str = str.replaceAll("ü", "ue").
replaceAll("ä", "ae").
replaceAll("ö","oe").
replaceAll("ß", "ss");
}
Die matches Methode liefert false auch wenn Umlaute im String vorhanden
sind. Auch wenn ich die / bei der RegEx weglasse, funktioniert es nicht.
Weiß jemand was da schiefläuft?
Danke,
Gerald
Achim Peters
> Ich möchte in einem String alle Umlaute und das scharfe s ersetzen.
> Da es ja seit JDK 5.0 eine matches Methode gibt, hab ich es mit dieser
> ausprobiert:
> if (str.matches("/[üäöß]/")) {
> str = str.replaceAll("ü", "ue").
> replaceAll("ä", "ae").
> replaceAll("ö","oe").
> replaceAll("ß", "ss");
> }
>
> Die matches Methode liefert false auch wenn Umlaute im String vorhanden
> sind.
Dein String muss den Ausdruck "matchen", d. h. diesem Ausdruck
entsprechen. Dein Ausdruck beschreibt einen String, der aus genau einem
"/", einem Umlaut/ß und dann einem Slash besteht.
> Auch wenn ich die / bei der RegEx weglasse, funktioniert es nicht.
> Weiß jemand was da schiefläuft?
Dann suchst Du einen String, der aus genau einem Zeichen der Aufzählung
besteht.
Versuche mal
str.matches("\\.*[üäöß]\\.*")
Bye
Achim
Hauke Ingmar
Gerald Holl schrieb:
> Ich möchte in einem String alle Umlaute und das scharfe s ersetzen.
> Da es ja seit JDK 5.0
Seit 1.4.
> eine matches Methode gibt, hab ich es mit dieser
> ausprobiert:
> if (str.matches("/[üäöß]/")) {
> str = str.replaceAll("ü", "ue").
> replaceAll("ä", "ae").
> replaceAll("ö","oe").
> replaceAll("ß", "ss");
> }
>
> Die matches Methode liefert false auch wenn Umlaute im String
> vorhanden sind. Auch wenn ich die / bei der RegEx weglasse,
> funktioniert es nicht. Weiß jemand was da schiefläuft?
Was sollen denn die / bedeuten?
matches prüft, ob der String dem Muster entspricht, nicht, ob das Muster in
dem String enthalten ist. Du mußt also entweder einen Matcher konstruieren
und die #find-Methode benutzen oder ein Muster nehmen, das den ganzen String
umfaßt: "^.*[äöüß]+.*$".
Bis denn
P.S.: Iiiihhh, Umlaute ersetzen. In welchem kranken Umfeld ist das denn noch
notwendig?
Gerald Holl
>>eine matches Methode gibt, hab ich es mit dieser
>>ausprobiert:
>>if (str.matches("/[üäöß]/")) {
>> str = str.replaceAll("ü", "ue").
>> replaceAll("ä", "ae").
>> replaceAll("ö","oe").
>> replaceAll("ß", "ss");
>>}
>>
>>Die matches Methode liefert false auch wenn Umlaute im String
>>vorhanden sind. Auch wenn ich die / bei der RegEx weglasse,
>>funktioniert es nicht. Weiß jemand was da schiefläuft?
>
>
> Was sollen denn die / bedeuten?
> matches prüft, ob der String dem Muster entspricht, nicht, ob das Muster in
> dem String enthalten ist. Du mußt also entweder einen Matcher konstruieren
> und die #find-Methode benutzen oder ein Muster nehmen, das den ganzen String
> umfaßt: "^.*[äöüß]+.*$".
Danke, jetzt funktioniert es. Bin leider mit RegExs nicht wirklich vertraut.
> P.S.: Iiiihhh, Umlaute ersetzen. In welchem kranken Umfeld ist das denn noch
> notwendig?
Ich verwende Amazon WebServices, und wenn die Suchbegriffe Umlaute
enthalten, kann diese der Server nicht korrekt interpretieren und findet
keine Produkte. Deswegen muß ich diesen Umweg machen.
Gerald
Achim Peters
>>Ich möchte in einem String alle Umlaute und das scharfe s ersetzen.
>>if (str.matches("/[üäöß]/")) {
>> str = str.replaceAll("ü", "ue").
>> replaceAll("ä", "ae").
>> replaceAll("ö","oe").
>> replaceAll("ß", "ss");
>>}
> matches prüft, ob der String dem Muster entspricht, nicht, ob das Muster in
> dem String enthalten ist. Du mußt also entweder einen Matcher konstruieren
> und die #find-Methode benutzen oder ein Muster nehmen, das den ganzen String
> umfaßt: "^.*[äöüß]+.*$".
JFTR: Da das Pattern sowieso dem ganzen String entsprechen muss, braucht
man nicht noch extra zu erwähnen, dass am Stringanfang ein Stringanfang,
und am Stringende ein Stringende stehen muss. ;-) Es geht also auch ohne
das "^" und "$". Das "+" ist ebenfalls nicht nötig wegen des folgenden ".*".
Bye
Achim
Stefan Matthias Aust
>>> str = str.replaceAll("ü", "ue").
>>> replaceAll("ä", "ae").
>>> replaceAll("ö","oe").
>>> replaceAll("ß", "ss");
>>>}
Bringt das zusätzliche matches überhaupt irgendwas an Geschwindigkeit?
Ich bezweifel das. Wenn die Mehrzahl von Strings eh mindestens ein
Umlaut oder ß enthält (wie dieser Satz) dann werden ja eh die 4
replaceAll durchgeführt.
Wenn es schneller gehen soll, dann verzichtet man am besten komplett auf
reguläre Ausdrücke (replaceAll erzeugt und kompiliert *jedes* *Mal*
einen neuen wenn auch trivialen Regex!) und macht es wie es eigentlich
naheliegend wäre...
int length = s.length();
StringBuilder b = new StringBuilder(length);
for (int i = 0; i < length; i++) {
char c = s.charAt(i);
if (c == 'ü') b.append("ue");
else if ...
else b.append(c);
}
return b.toString();
Da jetzt bei mindestens einem Sonderzeichen erstmal der StringBuilder
seinen Buffer verdoppeln muss, könnte es Sinn machen, hier ja nach
Häufigkeit der Umlaute besser zu werden. Etwa durch
StringBuilder b = new StringBuilder(length + length / 8);
(Der Mikrooptimierer in mir hat einen für den Prozessor leicht
optimierbare Divisor gewählt)
Eine Alternative bei wenigen Umlauten und kurzen Strings wäre dies:
StringBuilder b = new StringBuilder(s);
for (...) {
char c = b.charAt(i);
if (c == 'ü') b.replace(i, i + 1, "ue");
...
}
return b.toString();
Das spart steten kopieren, kopiert dafür aber jedes Mal alles für jeden
Umlaut. Wahrscheinlich nicht zu empfehlen.
PS: Wieso eigentlich nur die kleinen Umlaute?
Und was ist mit ë, ï, oder ÿ :)
--
Stefan Matthias Aust // Lassen Sie uns durch, wir sind Arzt!
Achim Peters
>>>> if (str.matches("/[üäöß]/")) {
>>>> str = str.replaceAll("ü", "ue").
>>>> replaceAll("ä", "ae").
>>>> replaceAll("ö","oe").
>>>> replaceAll("ß", "ss");
>>>> }
>
>
> Bringt das zusätzliche matches überhaupt irgendwas an Geschwindigkeit?
Keine Ahnung. Der OP wollte das halt. Wenn's schee macht ...
> Ich bezweifel das. Wenn die Mehrzahl von Strings eh mindestens ein
> Umlaut oder ß enthält (wie dieser Satz) dann werden ja eh die 4
> replaceAll durchgeführt.
Der OP schrieb später, dass er Suchbegriffe umwandeln will. Da dürfte
die Trefferquote schon bedeutend niedriger sein.
> Wenn es schneller gehen soll, dann verzichtet man am besten komplett auf
> reguläre Ausdrücke (replaceAll erzeugt und kompiliert *jedes* *Mal*
> einen neuen wenn auch trivialen Regex!) und macht es wie es eigentlich
> naheliegend wäre...
ACK
Bye
Achim
Ralf Ullrich
> Stefan Matthias Aust wrote:
>
An den OP:
>>>>>str = str.replaceAll("ü", "ue").
>>>>> replaceAll("ä", "ae").
>>>>> replaceAll("ö","oe").
>>>>> replaceAll("ß", "ss");
genügt völlig.
>>Ich bezweifel das. Wenn die Mehrzahl von Strings eh mindestens ein
>>Umlaut oder ß enthält (wie dieser Satz) dann werden ja eh die 4
>>replaceAll durchgeführt.
>
>
> Der OP schrieb später, dass er Suchbegriffe umwandeln will. Da dürfte
> die Trefferquote schon bedeutend niedriger sein.
Hand hoch wer schon mal mehr als 100 Zeichen als Suchbegriff eingeben hat!
Keiner?
Also was soll die ganze Optimiererei????
cu
Gerald Holl
> Achim Peters wrote:
>
>> Stefan Matthias Aust wrote:
>>
>
> An den OP:
>
>>>>>> str = str.replaceAll("ü", "ue").
>>>>>> replaceAll("ä", "ae").
>>>>>> replaceAll("ö","oe").
>>>>>> replaceAll("ß", "ss");
>
>
> genügt völlig.
Hm, ich hab jetzt doch Stefans Lösung genommen, weil es performanter ist.
Normalerweise ist es ja meistens so, daß der kürzere Algorithmus der
bessere/elegantere ist, aber es gibt auch Ausnahmen :)
Gerald
Stefan Matthias Aust
> Also was soll die ganze Optimiererei????
Also ich habe den ganzen Thread nicht gelesen (und gestehe diese
ignoranz sogar noch freimütig, so eine Frechheit) und fand es nur
unnötig kompliziert.
Daher:
Wer den Prozessorzyklus nicht ehrt ist den google nicht wert...
(Wenn ein paar Millionen Suchanfragen pro Minute bearbeitet werden
sollen, macht es schon einen Unterschied, ob das reguläre Ausdrücke
werkeln oder nicht. In diesem Fall würde ich aber auch keine Strings
mit chars drin benutzen, sondern wahrscheinlich int[] oder byte[], in
denen die Worte speziell kodiert stehen.)
Ingo R. Homann
Gerald Holl wrote:
> Hm, ich hab jetzt doch Stefans Lösung genommen, weil es performanter ist.
> Normalerweise ist es ja meistens so, daß der kürzere Algorithmus der
> bessere/elegantere ist, aber es gibt auch Ausnahmen :)
Der kürzeste Sortier-Algorithmus is IMHO BubbleSort. "Gut" ist der
definitiv nicht, und das einzige, was man daran bestenfalls "elegant"
finden kann, ist tatsächliche seine Kürze und Simplizität.
Bei String-Suchalgorithmen fallen mir neben dem trivialen brute-force
Ansatz (welches wohl mit der kürzeste Algorithmus ist) z.B.
Boyer-Moore(-Horspool?) und Knuth-Morriss-Pratt ein. Beide sind
definitiv länger, aber IMHO auch eleganter.
Um das Traveling-Salesman-Problem zu lösen ist der
brute-force-Algorithmus wohl auch der kürzeste, aber der ist nun
*überhaupt nicht* performant oder elegant.
Aus meiner Diss könnte ich noch ein paar Algorithmen zum
Sortieren/Kombinieren von Fuzzy-Streams zitieren, bei denen der kürzeste
auch der schlechteste und uneleganteste ist (um mal kurz die Ergebnisse
meiner Diss in zwei Worten zusammenzufassen ;-)
Eigentlich fällt mir spontan *gar kein* Beispiel ein, auf das deine
Aussage zutrifft, geschweige denn, dass sie "meistens" zutrifft!?
Ciao,
Ingo
Gerald Holl
> Eigentlich fällt mir spontan *gar kein* Beispiel ein, auf das deine
> Aussage zutrifft, geschweige denn, dass sie "meistens" zutrifft!?
Ich meinte mit dieser Aussage keine "weltbekannten" Algorithmen, sondern
"selbst erstellte".
Ich erinnere mich noch an die Programmier Übungen aus den ersten
Semstern in denen eben in den meisten Fällen der kürzere Algorithmus
auch der schnellere und leichter verständlichere war.
Bezüglich Sortier- und Patternmatching Algorithmen muß ich dir auf jeden
Fall recht geben.
cheers,
Gerald