Mehrere replaces

Conners

Erfahrenes Mitglied
Hi,

an einer Stelle in meinem Code führe ich mehrere replaceAlls aus.
Gibt es eine Möglichkeit die irgendwie zusammenzufügen mit Regex evtl. ? Da wird ja auch Regex intern verwendet beim replaceAll oder?

Dazu kommt noch, dass die teilweise ineinander verschachtelt sind.
Also ich hab da in etwa sowas stehen:
Code:
text = text.replaceAll("Hallo", "Hello");
text = text.replaceAll("Welt;", "World");
text = text.replaceAll("Hello World", "hello world");

Da der zu durchsuchende String "text" sehr sehr lang ist, wollt ich das gerne alles in einer Suchschleife abarbeiten.

Ich hab Regex in Java noch nie verwendet, ist das genauso zu handhaben wie in C# ?

Aber selbst in C# wüsste ich nicht, wie ich das alles in einmal machen würde. Auch da würd ich für dieses Beispiel 3 Regexs anlegen und 3 Regex.Replace aufrufen.
In etwa so:
Code:
string a = "Hallo";
Regex r1 = new Regex(@a);
string b = "Welt";
Regex r2 = new Regex(@b);
string c = "Hello World";
Regex r3 = new Regex(@c);
text = r1.Replace(text, "Hello");
text = r2.Replace(text, "World");
text = r3.Replace(text, "hello world");

Gruß
Conners
 
Zuletzt bearbeitet:
Reguläre Ausdrücke sind überall identisch. Aber das wirst du wohl nicht zusammenfassen können, weil du für die Unterschiedlichen Ausdrücke unterschiedliche Werte setzen möchtest. Aber du könntest anstelle von replaceAll nur replace verwenden. Dadurch sparst du dir Rechenzeit, da dann der zu ersetzende String nicht mehr als regex interpretiert wird.
 
Ich hätte da noch eine Frage.
Ich führe in meinem Parser oft auch folgende Codes aus.
Code:
String text;
...
text += source.substring(start, position);

Ich hab String text nun ersetzt durch StringBuilder, weil ich irgendwo gelesen hab, dass das mit append() wesentlich effizienter ist.

Allerdings führ ich am Ende des Parser nunmal diese oben im Thread genannten Replace-Methoden aus.

Also String.replace("String1","String2");

Gibts sowas beim StringBuilder nicht?
 
Nein, brauchst du aber auch nicht. Ein replace auf einen String ist nicht zeitkritisch. Der Geschwindigkeitsgewinn vom StringBuilder (nicht thread-safe) und StringBuffer (thread-safe) im Vergleich zum String liegt darain, dass diese immutable sind im Gegensatz zu Strings. Während du mit append nur etwas an deinen StringBuilder anhängst, erzeugst du mit += jedes Mal ein neues Objekt deiner String-Klasse.
 
Huhu,

jo, das hab ich mir auch schon fast gedacht, weil ich einen zeitlichen Unterschied nicht wirklich erkennen konnte. Aber mit append() siehts ja auch übersichtlicher aus find ich.

Nixdestotrotz, danke :)
 
Zusätzlich eine kleine Gegenüberstellung von Strings (immutable) zu StringBuffern (mutable):

Java:
public static void main(String[] args) {
	String string = "";
	StringBuffer buffer = new StringBuffer();

	System.out.println(new Date());

	for(int i = 0; i < 50000; i++) {
		string += "a";
	}

	System.out.println(new Date());

	for(int i = 0; i < 50000000; i++) {
		buffer.append("a");
	}

	System.out.println(new Date());
}

Ausgabe:

Code:
Tue Nov 11 21:55:27 CET 2008
Tue Nov 11 21:55:35 CET 2008
Tue Nov 11 21:55:39 CET 2008

Heißt also (mal abgesehen von meiner rechnerischen Leistung) , dass ein StringBuffer in gegebenem Szenario rund 2000-mal so performant ist wie ein normaler String. :)

Viele Grüße,
MAN
 
Zurück