# RegEx _ und 0-9



## 127.0.0.1 (9. Mai 2012)

Hi Leute,

nur ne kurze Frage:

Will prüfen ob ein String einen *unterstrich *und dann dannach *eine beliebige Zahl enthält*
Mach ich mit RegEx, is klar ^^


```
if(line.contains("_[0-9]")){

System.out.println("Gefunden !");

}
```

Meine Frage:

*Wie muss ich die RegEx für java quoten ??*

```
_[0-9]
```

mfg


----------



## Gast2 (9. Mai 2012)

Nein, musst du nicht escapen. contains erwartet nur keinen Regex 

Dafür musst du nen Matcher verwenden.


----------



## 127.0.0.1 (9. Mai 2012)

aber 

```
if(line.matches("_[0-9]")){
}
```

gibt mir einen boolean Wert zurück -.-
Will ja nen String ^^


----------



## faetzminator (9. Mai 2012)

Willst du nun wissen, *ob* das vorkommt, oder *was* vorkommt?
Verwende einfach einen Matcher, welcher mit [c]find()[/c] die jeweiligen Vorkommnisse findet, falls nötig.


----------



## Gast2 (9. Mai 2012)

EikeB hat gesagt.:
			
		

> Dafür musst du nen Matcher verwenden.


Matcher (Java 2 Platform SE 5.0)


----------



## timbeau (9. Mai 2012)

Was willst du für nen String? Eine Methode die  containswrapped und bei contains = true ein "Gefunden" zurückgibt? 

Manchmal hat man Denkblockaden, sowas ist doch kein Problem für dich 


```
private String wrapContains(String toCheck){
		if(toCheck.matches("_[0-9]+")){
			return "Gefunden!";
		}
		else return "Moep";
	}
```


----------



## 127.0.0.1 (9. Mai 2012)

jo, Denkblockade glaub ich ^^

Hab den Code:

```
if(line.matches("_[0-9]"))
{
							
System.out.println("Gefunden !");
}
```

aber da findet er nix -.-


----------



## Gast2 (9. Mai 2012)

Ich dachte du willst prüfen ob in deinem String _ oder 0-9 vorkommt?
String#matches prüft ob der String dem Regex entspricht, machs mit nem Matcher und find().


----------



## timbeau (9. Mai 2012)

Naja, das der Regex noch etwas umgebaut werden müsste ist ja klar.

Bei langen String lohnt sich der Matcher bestimmt eher als ein Regex .*?_[0-9]+.*


----------



## 127.0.0.1 (9. Mai 2012)

> Ich dachte du willst prüfen ob in deinem String _ oder 0-9 vorkommt?


Genau das will ich ja auch !


----------



## faetzminator (9. Mai 2012)

Wenn der String selbst nur [c]_[0-9][/c] enthalten soll, dann verwende [c]matches("_[0-9]")[/c], ansonsten [c]matches(".*_[0-9].*")[/c]. Alternative wär [c]Pattern.compile("_[0-9]").matcher(input).find()[/c].


----------



## 127.0.0.1 (9. Mai 2012)

faetzminator hat gesagt.:


> Wenn der String selbst nur [c]_[0-9][/c] enthalten soll, dann verwende [c]matches("_[0-9]")[/c], ansonsten [c]matches(".*_[0-9].*")[/c]. Alternative wär [c]Pattern.compile("_[0-9]").matcher(input).find()[/c].



hab ich ja so gemacht, siehe mein Code weiter oben
aber es funktioniert nicht, warum auch immer ???:L


----------



## timbeau (9. Mai 2012)

Nein hast du nicht gemacht, du willst wissen ob der String _[0-9] enthält und nicht ob der ausschließlich daraus besteht, sonst könnte man ja auch equals nehmen.


----------



## 127.0.0.1 (9. Mai 2012)

ja, das will ich doch auch, verwirrt mich doch nicht so ???:L

Will wissen ob mein String auf "_0-9" endet
also so:

XXXXXXXX_2
oder
YYYYYYY_4


----------



## faetzminator (9. Mai 2012)

Dann sag uns das doch gleich? Oder setz dich selbst ein Bisschen mit Regex auseinander  Zuerst sagtest du "enthält", jetzt "endet"... Wie wärs mit [c]matches(".*_[0-9]")[/c]?


----------



## timbeau (9. Mai 2012)

Faetz sagt dir schon zum 3. Mal den Regex.


```
"_[0-9]+
```
 ist ungleich 
	
	
	
	





```
".*?_[0-9]+.*"
```


----------



## 127.0.0.1 (9. Mai 2012)

Ich sag euch aber auch schon zum 2ten mal das es nicht geht 

Hab folgenden Code stehen:

```
if(line.matches(".*_[0-9]"))
{
System.out.println("Gefunden");

}
```

Aber in der Konsole steht nix....
und der String ist definitiv vorhanden !

Wenn ich schreibe:

```
if(line.contains("_1"))
{
System.out.println("Gefunden");

}
```
dann gehts

In dem File sieht der Text wie folgt aus:

```
966800_1
```


----------



## faetzminator (9. Mai 2012)

Na dann tritt das "_1" aber nicht am Schluss des Strings auf. Denn [c]"adfgafg_1".matches(".*_[0-9]")[/c] -> [c]true[/c] 

Edit: da wirst du sicherlich noch Leerzeichen o.ä. im File haben. Verwende auf jeder Linie zuerst [c]trim()[/c].


----------



## 127.0.0.1 (9. Mai 2012)

faetzminator hat gesagt.:


> Na dann tritt das "_1" aber nicht am Schluss des Strings auf.



doch, hab den String noch editiert gepostet.....aber hier nochmal:

```
966800_1
```


----------



## faetzminator (9. Mai 2012)

Wenn du ein Mal alle Posts gelesen hättest, dann wüsstest du dass
1. [c]matches(".*_[0-9]")[/c] funktioniert
2. [c]contains("_1")[/c] nicht auf das Ende schaut
3. Du im File irgendwo einen Space o.ä. haben musst
4. Dieses Problem mit trim() lösen könntest


----------



## 127.0.0.1 (9. Mai 2012)

hmmm....
1. und 2. hab ich probiert, da muss irgendwo im Code ein anderer Fehler sein, ich such mal
3. Hab ich nicht, schon geschaut, lediglich Trennzeichen in Form eines Doppelpunktes also 
	
	
	
	





```
Bla:966800_1:BlaBla
```


----------



## Gast2 (9. Mai 2012)

Wenn hinter dem _1 noch was kommt, dann matcht die Regex 
	
	
	
	





```
.*_[0-9]
```
 natürlich nicht.
Poste doch einfach mal was für nen String du jetzt wirklich hast (der scheint sicht von Post zu Post ja weiterzuentwickeln) und auf was du den konkret prüfen willst. Das wirds einigen leichter machen dir zu helfen.


----------



## timbeau (9. Mai 2012)

Bitte löschen


----------



## timbeau (9. Mai 2012)

timbeau hat gesagt.:


> Faetz sagt dir schon zum 3. Mal den Regex.
> 
> 
> ```
> ...



und nocheinmal bis es klappt....:noe:


----------



## 127.0.0.1 (9. Mai 2012)

> Wenn hinter dem _1 noch was kommt,


Nee, kommt nix mehr



> Poste doch einfach mal was für nen String du jetzt wirklich hast (der scheint sicht von Post zu Post ja weiterzuentwickeln) und auf was du den konkret prüfen willst.



Der String sieht wiefolgt aus:

```
XXVA234:hierirgendwas:ppqs778-8:Bla:Bla:966800_1:BlaBla:V3
```
--> ich splitte ihn aber auf, Trennzeichen ist ":"

dementsprechend müsste es an dem "966800_1" doch nichts auszusetzen geben oder ?!


----------



## timbeau (9. Mai 2012)

Sorry aber sowas von Tipresistent wie du war hier noch keiner.


```
@Test
	public void regex(){
		String splitted = "966800_1";
		System.out.println(splitted.matches(".*?_[0-9]+"));
	}
```

liefert true. Einfach mal richtig kopieren.


----------



## faetzminator (9. Mai 2012)

Ernsthaft, so darüber zu diskutieren macht überhaupt keinen Sinn. 127.0.0.1, wenn du so überzeugt von dir und anscheinend nicht an unsere Inputs glaubst, warum werden wir überhaupt gefragt?
Entweder kannst du dir den Debugger anschmeissen, oder du gibst jeden zu prüfenden String aus. Und nicht mit [c]System.out.println(foo);[/c], sondern mit [c]System.out.println("\"" + foo + "\"");[/c], damit man zumindest Leerzeichen schon mal erkennt. Kannst das gerne auch hier ins Forum posten.
Und bitte beachte stets: bring uns im Anfangspost möglichst vielen, sinnvollen Input, dann ist das Thema auch nach 2 Antworten geschlossen. Zudem können wir dir präzisere Antworten und mehr Hintergrund liefern.


----------



## 127.0.0.1 (10. Mai 2012)

@timbeau: dass das true zurückgibt hab ich auch bemerkt ^^ wollte damit auch weiterarbeiten, ging aber irgendwie auch nicht

@faetzminator: ich glaub an eure Antworten, deshalb wende ich mich ja auch an euch......aber der Code den ich ausprobiert hab geht nicht........hab immerwieder die Überprüfung gemacht ob er den String überhaupt findet, das ist der Fall, also stimmt was mit der RegEx nicht, schätze ich

Hab am Anfgang nicht allzuviel Input gebracht weil ich dachte es liegt an der RegEx, oder an der if Prüfung

Trotzdem danke an alle,
habs mehr oder weniger gelöst, leider nicht elegand xD
Funktioniert alles, nur diese blöde abfrage auf "_[0-9]" noch nicht



Gruß


----------



## timbeau (10. Mai 2012)

"Ging irgendwie nicht" ist keine Fehlermeldung...

und den Code den du ausporbierst solltest du vielleicht nächstes mal zeigen wenn du Hilfe benötigst. 

Ich bin raus :autsch:


----------



## 127.0.0.1 (10. Mai 2012)

> "Ging irgendwie nicht" ist keine Fehlermeldung...



kommt keine Fehlermeldung, sondern einfach nix
Der String ist vorhanden, er läuft aber nicht in die if Abfrage rein

Ich hab da ja ein Syso stehen, aber das gibt er mir (wenn ich RegEx benutze) nicht aus, nur wenn ich direkt nach "_1" suche


----------



## timbeau (10. Mai 2012)

Kaum zu glauben aber es gibt die Möglichkeit Quellcode zu posten.


----------



## 127.0.0.1 (10. Mai 2012)

```
if(line.contains("_1"))
{
System.out.println("Gefunden");
String p[] = line.split(":");
line=set_colum(11, new StringBuffer(line), ":", p[11].substring(0, 6)).toString();
}
```

*--> So funktionierts definitiv*


----------



## diggaa1984 (10. Mai 2012)

poste doch mal wies nicht geht, mit regEx

außerdem ist es ein Unterschied für den Aufbau des RegEx ob du vor oder nach der Abfrage splittest!


----------



## 127.0.0.1 (10. Mai 2012)

faetzminator hat gesagt.:


> Wenn der String selbst nur [c]_[0-9][/c] enthalten soll, dann verwende [c]matches("_[0-9]")[/c], ansonsten [c]matches(".*_[0-9].*")[/c]. Alternative wär [c]Pattern.compile("_[0-9]").matcher(input).find()[/c].



das geht nicht ^^

In meinem Code:

```
if(line.matches("_[0-9]"))
{                          
System.out.println("Gefunden");
}
```
Da passiert gar nix, keine Ausgabe in der Konsole, nix


```
if(line.matches(".*_[0-9].*"))
{                          
System.out.println("Gefunden");
}
```
das geht auch nicht


----------



## timbeau (10. Mai 2012)

Und so funktionierts auch definitiv


```
@Test
	public void regex(){
		String line = "966800_2";
		if(line.matches(".*?_[0-9]+.*"))
		{
		System.out.println("Gefunden");
		}
	}
```

Dein Problem ist nicht der Regex und die Line sieht garantiert nicht so aus wie gepostet


----------



## diggaa1984 (10. Mai 2012)

```
public class Test {
	
	public static void main(String[] args) {
		String s = "XXVA234:hierirgendwas:ppqs778-8:Bla:Bla:966800_1:BlaBla:V3";
		if (s.matches(".*_[0-9].*")) // oder auch mit ".*_[0-9]+.*"
			System.out.println("gefunden");
	}
}
```


----------



## faetzminator (10. Mai 2012)

Klar, denn bei [c]"XXVA234:hierirgendwaspqs778-8:Bla:Bla:966800_1:BlaBla:V3"[/c] ist _1 eindeutig nicht am Ende der Linie  Aber natürlich am Ende eines Teiles, welches mit : getrennt wird. Also muss der Regex statt [c]".*_[0-9]"[/c] einfach [c]".*_[0-9]:.*"[/c] lauten. Falls aber der _[0-9] auch ganz am Ende - als letztes Item - gematcht werden muss, kann man den Regex immer noch leicht erweitern: [c]".*_[0-9].*)?"[/c].


----------



## 127.0.0.1 (10. Mai 2012)

oh man......endlich !


```
if(line.matches(".*_[0-9]:.*"))
{
System.out.println("Gefunden");
}
```

*Es geht !*
Dankeschön an alle und an faetzminator für den RegEx Befehl (den ich von Anfang an gesucht hatte)

Gruß


----------



## timbeau (10. Mai 2012)

timbeau hat gesagt.:


> Naja, das der Regex noch etwas umgebaut werden müsste ist ja klar.
> 
> Bei langen String lohnt sich der Matcher bestimmt eher als ein Regex .*?_[0-9]+.*



Ich zitiere mich mal von gestern 12:21....

Wenn bei ":" gesplitted wird, dürfte der Regex mit ":" aber nicht matchen...


----------



## nazar (10. Mai 2012)

Wenn die Regex geht, dann hat deine zerlegte line nicht das von dir beschriebene Format (966800_1).
Schreib vor dem 
	
	
	
	





```
if(line.matches())
```
 noch ein 
	
	
	
	





```
System.out.println(line)
```
 und überprüf nochmal ob du wirklich richtig zerlegt hast. Nicht dass sich dadurch noch weitere Fehler im Programm einschleichen.
Zur weiteren Regexhilfe mal Java Regex Tutorial.


----------



## 127.0.0.1 (10. Mai 2012)

timbeau hat gesagt.:


> Ich zitiere mich mal von gestern 12:21....
> Wenn bei ":" gesplitted wird, dürfte der Regex mit ":" aber nicht matchen...



naja, deshalb frag ich ja hier im Forum nach ^^
Wenn ichs wüsste, hätt ichs ja von Anfang an richtig gemacht 



Wie gesagt, nun gehts, danke


----------



## timbeau (10. Mai 2012)

Hättest du gestern um 12Uhr meinen Post gelesen wärst du 24 Stunden später schon weiter.


----------



## 127.0.0.1 (10. Mai 2012)

man lernt aus Fehlern


----------



## nazar (10. Mai 2012)

So wie es aussieht, hast du noch nicht genug gelernt oder ich bin mal wieder begriffsstutzig. 
Da du ständig die Position vertreten hast, dass der String mit "_1" aufhört, bin ich jetzt verwundert, warum die "_1:x"-Version funktioniert und zufriedenstellend ist.


----------



## 127.0.0.1 (10. Mai 2012)

der String als sochles hört ja auch mit _1 auf........eben nur die "Zeile" nicht
Ich wollte nur dieses einen String rausfiltern (mit Split) und dann überprüfen

Da es nun aber mit der oben genannten RegEx geht kann ich mir das ersparen, oder ?!


----------



## nazar (10. Mai 2012)

Es bedeutet zumindest mal, dass dein Split nicht funktioniert. Solange du diesen aber nicht weiter verwenden musst, sollte dir die jetztige Regex reichen.

Edit: Habe mir nochmal deine ersten Posts durchgelesen. Mit der jetztigen Regex suchst du nichtmehr nur nach einem Unterstrich und einer beliebigen Zahl, sondern 
Zeichen + beliebig viele Zeichen + Unterstrich + Zahl + Doppelpunkt + Zeichen + beliebig viele Zeichen
Von daher liegt die Entscheidung ob es das ist was du willst bei dir. Wenn es nur Unterschrich und Zahl sein soll, mach das was Timbeau geschrieben hat.


----------

