Probleme bei Regex

[Caliburns]

Hallo,

ich habe ein großes Problem bezüglich einem regulärem Ausdruck.

Ich habe einen String, z.b.

String str = 5i7i;

Diesen möchte ich nun mit Regex überprüfen, ob er mehr als ein i enthält.

Pattern patternOrders = Pattern.compile("(i){1}");
Matcher matcherOrders = patternOrders.matcher(str);

Anschließen soll eine if-Anweisung kommen, dass wenn nur ein i enthalten ist, etwas ausgeführt werden soll.

if (matcherOrders.find()) {
...
}

Ich habe etwas rumprobiert, meiner Ansicht nach muss der Fehler beim Regex oben liegen. Denn die Methode in der if-Anweisung wird immer durchgeführt, egal wie viele i enthalten sind. Offenbar greift der Regex-Ausdruck nicht. Habe ich einen Denkfehler irgendwo? Ist die Syntax korrekt?
(Die Methode wird nur in der If-Anweisung angesprochen, sonst nirgens.)



Danke und Viele Grüße

 

[httpdigest]

Die Frage: "Gibt es höchstens ein Zeichen 'X' irgendwo in einem gegebenen String?" ist mit regulären Ausdrücken sehr schwer zu beantworten. Hierfür würde man negative forward lookaheads verwenden.
Das Problem würde ich nicht mit regulären Ausdrücken lösen, sondern einfach mit dem Zählen der 'i' Zeichen im String. Einfach eine Schleife über die characters und vergleichen und zählen.
Das Pattern "i{1}" (übrigens exakt gleichbedeutend mit dem Pattern "i") matched, weil es ja im String "5i7i" eine Folge von genau einem hintereinanderhängenden "i" gibt. Das Pattern matched sogar zweimal.

 

[mihe7]

import java.util.regex.*;

public class RegexTest {
    public static void main(String[] args) {
        Object[][] tests = {
            {"", false},
            {"i", false}, {"ii", true}, 
            {"1i", false}, {"i1", false},
            {"i1i", true}, {"1ii", true}, {"ii1", true}, {"22i", false},
            {"Xylophon", false}, {"Mississippi", true}
        };

        Pattern patternOrders = Pattern.compile(".*i.*i.*");
        // oder allgemeiner: Pattern patternOrders = Pattern.compile(".*(i.*){2,}");

        for (Object[] test : tests) {
            String str = (String) test[0];
            Matcher matcherOrders = patternOrders.matcher(str);
            boolean expected = (boolean) test[1];   
            boolean actual = matcherOrders.matches();

            if (expected != actual) {
                System.out.printf("Matching against '%s' returned %s, but %s was expected\n",
                        str, Boolean.toString(actual), Boolean.toString(expected));
            } else {
                System.out.printf("%s: ok\n", str);
            }
        }
    }
}

 

[httpdigest]

...oder natürlich man dreht den Match einfach um. 🙂

 

[Caliburns]

Ich habe die Variante mit dem Zählen genommen 🙂
Hat super funktioniert.

 

[Caliburns]

Habe allerdings noch eine kurze Frage zur Regex, ich hoffe ich kann die noch hier dazuschreiben.
Ich möchte einen String z.B. der Struktur (2 + 4) + (4 + 9) auf die Zeichenfolge ) + ( untersuchen. Wenn diese mindestens einmal vorkommt, soll etwas ausgeführt werden.

Für +,*,- hab ich es hinbekommen mit der Struktur: ".*\\) \\+ \\(.*" usw.

Mein Problem liegt bei der Division, dargestellt durch \

Wenn ich diese Struktur: ".*\\) \ \\(.*" nehme meldet mir Eclpise einen Fehler... Die Struktur ".*\\) \\\ \\(.*" mit zwei Backslashes ist doch nicht mehr notwendig oder? (Bekomme allerdings auch da einen Fehler angezeigt)

Wie könnte ich denn dies lösen?



Danke und Viele Grüße

 

[mihe7]

\\\\

Nachtrag: statt \\\ musst Du \\\\ verwenden.

 

[Caliburns]

Hat super geklappt, danke dir!

Wie sieht es den aus, wenn ich die Zeichenfolge [(2 + 4) + (4 + 9)] * (2 + 9) neben den oben genannten Operatoren, noch auf die Klammern "[" und "]" untersuchen will?

[-+*/\\[] ?\\(|(?<=\\))\\]

Diese Struktur gibt mir zwar alles aus aber die schließende eckige Klammer wird zusammen mit dem * dargestellt...

[
+
]*

Wie könnte ich den Ausdruck abändern, dass diese Form entsteht?

[
+
*
]


Danke

 

[mihe7]

Wenn aus [(2 + 4) + (4 + 9)] * (2 + 9) plötzlich [+*] wird, dann wäre das sehr seltsam.

 

[Xyz1]

neben den oben genannten Operatoren, noch auf die Klammern "[" und "]" untersuchen will?

Dann brauchst Du einen Rangierbahnhof.