# Zahl in Ihre Einzelteile zerlegen?



## thadre (16. Dezember 2008)

Ich habe eine Zahl z.B: zipCode, die aus der Datenbank kommt. Nun möchte ich die Zahl so zerlegen, dass die Postleitzahl 12345 dann 1 zipCode1, 2 zipCode2, 3 zipCode3 usw ist.
Weiß jemand wie das geht?

Vielen Dank


----------



## tim staeglich (16. Dezember 2008)

Hi thadre,

könntest Du kurz genauer beschreiben was Du möchtest, z.B. "Zahl" wird zu "Ergebnis" etc.? Ich verstehe die Problematik noch nicht (ich glaube das hat außerdem auch nix mit J2EE/JEE zu tun).

Danke & Grüße

Tim


----------



## thadre (16. Dezember 2008)

Also ich entwickle in J2EE dehalb hab ichs hier reingeschrieben 
Ich bekomme aus der Datenbank zum Beispiel eine Postleitzahl und 12345
Jetzt möchte ist das jede dieser 5 Zahlen für sich alleine steht, also die 1 für sich, die 2 für sich und die 3 für sich.
Hoffe verstehst wie ich das meine.

Danke


----------



## tim staeglich (16. Dezember 2008)

Sicherlich gäbe es noch andere Möglichkeiten, aus der Hüfte geschossen funktioniert diese hier schon mal:


```
public static void main(String[] args) {

		StringBuffer buffer = new StringBuffer();
		buffer.append(1234);
		char[] charArray = buffer.toString().toCharArray();
		for (int i = 0; i < charArray.length; i++) {
			char c = charArray[i];
			System.out.println(c);
		}

	}
```

Gruß Tim


----------



## Johannes7146 (16. Dezember 2008)

```
public class TestKlasse {

	public static void main(String[] args) {

		// Deine Zahl
		int zahl = 12345;
		// Zahl in String convertieren
		String s = String.valueOf(zahl);
		// Array anlegen das so groß ist wie deine zahl lang
		int[] zahlen = new int[s.length()];

		// Zahlen in ein Array einfügen
		for (int i = 0; i < zahlen.length; i++) {
			zahlen[i] = Integer.parseInt(String.valueOf(s.charAt(i)));
		}

		// Zahlen ausgeben
		for (int j = 0; j < zahlen.length; j++) {
			System.out.println(zahlen[j]);
		}

	}
```

edit: da war wohl jemand schneller


----------



## thadre (16. Dezember 2008)

Danke. Werde es heute Abend gleich mal ausprobieren


----------



## tim staeglich (16. Dezember 2008)

Klasse. Wäre nett wenn du uns noch positiv bewerten könntest (gesetzt den Fall wir konnten Dir helfen). 

Gruß Tim


----------



## thadre (16. Dezember 2008)

tim staeglich hat gesagt.:


> Klasse. Wäre nett wenn du uns noch positiv bewerten könntest (gesetzt den Fall wir konnten Dir helfen).
> 
> Gruß Tim



habe ich soeben getan. danke


----------



## Oliver Gierke (17. Dezember 2008)

Wenn es wirklich um einzelne Ziffern geht ist man mit mod 10 und ganzzahliger Division durch 10 wahrscheinlich wesentlich performanter... 


```
List<Integer> digits = getDigits(new ArrayList<Integer>());

public List<Integer> getDigits(Integer number, List<Integer> digits) {

  if (number < 10) {
    digits.add(number);
    return digits;
  }

  digits.add(number % 10);
  return getDigits(number / 10, digits);
}
```

Achtung, das ist VHIDT Code (vom Hirn in die Tasten) - also eher Pseudocode... aber das Prinzip sollte deutlich werden. Probleme ebenso: vermtl. ist ein Stack als Speicher sinnvoller, da mit der Liste die Reihenfolge verkehrt ist (letzte Ziffer an erster Stelle). 

Gruß
Ollie


----------



## vfl_freak (17. Dezember 2008)

Moin Ollie,



> VHIDT


? ? ?

Was heißt denn das bitte ? 

Danke und Gruß
Klaus

EDIT:  hab's nochmal gelesen und erst jetzt verstanden - sorry, bin derzeit erkältet und bedingt "bedienungsfähig" ...


----------



## Navy (17. Dezember 2008)

Oliver Gierke hat gesagt.:


> Wenn es wirklich um einzelne Ziffern geht ist man mit mod 10 und ganzzahliger Division durch 10 wahrscheinlich wesentlich performanter...



Mhmm... mit dieser Aussage wäre ich vorsichtig. Je nach Länge der Zahl wäre die Typenumwandlung nach String mit folgenden Zählerdurchlauf sehr viel schneller als das Rekursionsverfahren (welches ich aber dennoch als wesentlich eleganter ansehe) mit 2n Berechnungen, da beim String nur in den Adressen, bzw einem Array von chars gesprungen werden muss...


----------



## Oliver Gierke (17. Dezember 2008)

Richtige Überlegung. Wenn ich allerdings davon ausgehe, dass String.valueOf einen neuen String erzeugt (was ich nicht genau weiß, jedoch den Worstcase annehme), ist das schon nicht ohne. Allerdings bewegen wir uns hier wirklich im Bereich der Microoptimierung. Vielleicht hätte ich den Performancesatz nicht so prominent vorn anstellen sollen. Mir ging es eher darum, den mathematischeren Weg aufzuzeigen. IMHO schlägt man zu oft zu schnell mit Stringfrickeleien nach solchen Problemen (wobei, die natürlich trotzdem das Problem lösen...).

Gruß
Ollie


----------



## tim staeglich (17. Dezember 2008)

Moin,

ich finde es sehr gut (ob nun Microoptimierung oder nicht), solche ideen wie Oli sie vorschlägt zu posten.

Im Alltag vergisst man sehr oft die netten Möglichkeiten zu nutzen, die z.B. rekursive Programmierung bietet. 

Meistens ist Rekursion schneller meine ich - in diesem Fall z.B. glaube ich nicht dass zusätzliche Initialisierungen von Strings etc. hier allzu nachteilig für die Performance sind.

Gruß Tim


----------



## nanuna (13. Januar 2009)

Hmmm, wenn wir gerade bei unterschiedlichen Lösungsmöglichkeiten sind, hier ist eine *ohne* Strings, von der mich die Performance interessieren würde:


```
int wert = 12345;

// hier noch wert = 0 abfangen! ...

// Länge des Integerwertes.
int d = (int) Math.log10( Math.abs(wert) ) + 1;

// Rückgabearray mit den einzelnen Ziffern.
int[] ziffern = new int[d];

while (wert != 0)
   {
   ziffern[--d] = wert % 10;
   wert /= 10;
   }

// ziffern[0] = 1
// ziffern[1] = 2
// ziffern[2] = 3
// ziffern[3] = 4
// ziffern[4] = 5
```


----------



## andie2302 (8. September 2009)

Hier noch eine Möglichkeit!

```
int zahl = 185494589;
    ArrayList<Integer> liste = new ArrayList<Integer>();
    for(int i=(""+zahl).length(); i>0;i--)
    {
        liste.add(0, zahl%10);
        zahl=(zahl-zahl%10)/10;
    }
```
Das Ergebnis steht in liste.


----------

