im String ersetzen, wenn.

Status
Nicht offen für weitere Antworten.
M

magic_halli

Bekanntes Mitglied
Hi,

ich habe einen String, der in etwa so aussehen kann:
java Code:
Code: 
String str = "sigma_v=sqrt(sigma^2+3*tau^2*tau_v)";

Jetzt möchte ich in solch einem String bspw. 'sigma' und 'tau' ersetzen (z.B. durch einen Zahlenwert).
Es soll aber nur ersetzt werden, wenn links vom gefundenen Wort (wäre hier 'sigma' bzw. 'tau') entweder ein Leerzeichen oder math. Zeichen ( +,-,*,/,(,),^ etc. ) UND rechts vom gefundenen Wort ebenfalls Leerzeichen, math.Zeichen, oder ein Stringende vorkommt
Hier in diesem Fall würde/sollte dann 'sigma' und 'tau' ersetzt werden, aber nicht das sigma von 'sigma_v' und tau von 'tau_v'!
Wie ich ersetze weis ich. Mir geht es nur um das Überprüfen dieser Kriterien... denn ein ersetzen von sigma bzw. tau mittels replaceAll(), ersetzt ja leider auch in den Worten sigma_v und tau_v - das soll aber nicht ersetzt werden.

Wie kann ich das anstellen?

Danke und Gruß.
 
mit regulären Ausdrücken könntest du sowas finden,
aber kaum ersetzen,
immerhin bekommst du den Index des Anfangs und Ende,
dann könntest du damit den Originalstring auftrennen und neu zusammensetzen,

vielleicht kennt noch wer einfacheres/ oder die Ersetzungserweiterung selber bauen 😉
Code: 
public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        String str = "aaaaacdueaaaa";
        String search = "(c|e)(du|da)(c|e)";
        Pattern p = Pattern.compile(search);
        Matcher m = p.matcher(str);
        while (m.find())
        {
            System.out.println("find: "+m.group(1)+", "+m.group(2)+", "+m.group(3));
            System.out.println(m.end(1)+", "+m.start(3));
        }
    }
}
 
ach so gehts:

Code: 
public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        String str = "---cdue--du-";
        str = str.replaceAll("(c|e)(du|da)(c|e)", "$1TTT$3");
        System.out.println(str);
    }
}
 
mit regulären Ausdrücken könntest du sowas finden,
aber kaum ersetzen, ...
Zum Vergrößern anklicken....
Mh, danke erstmal. Das ich kaum ersetzen kann, ist natürlich nicht schön, denn darum gehts mir ja eigentlich. :cry:
Naja, ich werde mal ein wenig probieren - vielleicht fällt ja jemand noch ein Ansatz dazu ein?!
 
magic_halli hat gesagt.:
ich habe einen String, der in etwa so aussehen kann:
Zum Vergrößern anklicken....
Sowas habe ich doch neulich schonmal gelesen (siehe: http://www.java-forum.org/de/viewtopic.php?t=58347) ;-)

magic_halli hat gesagt.:
Wie ich ersetze weis ich. Mir geht es nur um das Überprüfen dieser Kriterien... denn ein ersetzen von sigma bzw. tau mittels replaceAll(), ersetzt ja leider auch in den Worten sigma_v und tau_v - das soll aber nicht ersetzt werden.
Zum Vergrößern anklicken....
Dann hilft nur, dein Kriterium für den Vergleich zu erweitern:
Code: 
String search = "(c|e)(du|da)(c|e)";

// wird dann zu 

String search1 = "(du|da)[^_]";

siehe auch: java.util.regex

das "Dach" sorgt dafür, dass beim Vergleich nach "du" oder "da" KEIN '_' steht.
 
Code: 
String search1 = "(du|da)[^_]";
Zum Vergrößern anklicken....
Wie sieht das syntaktisch aus, wenn ich außer dem '_' auch auf KEINE alphanumerischen Zeichen prüfen will???
Code: 
[^\w]
So etwa?

PS: Verstehe ich hier was falsch...?
WEnn ich folgendes schreibe:
Code: 
String eingabe = "sigma_v=sqrt(sigma^2+3*tau^2)";
eingabe = eingabe.replaceAll("(sigma)[^_][a-zA-Z0-9]", "xxx");
...dann bedeutet das doch, dass alle 'sigma' im Text ersetzt werden, die KEIN '_' und keine alphanummerischen Zeichen noch hintendran haben,oder?! Also werden sigma_v, sigma2 oder auch sigmaW nicht verändert?!
Frage:
1. Wieso kommt kein '^' bei den alphanummerischen Zeichen davor?
2. Wie sähe die Syntax aus, wenn ich auch VOR dem Suchwort auf diese ganzen Zeichen prüfen möchte?
Code: 
String eingabe = "sigma_v=sqrt(sigma^2+3*tau^2)";
eingabe = eingabe.replaceAll("[^_][a-zA-Z0-9](sigma)[^_][a-zA-Z0-9]", "xxx");
So klappts nämlich nicht!
 
> So etwa?

erst testen,
wenn irgendwas komisches rauskommt, dann konkrete Fragen stellen wie im Rest deines Postings

> dann bedeutet das doch, dass alle 'sigma' im Text ersetzt werden, die KEIN '_' und keine alphanummerischen Zeichen noch hintendran haben,oder?!

wieso KEINE alphanummerischen ZeicheN?
von Mehrzahl steht da nix, nur ein Zeichen, und ein ^ fehlt auch, also keine Negation

> 1. Wieso kommt kein '^' bei den alphanummerischen Zeichen davor?

? wenn du ein ^ haben willst, dann schreibe es hin, sonst nicht

> 2. Wie sähe die Syntax aus, wenn ich auch VOR dem Suchwort auf diese ganzen Zeichen prüfen möchte?
> So klappts nämlich nicht!

bitte nochmal ganz langsam in deutscher Sprache was genau gematcht werden soll,
idealerweise mit Positiv- und Negativ-Beispielen
 
magic_halli hat gesagt.:
Wie sieht das syntaktisch aus, wenn ich außer dem '_' auch auf KEINE alphanumerischen Zeichen prüfen will???
Code: 
[^\w]
So etwa?
Zum Vergrößern anklicken....
Hast du mal die API-Doku zu java.util.regex gelesen??? (Link in meinem letzten Beitrag) Da steht eigentlich alles drin. Eine Auflistung aller möglichen Ausdrücke findest du bei der Klasse "Pattern", aber das war eigentlich klar, oder?

magic_halli hat gesagt.:
PS: Verstehe ich hier was falsch...?
Code: 
eingabe = eingabe.replaceAll("(sigma)[^_][a-zA-Z0-9]", "xxx");
Zum Vergrößern anklicken....
Ja...

Jedes Zeichen deines regulären Ausdrucks ist zunächst mal ein Zeichen, welches mit deinem zu testenden String übereinstimmen muss. Mit Hilfe der eckigen Klammern kannst du Gruppen von Zeichen gegen ein einzelnes Zeichen vergleichen, also z.B. [0-9] ist eine der Zahlen 0 bis 9. Jetzt hast du ja schon völlig korrekt [a-zA-Z0-9] geschrieben, allerdings in eine separate Klammer. Du vergleichst also jetzt auf Strings, die im Anschluss an das "sigma" irgendein Zeichen stehen haben, nur keinen Unterstrich. Erst im Anschluss an dieses EINE Zeichen greift dann die o.g. Klammer für die alphanumerischen Ausdrücke.

magic_halli hat gesagt.:
1. Wieso kommt kein '^' bei den alphanummerischen Zeichen davor?
2. Wie sähe die Syntax aus, wenn ich auch VOR dem Suchwort auf diese ganzen Zeichen prüfen möchte?
Zum Vergrößern anklicken....
zu 1.: wer sagt das, dass da kein '^' davor steht???
zu 2.: Der angegebene String ist grundsätzlich so zu verwenden, d.h. genau das Pattern, dass gewünscht oder nicht gewünscht ist, steht auch in deinem Java-Pattern, allerdings solltest du erstmal den ersten Fall (kein '_' und kein alphanum) richtig hinbekommen, bevor du dein Pattern erweiterst.

Reguläre Ausdrücke können durchaus sehr komplex werden und wenn du schon falsch - bzw. nicht getestet (siehe den Beitrag von SlaterB) - anfängst, wird das nix :noe:
 
Ok Leute, sry wenn ich vorhin etwas wirr gepostet habe 😳

Also, API zu java.util.regex hab ich gelesen und vor mir liegen.
Ich habe nun folgendes probiert:
Code: 
String eingabe = "sigma_v=sqrt(sigma^2+3*tau^2)";
eingabe = eingabe.replaceAll("(sigma)[^_a-zA-Z0-9]", "XXX");
System.out.println(eingabe);
Ausgabe:
Code: 
sigma_v=sqrt(XXX2+3*tau^2)
Falsch, denn das '^' nach sigma wird mit ersetzt! Jedoch richtig insofern, als dass das sigma_v so bleibt wie´s ist.

In Worten heißt das doch bei mir: "Ersetze sigma, wenn das nachfolgende Zeichen KEIN (^ entspricht Negation) '_' oder Zahlen, oder Buchstaben ist"?!

Wenn ich jetzt folgenden Eingangsstring habe:
Code: 
String eingabe = "sigma_v=sqrt(sigma(tau)^2+3*tau^2)";
eingabe = eingabe.replaceAll("(sigma)[^_a-zA-Z0-9]", "XXX");
System.out.println(eingabe);
Ausgabe:
Code: 
sigma_v=sqrt(XXXtau)^2+3*tau^2)
Da wird sigma ersetzt, aber die Klammer gleich mit weggemacht!

Omg, mir qualmt der Schädel bei diesen RegularExpressions. Was mache ich denn nur falsch - ich stell mich aber auch wieder an?! :autsch:
 
du hast den String sigma^, der auf dein Suchschema passt,
dieser String wird also durch XXX ersetzt (der ganze String, nicht nur ein bisschen davon), was könnte es einfacheres geben 😉

wie man dafür sorgt, dass sowohl gesucht wird, aber die umgebenden Zeichen erhalten bleiben,
das hatten wir doch anfangs geklärt:

String str = "---cdue--du-";
str = str.replaceAll("(c|e)(du|da)(c|e)", "$1TTT$3");


willst du damit noch selber probieren oder ohne jede Ahnung auf eine Lösung warten? 😉
 
Naja, es wäre echt toll, wenn ich die Lösung selber finden würde! :roll: Ich tue mir hierbei zwar schwer, aber so denke ich, lerne ich auch was dabei?!

Nur nochmal für mich zur Erklärung...
Code: 
String str = "---cdue--du-";
str = str.replaceAll("(c|e)(du|da)(c|e)", "$1TTT$3");
Das heißt, dass wenn ein 'du' oder 'da' im STring vorkommt und davor UND dahinter ein 'c' oder 'e' vorkommt, erst dann wird du oder da durch TTT ersetzt. $1 ist hierbei der Platzhalter für das erste (c|e) und $3 für das nachfolgende (c|e) bzw. eben den Klammerausdruck, wie auch immer der heisen mag.
Hab ich das richtig verstanden?
 
ja,
das kompliziert (du|da) in der Mitte kann einfacher nur ein String sein,
du willst in einem replaceAll ja immer nur genau ein Element wie 'sigma' ersetzen
 
Ok, ich kann in der mittleren Klammer auch mein sigma einsetzen... soweit verstanden.
Jezt hab ich versucht, nicht auf c oder e zu prüfen, sondern auf irgendwelche Sonderzeichen, bspw:
Code: 
String str = "---^du^--du-";
str = str.replaceAll("(^)(du|da)(^)", "$1TTT$3");
Ausgabe:
Code: 
---^du^--du-

So und hier bin ich mit der Logik schon wieder am Ende - warum das denn - ob nun Buchstabe oder Zeichen... ist das nicht egal bzw. ist meine Syntax falsch?
 
^ steht für den Anfang einer Zeile

nach einen Buchstaben kann nie der Anfang einer Zeile kommen, da kommt immer erst das Zeilenende,

mit viel Umbau funktioniert
Code: 
public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        String str = "du\n--du-";
        Pattern p = Pattern.compile("(^)(du|da)($)",Pattern.MULTILINE);
        Matcher m = p.matcher(str);
        str = m.replaceAll("$1TTT$3");
        System.out.println(str);
    }
}

aber du wolltest doch was ganz anderes oder? 😉
 
aber du wolltest doch was ganz anderes oder?
Zum Vergrößern anklicken....
Naja, eigentlich wollte ich das sigma ersetzen... schon richtig, aber weiterführend muss ich ja noch abfangen, wie reagiert werden soll, wenn irgendwelche anderen Zeichen (Klammern, ^, *, +, -, / etc vorkommen). Denn ich habe ja gesehen, dass wenn ich es so mache:
Code: 
String eingabe = "sigma_v=sqrt(sigma^2+3*tau^2)";
eingabe = eingabe.replaceAll("(sigma)[^_a-zA-Z0-9]", "XXX");
System.out.println(eingabe);
...kommt als Ausgabe:
Code: 
sigma_v=sqrt(XXX2+3*tau^2)

und wie Du schon richtig gesagt hast:
wie man dafür sorgt, dass sowohl gesucht wird, aber die umgebenden Zeichen erhalten bleiben,
das hatten wir doch anfangs geklärt:

String str = "---cdue--du-";
str = str.replaceAll("(c|e)(du|da)(c|e)", "$1TTT$3");
Zum Vergrößern anklicken....

Mh, und damit schließt sich wieder der Kreis. :wink:


^ steht für den Anfang einer Zeile
Zum Vergrößern anklicken....
Kann man hierfür nicht irgendwie einen entsprechende Hexwert für das Zeichen einsetzen oder sonstwie auflösen?
In der API steht bspw: " A next-line character ('\u0085')" ... gibts für das '^' nicht auch solch eine Notation? Was ist das überhaupt für eine Notation?
 
magic_halli hat gesagt.:
Code: 
str = str.replaceAll("(^)(du|da)(^)", "$1TTT$3");
ist meine Syntax falsch?
Zum Vergrößern anklicken....
Wenn du auf das Zeichen '^' vergleichen willst, musst du ein "\\^" in dein Pattern einbauen. Einen "\" benötigst du, um im regulären Ausdruck (also völlig unabhängig von Java) das ^ zu "escapen" (ihm die Sonderzeichenbedeutung zu nehmen) und zwei "\\" müssen es sein, weil Java an sich schon einen "\" als Escape-Zeichen verwendet und diesen dann bei der Auflösung des Patterns herausfiltern würde.
 
Code: 
String str = "---^du^--du-";
str = str.replaceAll("(\\^)(du|da)(\\^)", "$1TTT$3");
Ausgabe:
Code: 
---^TTT^--du-
Jawohl, so klappt das schonmal :wink:

So, na und nun weiter im Programm...
 
So, ich mal wieder 😳

Also irgendwie haben diese RegEx es ganz schön in sich!!!
Folgendes habe ich gemacht:
Code: 
String eingabe = "sigma_v=sqrt(sigma(sigma)^2+3*tau^2)";
eingabe = eingabe.replaceAll("(\\( | \\^ | \\))(sigma)[^_a-zA-Z0-9](\\^ | \\( | \\))", "$1XXX$3");
System.out.println(eingabe);
Ausgabe: sigma_v=sqrt(sigma(sigma)^2+3*tau^2) (also gar nix ersetzt!)

Vielleicht kann mir doch mal jemand für meine Vorstellung helfen, wie es syntaktisch aussehen muss?!
Es soll nur mein sigma ersetzt werden und alle direkt davor und danach angrenzenden Zeichen sollen nicht verändert werden (Klammern, ^ und dann später noch Rechenzeichen). Weiterhin soll auch nur dann ersetzt werden, wenn das nächste Zeichen, welches nach sigma kommt, kein'_', Zahl oder Buchstabe ist.

Ich habe jetzt schon tausende Kombinationen versucht und es kommen immer irgendwelche Ergebnisse heraus, aber keines ist korrekt. Ich bin hier echt langsam am durchdrehen... wieso will das nicht?! :bahnhof: :bahnhof: :bahnhof:
 
magic_halli hat gesagt.:
Code: 
eingabe = eingabe.replaceAll("(\\( | \\^ | \\))(sigma)[^_a-zA-Z0-9](\\^ | \\( | \\))", "$1XXX$3");
Zum Vergrößern anklicken....
Leerzeichen sind ja immer ganz gut für die Übersicht, aber in einem regulären Ausdruck haben sie nichts zu suchen - AUSSER, wenn du wirklich mit einem Leerzeichen vergleichen willst. Denke immer daran: der reguläre Ausdruck ist eine exakte Repräsentation deines/r Strings, bloß in einer "Formel-Sprache" (ein anderer Begriff fällt mir jetzt nicht ein ;-) ).

Richtig wäre also (ohne jetzt alles im Einzelnen geprüft zu haben)
Code: 
eingabe = eingabe.replaceAll("(\\(|\\^|\\))(sigma)[^_a-zA-Z0-9](\\^|\\(|\\))", "$1XXX$3");
 
Vorsicht mit den Leerzeichen, die zählen auch
\\( |
heißt: (Klammer und Leerzeichen) oder was anderes

an Stelle der | oder verwende doch [] zur Auflistung von Alternativen
Code: 
public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        String eingabe = "sigma_v=sqrt(sigma(sigma)^2+3*tau^2)"; 
        String part1 = "[\\(\\^\\)]";
        eingabe = eingabe.replaceAll("("+part1+")(sigma)([^a-zA-Z0-9]"+part1+")", "$1XXX$3"); 
        System.out.println(eingabe); 
    }
}

bedenke aber, dass bei
(sigma)^2
die ) schon als [^_a-zA-Z0-9] zählt, nicht als der Teil dahinter (part1),
das funktioniert also nur weil hinter ) noch ein ^ folgt

für das zweite sigma im String funktioniert das also nicht,

---------

wenn man das Pattern verkleinert auf
Code: 
eingabe = eingabe.replaceAll("("+part1+")(sigma)([^a-zA-Z0-9])", "$1XXX$3");
so wird nun zwar das zweite sigma ersetzt, aber das dritte nicht mehr,
ich nehme an, weil der Buchstabe zwischen zweiten und dritten sigma für das zweite sigma verwendet wurde und nicht mehr zur Verfügung steht,
was man da nun normalerweise tun könnte weiß ich auch nicht mehr,

generell könnte man sich überlegen, für welche Zeichen dies zutrifft,
und diese Zeichen vor dem ersetzen verdoppeln:

Code: 
public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        String eingabe = "sigma_v=sqrt(sigma(sigma)+3*tau^2)";
        String part1 = "[\\(\\^\\)]";


        eingabe = eingabe.replaceAll("(" + part1 + ")", "$1$1");
        System.out.println(eingabe);
        eingabe = eingabe.replaceAll("(" + part1 + ")(sigma)([^a-zA-Z0-9])", "$1XXX$3");
        System.out.println(eingabe);

        eingabe = eingabe.replaceAll("(" + part1 + "){2}", "$1");
        System.out.println(eingabe);
    }
}
das verdoppeln geht gut, beim zurückkürzen bin ich mir mit meinem Pattern nicht so sicher,
notfalls per Hand
eingabe = eingabe.replaceAll("\\(\\(", "\\(");
eingabe = eingabe.replaceAll("\\)\\)", "\\)");
usw.

wobei das ganze Verfahren (das Verdoppeln) nicht gerade schön ist 😉
 
Vielen Dank erstmal für euer Bemühen! :applaus:

bedenke aber, dass bei
(sigma)^2
die ) schon als [^_a-zA-Z0-9] zählt,
Zum Vergrößern anklicken....
Allerdings fällt doch die Klammer ) eigentlich gar nicht in das Muster rein?!
Omg, ich hasse RegEx... da bin ich mir sicher! :roll:

Ich merke schon, es ist wahrscheinlich gar nicht möglich, einen allgemeinen Algorithmus zu entwerfen, der sämtliche Eventualitäten für einen Eingabestring abdenken kann, oder?
 
> Allerdings fällt doch die Klammer ) eigentlich gar nicht in das Muster rein?!

wieso nicht?
was ist denn das Muster, warum sollte es nicht ) beeinhalten?

> Ich merke schon, es ist wahrscheinlich gar nicht möglich, einen allgemeinen Algorithmus zu entwerfen, der sämtliche Eventualitäten für einen Eingabestring abdenken kann, oder?

solange du nicht alle nennst ist das schwer zu sagen
 
solange du nicht alle nennst ist das schwer zu sagen
Zum Vergrößern anklicken....
Tja, wie Du sicher gemerkt hast, handelt es sich um eine Formel. Diese Formel kommt aus einem Textfile, in dem ich zeilenweise diesen RegEx anwenden will, um darin enthaltene Worte durch konkrete Zahlenwerte zu ersetzen.
Die Formeln können hierbei alle möglichen sein, denn dieses File kommt aus einem techn. Konstruktionsprogramm und da können teilweise auch krasse Dinger dabei sein. Das weiß ich aber als Programmierer vorher leider nicht! :cry:

Dein Mechanismus mit dem Verdoppeln funktioniert aber erstmal - ich habe in part1 noch weitere Zeichen aufgenommen - sieht bis jetzt gut aus. :applaus:
 
magic_halli hat gesagt.:
Diese Formel kommt aus einem Textfile
Zum Vergrößern anklicken....
Wie du in einem anderen Beitrag schreibst, wird die einzulesende Textdatei mehrfach durchlaufen und immer das, was schon ausgerechnet ist, durch seinen Zahlenwert ersetzt. Das läuft nun so lange, bis nichts mehr zu ersetzen ist, sehe ich das richtig?

Damit das funktioniert, musst du ja ohnehin die Textdatei immer wieder schreiben. Hier nochmal dein Beispiel aus o.g Thread:

Code: 
sigma = (1.0/5.0 + 2.0/6.0 + 10.0/4.0) 
tau = (3.0/7.0 + 8.0/4.0 + 9.0/4.0) 
sigma_v=sqrt(sigma^2+3*tau^2) 
s_b=4.0/sigma_v 
s_bv=6.0/sigma_v

Du könntest jetzt beim allerersten Einlesen der Datei eine Ersetzungstabelle, z.B. ein Hashtable erzeugen, in dem du jedem String der Eingabedatei einen eindeutigen String für die Ausgabedatei zuordnest

Code: 
Hashtable<String, String> referenz = new Hashtable<String, String>();
// Code, um die Strings zu ermitteln, nachfolgend mal eine manuelle Abkürzung
int unique = 0;
String key = "sigma";
String value = "var" + unique;
referenz.put(key, value);
unique++;

Vor dem .put(...) musst du natürlich erstmal überprüfen, ob genau dieser String schon enthalten ist. Um jetzt deine key-Werte zu erhalten, musst du natürlich auch weiterhin irgendwelche Annahmen treffen, welche Zeichen solch ein key haben darf, also z.B. a-z, A-Z, 0-9, _ - Wenn du davon ausgehtst, dass jede Zeile mit einem key anfängt, verarbeitest du einfach(?) zeichenweise deine Eingabezeilen vom Zeilenanfang bis zum ersten Zeichen, das nicht zum erlaubten Zeichenvorrat gehört. Das kommt dann in den/die(?) Hashtable und wird auch gleich an Ort und Stelle ersetzt - aber NUR an dieser einen Stelle.

Weiter geht's: weitere Zeichen werden eingelesen und irgendwann triffst du wieder auf ein für einen key erlaubtes Zeichen. Vermutlich ist auch die Einschränkung erlaubt, dass ein key mit einem Buchstaben beginnt - sonst wird's irgendwann tatsächlich völlig unmöglich.

Jeder gefundene key wird auf Vorhandensein im Hash überprüft und ggf. sofort ersetzt - wieder nur an dieser einen Stelle, denn dann hast du Anfangs- und Endindex innerhalb der Zeile.

Wenn das so funktionieren sollte (ist nur theoretisch überlegt), benötigst du nicht einmal reguläre Ausdrücke - obwohl es auf gar keinen Fall verkehrt ist, die Grundzüge zu kennen ;-)
 
@fehlerfinder:
Vielen Dank für den Vorschlag... ich werde ihn mir mal gründlich zu Gemühte führen! :###

@SlaterB:
Ich bin nochmals an Deinem RegEx-Mechanismus dran:
Code: 
String eingabe = "sigma_v=sqrt(sigma(sigma)+3*tau^2)";
String part1 = "[\\(\\^\\)]";

//1.
eingabe = eingabe.replaceAll("(" + part1 + ")", "$1$1");
System.out.println(eingabe);
//2.
eingabe = eingabe.replaceAll("(" + part1 + ")(sigma)([^a-zA-Z0-9])", "$1XXX$3");
System.out.println(eingabe);
//3.
eingabe = eingabe.replaceAll("(" + part1 + "){2}", "$1");
Zum Vergrößern anklicken....
Es klappt zwar erstmal, doch je öfter ich mir den Code anschaue, umso unklarer wird mir das Prinzip - bezüglich der Syntax.
Kann mir mal jemand zu 1., 2. und 3. in Worten sagen, was passiert?! Mir ist irgendwie die syntaktische schreibweise nich so ganz einleuchtend, vor allem bezüglich 'part1'. 😳


Gruß
 
part 1 ist nur di Menge der Zeichen, steht nur in einer Variablen, um sie nicht imer wieder zu tippen
(Tippfehler, eine Stelle vergessen, mühsam vergleichen usw.)

1 sucht ein derartiges Zeichen und schreibt es zweimal zurück

3. sucht zwei solche Zeichen und schreibt das erste davon zurück,
da sicher ist, dass jeweils zwei hintereinander kommen, kann es keine Probleme geben,
allgemein würde aber auch (^ zu ( gekürzt werden

was 2. macht wiederhole ich nicht..
 
Aaaah, alles klar. Danke. So hatte ich mir das auch gedacht (weil ja so besprochen), aber die Syntax hat mich zeitweilig verwirrt. :roll:

Eine Sache habe ich noch als Frage, wo ich nun bereits ne Weile grübel...
Ich bekomme es nicht hin, auch das Wort (sigma) links vom '=' zu ersetzen. Ausgangspunkt ist hierbei wieder SlaterB´s Code mit folgendem eingabe-STring:
Code: 
String eingabe = "sigma=sqrt(sigma(sigma)+3*tau^2)";
String part1 = "[\\(\\^\\)]";

eingabe = eingabe.replaceAll("(" + part1 + ")", "$1$1");
System.out.println(eingabe);

eingabe = eingabe.replaceAll("(" + part1 + ")(sigma)([^a-zA-Z0-9])", "$1XXX$3");
System.out.println(eingabe);

eingabe = eingabe.replaceAll("(" + part1 + "){2}", "$1");
System.out.println(eingabe);


Ich hab schon wieder die wildesten Modifikationen gemacht, aber nichts fruchtet. Ersetzt werden jedoch immer nur die sigma in der Gleichung, jedoch nicht vorm '='!


PS: Mir ist klar, dass die Formel Null Sinn ergibt, aber es geht hier um´s Prinzip.
 
welche Modifikationen hast du denn konkret gemacht?
ich sehe weder, wie du den Zeilenanfang noch das =-Zeichen miteinbeziehst,
sind doch einfache Schritte

Code: 
public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        String eingabe = "sigma=sqrt(sigma(sigma)+3*tau^2)"; 
        String part1 = "[\\(\\^\\)=]"; 

        eingabe = eingabe.replaceAll("(" + part1 + ")", "$1$1"); 
        System.out.println(eingabe); 

        eingabe = eingabe.replaceAll("(^|"+part1+")(sigma)([^a-zA-Z0-9])", "$1XXX$3"); 
        System.out.println(eingabe); 

        eingabe = eingabe.replaceAll("(" + part1 + "){2}", "$1"); 
        System.out.println(eingabe); 

    }
}
 
...ich habe mal hier, mal da was probiert, doch so hatte ich es nicht gemacht: ( ^| eingefügt )
Code: 
eingabe = eingabe.replaceAll("(^|"+part1+")(sigma)([^a-zA-Z0-9])", "$1XXX$3");

Danke.
 
Nach einiger Zeit bin ich nochmal mit dem Thema "im String ersetzen" beschäftigt. Der Code, der hier in dem Post herausgearbeitet wurde, um mein ursprüngliches Problem zu lösen (ersetzen von bestimmten Teilstrings rechts vom Gleichheitszeichen in einem String, welcher eine math.Formel darstellt) funktioniert erstmal prima!
So sieht er aus:
Code: 
String eingabe = "sigma=sigma_v/sigma_v+2*3/4-5^6";
String part1 = "[\\(\\^\\)\\*\\ \\/\\+\\-\\=\\>\\<]";

eingabe = eingabe.replaceAll("(" + part1 + ")", "$1$1");
System.out.println(eingabe);
eingabe = eingabe.replaceAll("(^|" + part1 + ")(sigma_v)([^_a-zA-Z0-9=]|$)", "$1XXX$3");
System.out.println(eingabe);
eingabe = eingabe.replaceAll("(" + part1 + "){2}", "$1");
System.out.println(eingabe);

Diesen Code wollte ich nun so umschreiben, damit in einem String, der einen math. Vergleich darstellt, z.B.:
sigma_v>5 oder
sigma_v<5 oder
sigma_v=5 oder
sigma_v!=5 oder
sigma_v>=5 oder
sigma_v<=5
NUR die linke Seite von den Vergleichsoperatoren, also hier sigma_v, durch einen bestimmten Wert ersetzt wird!
Ich bastel nun bereits ne Stunde hier dran rum, ohne jedoch das gewünschte Ergebnis zu erhalten. Immer passiert etwas anderes, aber meinem Ziel komme ich einfach nicht näher. :cry:
Dieser Code scheint schon erstmal halbwegs für die "neuen" Eingabestrings zu funktionieren, doch wenn der Eingabestring 'sigma_v=5' lautet, wird sigma_v einfach nicht ersetzt!!!
Kann mir bitte bitte jemand mal dabei zur Hand gehen, damit von solch einem String nur die linke Seite vom Vergleichsoperator ersetzt wird.

Vielen Dank.


PS: Ich mag RegExp nicht wirklich und tu mir hierbei immer wieder schwer - vor allem die Syntax präge ich mir nicht so recht ein - bin jedoch gewillt das endlich mal richtig zu raffen! :wink:
 
Code: 
public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        String eingabe = "sigma_v>=";
        String gleichung = "(\\=|!\\=|\\<|\\>)";
        eingabe = eingabe.replaceAll("sigma_v" + gleichung, "DDD$1");
        System.out.println(eingabe);
    }
}
 
das ist ja auch nur die erste Mini-Version aus deiner ungenauen Beschreibung,
gleich wirst du wieder mit 'aber bei ..' kommen..
 
Status
Nicht offen für weitere Antworten.

Aktuelle Jobs

Neue Themen

Ähnliche Themen

$ in String ersetzen fürs nochmalige ersetzen.. (JavaBug?)
Antworten: 7
Textdatei öffnen, String suchen, String ersetzen ?????????
Antworten: 6
char in String suchen und durch anderen String ersetzen
Antworten: 2
Datei öffnen und String durch einen anderen String ersetzen.
Antworten: 15
Textzeilen nach 2 Wörtern untersuchen wenn vorhanden Zeile in neuen Text ausgeben wenn nicht löschen
Antworten: 10

Zurück
Oben