Java Regex Pattern gesucht (100,100,100...)

[privacy]

Hallo zusammen.

Ich suche einen RegEx Pattern für Java der nach folgendem Pattern checkt:

Zahl Komma Zahl Komma usw.

Ein Beispiel wäre:

100,100,100

Außerdem muss mindestens eine Zahl vorhanden sein.

Habe verschiedene Dinge versucht aber nichts hat hingehauen. Naja ich würde mich freuen wenn mir hier ein paar Pattern Experten helfen könnten.

Vielen Dank schon mal.

Viele Grüße

 

[$LeEP]

Hi,

ich glaube Regular Expressions sind an der Stelle problematisch, weil du müsstest ja für jeden Fall ein eigenes Pattern bereitstellen. also eines für Zahl,Zahl; eines für Zahl,Zahl,Zahl; eines für Zahl,Zahl,Zahl,Zahl; etc...

wärs nicht einfacher du durchsuchst den String der die Zahlen und Kommas enthält Zeichen für Zeichen bis du wieder ein Komma findest, und extrahierst dir da die einzelnen Zahlen raus?

 

[Anub1s]

Experte würde ich mich jetzt nicht nennen, aber so spontan:

[0-9]+(,[0-9]+)*

Ob die Syntax jetzt so stimmt kann ich nicht genau sagen, aber von der Idee her: eine Ziffer beliebig oft (mindestens eine), danach beliebig oft ein Komma und wieder Ziffern.

 

[privacy]

Danke schonmal. Den letzt genannten Pattern hatte ich schon versucht und er funktionierte leider nicht.

@Slep:
Naja ich möchte ja testen ob der String fehlerfrei ist. Das auseinanderbasteln geht natürlich mit split() leichter.

 

[Zonk!]

Hey, suchst du nach sowas?

public static void main(String[] args) {
String kette = "123,100,099";
StringTokenizer st = new StringTokenizer(kette, ",");
String[] result = new String[st.countTokens()];
int i = 0;

while (st.hasMoreTokens()) {
result = st.nextToken();
if(result.equals("100")){
System.out.println("bingo");
}
i++;
}
}

Gruß

 

[Ack der III]

Ich bin auch kein Experte, aber wie sieht es damit aus:

^([0-9]+,)*[0-9]+$

Ist im Grunde das wie von Anub1s nur umgedreht und dazu noch Anfang und Ende als fest definiert.

 

[Joker86]

Hi,

ich würde an deiner Stelle das Problem etwas anders angehen.
Teste doch ob im String ein Fehler drin ist und nicht ob er fehlerfrei ist. Dazu musst du dir natürlich erstmal überlegen welche Fehler sich da einschleichen könnten aber ich glaube das Abfragen wird dadurch einfacher.

Zusätzlich hast du dann im Fehlerfall gleich schon eine klare Fehlerursache bzw. Fehlermeldung

 

[ag3nt]

Hallo,

also wenn >> [0-9]+(,[0-9]+)* << bei dir nicht funktioniert hat, dann bitte ich dich mal dein Problem etwas genauer zu beschreiben! Weil der Ausdruck ist nunmal absolut korrekt, wie du dich auch an einem Beispiel selbst überzeugen kannst:

public class Main {
    public static void main(String[] args) {
        System.out.println(
            "11,011,2211413,22331".matches("[0-9]+(,[0-9]+)*") 
        );
    }
}

 

[privacy]

Naja aber wenn ich "100,ff" durchlaufen lasse geht der Test auch durch. Also naja ich kann nur das sagen was ich hier sehe.

So teste ich:

    public static boolean checkPattern(String input, String regex){
    	boolean status = false;
    	String search = input;
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(search);
        status = matcher.find();
    	
    	return status;
    }

Hier bekomme ich für die Strings "100,100,100" als auch "100,ff,100" true zurück. Zweiteren möchte ich aber gefiltert haben.

 

[ag3nt]

Tschuldigung aber das ist so auch schlicht falsch!
Du prüfst einfach nur ob deine Eingabe "input" in irgendeiner Form dem gesuchten ausdruck entspricht, und das tut sie ja auch.

Wenn du dir die Dokumentation zu find ansiehst stellst du fest, dass dieses Verhalten auch so korrekt ist.
Das was du eigentlich willst ist aber ein kompletter vergleich den dir matches liefert.

Btw, das was du machst geht auch erheblich einfacher so:

    public static boolean checkPattern(String input, String regex){
    	return input.matches(regex);
    }

 

[BerniG]

Das ist zwar einfacher, aber nicht generell besser. Bei der etwas umständlicheren Lösung kann man nämlich die kompilierte pattern-Variable cachen. Das kann die Performance starkt erhöhen wenn man dasselbe Regex öfters nutzt. Siehe http://www.javalobby.org/forums/thread.jspa?threadID=16822&tstart=0

 

[privacy]

Ok Danke. Dann habe ich mich mit find() vertan. Vielen Dank für die Hilfe.

 

[ag3nt]

Das ist prinzipiell korrekt mit der erhöhten Performance (steht wie immer auch in der Java-API), allerdings darf man da auch die Verhältnismäßigkeit nicht vergessen. Um wirklich von einer erhöhten Performance sprechen zu können müssen sekündlich schon einige Überprüfungen durchgeführt werden. Und in der Vorgegebenen Form war das ohnehin nicht gewährleitstet. Abgesehen davon gings dem Threadersteller in seiner Frage nicht um Effizenz Da wäre es dann sinnvoller einen Patternmatcher als Klassenattribut zu verwalten, nur dann sind wir endgültig OT