# String Elemente auf Zahlen Überprüfen



## Gerlon (1. Dez 2012)

Guten Tag,

ich versuche mich gerade an einem Programm welches einen String auf Zahlen überprüft und diese dann in ein int Array speichert.
Bisher noch ein paar Probleme und weiß gerade nicht weiter.
Habe erstmal eine Methode zur Überprüfung geschrieben bei einzelnen Zeichen hat es auch funktioniert.
Ich weiß aber nicht ob ich den String noch weiter vereinfachen muss.. oder ob das so mit der Überprüfung Sinn macht.
Hoffe es ist erkennbar was am Ende bei rauskommen soll, in der Ausgabe steht das Ergebnis was ich haben möchte.

Freue mich über jede Hilfe/Denkanstoß 


```
public static boolean isZiffer(char c){
		if (Character.isDigit(c)){
			return true;
		}
		else
		return false;
	}
	public static int[] subString(String s){
		
		char[] chars = s.toCharArray();
		int[] a = new int[chars.length];
		int q = 0;
		for ( int i = 0; i<= chars.length;i++){
		if (isZiffer(chars[i]) == true && chars[i] > 0){
			a[q] = chars[i];
			q++;
		}
		
		
}
		return a;
	}
public static void main(String[] args) {
		String testString = "-5, 20, abc, -20, defg, 45ab67, 23";
		
		System.out.println("Teste \""+testString+"\" mit subString() erwarte: [20,23] bekomme:"+Arrays.toString(subString(testString)));}}
```


----------



## Gerlon (1. Dez 2012)

Gerade bemerkt das so wirklich nur einzelne Zeichen überprüft werden. Wie kann ich das als Element kennzeichnen, irgendwie über die Leerzeichen?
Weil so würde ja jede Zahl gespeichert werden.


----------



## Marco13 (1. Dez 2012)

Etwas mehr Infos zum eigentlichen Ziel wären wohl hilfreich. Du könntest ggf. den String mit

```
StringTokenizer st = new StringTokenizer(s, ",");
while (st.hasMoreTokens())
{
    String t = st.nextToken().trim();
    // prüfe 't'
}
```
an den Kommas aufsplitten und nur die einzelnen Elemente prüfen. Und statt isZiffer kannst du gleich Charakter.isDigit(...) einsetzen.


----------



## Gerlon (1. Dez 2012)

Na ich möchte am Ende diese 2 Zahlen [20,23] in dem Array gespeichert haben.
Und ausgelagert habe ich die isZiffer Methode weil ich die später nocheinmal in anderen Methoden aufrufen wollte.
Sollte sich ja später nicht nur auf das hier beschränken ^^


----------



## Bernd Hohmann (1. Dez 2012)

Die Frage von Marco "was ist das Ziel" hast Du leider nicht beantwortet, denn davon hängt etwas die Antwort ab.

Wenn Du exakt auf 0-9 prüfen willst, ist "Character.isDigit(c)" eher untauglich weil das je nach Unicodeset auch IVLMC (Römische Ziffern) und sonstwas als Digit zurückliefert und für reine 0-9 Prüfung eigentlich Perlen vor die Säue geworfen ist.

Warum "-5" keine gültige Zahl ist, erschliesst sich mir jetzt auch nicht.

Ansonsten wie von Marco vorgeschlagen über einen StringTokenizer und dann den String via Schleife und .charAt(i) >= '0' && <= '9' abfragen.

Bernd


----------



## Spacerat (1. Dez 2012)

Das hier filtert alle Zahlen, auch die 45 und die 67. Allerdings macht's keinen Unterschied zwischen Integern und Flieskomma.

```
import java.io.IOException;
import java.io.Reader;
import java.io.StreamTokenizer;
import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.List;


public class NumberFilter {
	public static void main(String[] args) throws IOException {
		if(args.length == 0) {
			args = new String[] {"-5, 20, abc, -20, defg, 45ab67, 23"};
		}
		final CharBuffer chars = CharBuffer.wrap(args[0].toCharArray());
		Reader r = new Reader() {
			@Override
			public int read(char[] cbuf, int off, int len) throws IOException {
				if(chars.remaining() == 0) {
					return -1;
				}
				len = Math.min(len, chars.remaining());
				chars.get(cbuf, off, len);
				return len;
			}
			
			@Override
			public void close() throws IOException {
				// lol
			}
		};
		List<Double> numbers = new ArrayList<>();
		StreamTokenizer st = new StreamTokenizer(r);
		st.resetSyntax();
		st.parseNumbers();
		int token;
		do {
			token = st.nextToken();
			if(token == StreamTokenizer.TT_NUMBER) {
				numbers.add(st.nval);
			}
		}
		while(token != StreamTokenizer.TT_EOF);
		for(Double d : numbers) {
			System.out.println(d);
		}
	}
}
```


----------



## Bernd Hohmann (1. Dez 2012)

Der heutige Preis für den am meissten verwirrenden Code geht eindeutig an Dich 

Bernd

Obli:


```
import java.util.*;

public class Test {
	public static void main(String[] args) throws Exception {
		String str = "-5, 20, abc, -20, defg, 45ab67, 23";

		ArrayList<Integer> al = new ArrayList<Integer>();
		StringTokenizer strt = new StringTokenizer(str, ",");
		while (strt.hasMoreTokens()) {
			int i = 0;
			try {
				i = Integer.parseInt(strt.nextToken().trim());
			} catch (NumberFormatException e) {
				continue;
			}
			if (i < 0) continue;
			al.add(i);
		}

		for (int i : al) {
			System.out.println(i);
		}

	}
}
```


----------



## Gerlon (1. Dez 2012)

Dann noch einmal das Ziel ist es am Ende alle positiven Zahlen ausgeben zu können. Dachte das wenn ich die 2 gewünschten Zahlen hinschreibe das ersichtlich wäre, mein Fehler..

Werde mal mit dem Stringtokenizer rumprobieren.

Fande den Beitrag von Spacerat nicht hilfreich kann damit bisher noch nicht sonderlich viel anfangen, müsste auch deutlich einfacher gehen. Vorallem mehr auf meine Aufgabe bezogen, wäre schön. Die Methoden die ich hingeschrieben habe, sollen auch so verwendet werden.
Aber trotzdem schon mal Danke für die bisherige Hilfe.

Also in der substring den string übergeben, vereinfachen und umwandeln um in isZiffer() die Parts zu überprüfen. Und das am Ende in ein int[] array speichern und zurück zur main geben!

Hab das jetzt erstmal so angepasst, fehlt jetzt halt noch die richtige Überprüfung und der Ausschluss wenn ein Part nich nur aus einer Zahl besteht.


```
StringTokenizer st = new StringTokenizer(s, ",");
		int[] a = new int[s.length()];
		int q = 0;
		while (st.hasMoreTokens())
		{
		    String t = st.nextToken().trim();
		    char[] chars = t.toCharArray();
		    for (int i = 0; i <= chars.length;i++){
		    	if( isZiffer(chars[i])==true){
		    		a[q] = chars[i];
		    	}
		    	
		    }
		    q++;
		}
```

Wie könnte ich das schreiben das die Bedingung wenn die Zahl gespeichert wird dies nur tut wenn die Zahl > 0 ist ?
Dachte an irgendwas wie chars[i-1] ungleich - oder so aber weiß nicht wie ich das genau ausdrücken soll.


----------



## Bernd Hohmann (1. Dez 2012)

Gerlon hat gesagt.:


> Vorallem mehr auf meine Aufgabe bezogen, wäre schön. Die Methoden die ich hingeschrieben habe, sollen auch so verwendet werden.



Hammwa auch im Programm:


```
import java.util.*;

public class Test {
	public static void main(String[] args) throws Exception {
		String testString = "-5, 20, abc, -20, defg, 45ab67, 23";
		System.out.println("Teste \"" + testString + "\" mit subString() erwarte: [20,23] bekomme:" + Arrays.toString(subString(testString)));

	}

	public static String[] subString(String s) {
		ArrayList<String> al = new ArrayList<String>();
		StringTokenizer strt = new StringTokenizer(s, ",");
		while (strt.hasMoreTokens()) {
			String tmp = strt.nextToken().trim();
			boolean isZ = true;
			for (int i = 0; i < tmp.length(); i++) {
				if (!isZiffer(tmp.charAt(i))) {
					isZ = false;
					break;
				}
			}
			if (isZ) al.add(tmp);
		}

		String str[] = new String[al.size()];
		return al.toArray(str);
	}

	public static boolean isZiffer(char c) {
		if (c < '0') return false;
		if (c > '9') return false;
		return true;
	}
}
```


----------



## Gerlon (1. Dez 2012)

Ok, vielen Dank, das hilft mir doch weiter 
Muss ich nur noch die negativen auschließen und die wo noch  Buchstaben etc. enthalten sind.


----------



## Bernd Hohmann (1. Dez 2012)

Gerlon hat gesagt.:


> Muss ich nur noch die negativen auschließen und die wo noch  Buchstaben etc. enthalten sind.



In beiden meiner Sourcen wird negativ ausgeschlossen.

Im ersten Fall auf explizite Prüfung "i<0", im zweiten Fall dass nur 0-9 zugelassen ist.

Kann es sein, dass Character.isDigit() die Zeichen "+/-" als Digit ansieht?

Bernd


----------



## Spacerat (1. Dez 2012)

Bernd Hohmann hat gesagt.:


> Der heutige Preis für den am meissten verwirrenden Code geht eindeutig an Dich


So verwirrend find' ich den gar nicht. Experimente mit den StringTokenizer können noch viel verwirrender werden.
Positive Zahlen lassen sich immer noch filtern, indem man Zeile 37 wie folgt ändert:
[JAVA=37]			if(token == StreamTokenizer.TT_NUMBER && st.nval >= 0) {[/code]
Zum filtern von Hexadezimalzahlen müsste ich mir allerdings auch noch was einfallen lassen. Zumindest ist der StreamTokenizer in den Konfigurationsmöglichkeiten nicht so begrenzt wie der StringTokenizer. Aber wenn die Methoden vorgegeben sind, steht er kaum zur Debatte. Ich würde aber auf keinen Fall zum StringTokenizer greifen, wenn ich nur Zahlen haben will. Lieber tokenisiere ich mir den Reader oder sogar das simple char-Array selbst.


----------



## Bernd Hohmann (1. Dez 2012)

Spacerat hat gesagt.:


> So verwirrend find' ich den gar nicht.



Sagen wir es mal so: ich hab auch so einige Codefragmente in der Schublade, mit denen ein einfaches Problem "elegant" (also unter Nutzung eher selten gebräuchlicher Elemente der Runtime) zu lösen ist.

Zum Glück hängt an der Schublade ein großes Schloss und der Schlüssel wurde weggeworfen.

Bernd


----------



## Gerlon (1. Dez 2012)

Ah auch gerade gesehen das die schon ausgeschlossen werden ^^
Nurn Fehler noch gehabt..
Ändere gerade nur die substring wieder zu int[] substring, hast die ja als String und mit arraylist benutzt.
Möchte die aber als normales Array dann haben


----------



## Bernd Hohmann (1. Dez 2012)

Gerlon hat gesagt.:


> Ändere gerade nur die substring wieder zu int[] substring, hast die ja als String und mit arraylist benutzt. Möchte die aber als normales Array dann haben



Achso... Einfach am Ende statt 


```
String str[] = new String[al.size()];
return al.toArray(str);
```

halt ein 


```
int rc[]=new int [al.size()];
for (int i=0;i<al.size();i++)
   rc[i]=Integer.parseString(al.get(i));
return rc;
```

machen.

Bernd


----------



## maske (1. Dez 2012)

Wie wäre es damit?


```
public class Test {


	public static void main(String[] args) {
		String testString = "-5, 20, abc, -20, defg, 45ab67, 23";
		System.out.println(Arrays.toString(subString(testString)));
	}

    public static Integer[] subString(String testString){
		List<Integer> result = new ArrayList<Integer>(); 
		for (String s : testString.split(",")) {
			if (s.trim().matches("\\d+"))
				result.add(Integer.parseInt(s.trim()));
		}
		return result.toArray(new Integer[result.size()]);
	}

}
```


----------



## Gerlon (1. Dez 2012)

Ok, macht Sinn 

Vielen Dank für die schnelle Hilfe. An eine Liste hätte ich nicht gedacht. 
An sich ja relativ einfach 
Eine Frage hätte ich noch, würde es auch ohne Liste gehen und direkt mit einem Array?


----------



## Bernd Hohmann (1. Dez 2012)

Gerlon hat gesagt.:


> Eine Frage hätte ich noch, würde es auch ohne Liste gehen und direkt mit einem Array?



Nicht wirkllich gut da Du nicht weisst, wie viel Elemente aus deinem String übrig bleiben.

In Zeiten knappen Speichers hätte man die Aufgabenstellung 2x durchlesen: 1x für die Ermittlung des Speicherbedarfs und 1x für das Befüllen des Arrays.

Du kannst natürlich auch theoretisch ein int[]-Array hinreichender Grösse bereitstellen und das im Ernstfall grösser machen (neues, grösseres array erstellen, bestehende Werte reinkopieren, altes arrray löschen). Aber da bist Du genau an der Stelle bzw. Funktionalität, was ArrayList und Konsorten intern genau so machen.

Bernd


----------



## Gerlon (2. Dez 2012)

Oki, nochmals Danke hat mir sehr geholfen!


----------



## intel.amd (5. Dez 2012)

maske hat gesagt.:


> Wie wäre es damit?
> 
> 
> ```
> ...



Wie mache ich es wenn ich aus diesem String nur die Größte Zahl haben möchte. Also Die Funktion sortiert ja die 20 und 23 raus, soll Sie Vergleichen und nur die 23 ausgeben.

ich wollte es so machen, aber irgendwie geht das nicht.


```
public static int MaxNumb (String str, int[] numbers) {
    int max=numbers[0];
    int index=0;
    for(int i=1; i<numbers.length;i++) {
      if(max<numbers[i]) { 
    max = numbers[i]; 
    index = i;
      } 
    }
    return index;

public static void main(String[] args) {
		String testString = "-5, 20, abc, -20, defg, 45ab67, 23";
System.out.println("Teste MaxNumb mit \""+testString+"\" erwarte: 23 bekomme:"+MaxNumb(testString));
}
```


----------



## Spacerat (5. Dez 2012)

Erstens musst du deiner MaxNumb-Methode beim Aufruf ein int[]-Array mit entsprechender Grösse übergeben, es sei denn, du streichst den sonst überflüssigen Parameter bei MaxNumb und deklarierst das Array dann dort. Zweitens lassen sich Min- und Max-Werte in Arrays viel bequemer mit "java.util.Arrays" filtern.


----------



## Gerlon (7. Dez 2012)

weiß nicht ob du das Problem noch hast aber
brauchst doch nur das 


```
int[] a = new int[str.length()];
		a = subString(str);
```

und dann eine Schleife
und ich würde es dann auch gleich im index zwischenspeichern
und den 


```
int max=numbers[0];
```

keine Ahnung was das da soll, ist unnötig


```
for ( int i = 0; i < a.length ; i++){
			
			if (index < a[i]) {
				index = a[i];
}
```


----------

