# Prüfen ob String eine Zahl mit maximal 2 Nachkommastellen ist



## OhNo (31. Jan 2013)

Hallo zusammen, 

ich habe eigentlich ein einfaches Problem. Ich habe einen String der eine Zahl repräsentiert. Dieser kann tausender Trennzeichen und ein Dezimaltrennzeichen haben. 
Wie kann ich nun abprüfen ob der String eine Zahl ist und höchstens 2 Nachkommastellen hat?

z.b. 
1000 -> true
1000,0 -> true
1000,00 -> true
1.000,11 -> true
1.000.000,22 -> true
1.000.000.000,33 -> true


1,555 -> false
1.000,55555 -> false
10.00,88 -> false

Ich hab schon versucht zu googeln mit DecimalFormat etc. rumgespielt aber ich bekomme es nicht hin. Bin für jeden Tip dankbar.

Grüße
OhNo


----------



## Bernd Hohmann (31. Jan 2013)

Für die Nachkommastellen alleine:


```
boolean blnValid = strNum.length() - strNum.indexOf(",") < 4 || strNum.indexOf(",") == -1;
```

Ob der String eine Zahl mit der richtigen 1000er Gruppierung ist, wird so oder so ein Problem. Klassisch würde ich nach obiger Prüfung eine Schleife über den String machen und den erstmal auf 0-9 und "," "." prüfen wobei "," entweder nur 1x oder garnicht vorkommen darf. DIe 1000er gruppierung würde ich mit indexOf(char) und indexOf(char, fromindex) so prüfen dass der Abstand genau 3 ist.

Du kannst es natürlich auch über NumberFormat lösen (Zahl parsen lassen und neu aufbereiten, danach schauen ob die Strings identisch sind).  Dazu musst Du aber den Ursprungsstring erstmal erweitern: ist kein "," vorhanden, "," anhängen. Danach solange "0" anhängen bist 2 NKS erreicht sind.


```
String strNum = "1.2.34,56";

		if (strNum.indexOf(',') == -1) strNum += ",";
		while (strNum.length() - strNum.indexOf(',') < 3)
			strNum += "0";

		NumberFormat nf = DecimalFormat.getNumberInstance();
		Number numIn = nf.parse(strNum);

		nf.setMinimumFractionDigits(2);
		nf.setMaximumFractionDigits(2);
		nf.setGroupingUsed(true);

		String strOut = nf.format(numIn.doubleValue());

		System.out.println(strOut.equals(strNum));
```

Mit der Routine erschlägst Du auch das Problem mit der Prüfung auf 2 Nachkommastellen.

Vorsicht mit Locale: andere Länder formatieren 1,234.56 !

Bernd


----------



## DrZoidberg (31. Jan 2013)

Du kannst auch regex verwenden.

```
String str = "123.342.211,23";
Pattern p = Pattern.compile("\\d{1,3}(\\.\\d{3})*(,\\d{2})?\\z");
Matcher m = p.matcher(str);
boolean isNumber = m.find();
System.out.println(isNumber);
double number = 0;
if(isNumber) number = Double.parseDouble(str.replace(".","").replace(",","."));
System.out.println(number);
```


----------



## Crian (31. Jan 2013)

Das müsste noch leicht angepasst werden, damit auch Zahlen mit nur einer oder gar keiner Nachkommastelle gefunden werden. Desweiteren scheinen die Tausenderpunkte optional zu sein.


----------



## anti-held (31. Jan 2013)

hier eine Lösung...
könnte aber noch Bugs enthalten.



Spoiler: Code





```
private static boolean isSuitableNumber(String string) {
		System.out.print(string + " ");
		char[] array = string.toCharArray();
		boolean isCommaAppeared = false;
		boolean isPointAllowed = false;
		int commaIndex = 0;
		for (int i = array.length - 1; i >= 0; i--) {
			if (isCommaAppeared) {
				if((commaIndex == 0 ? array.length : commaIndex) - 4 == i && array[i] == '.'){
					isPointAllowed = true;
				}
				if (array[i] >= '0' && array[i] < '9') {
					continue;
				} else if (array[i] == '.' && isPointAllowed) {
					if (((commaIndex == 0 ? array.length : commaIndex) - i) % 4 != 0) {
						return false;
					}
				} else {
					return false;
				}
			} else {
				if (array[i] == ',') {
					isCommaAppeared = true;
					commaIndex = i;
					continue;
				}
				if (i < array.length - 2) {
					isCommaAppeared = true;
					i++;
					continue;
				}
				if (!(array[i] >= '0' && array[i] < '9')) {
					return false;
				}
			}
		}
		return true;
	}
```


----------

