# Ungerade Zahlen aus befülltem Array lesen und in neues Array übergeben



## stibi (9. Nov 2012)

Hallo liebe Java-Forum Community

Also folgende Aufgabe:

Ich muss eine Methode erstellen, in welcher ein befülltes Array mit x Werten übergeben werden kann. In dieser Methode sollen alle ungerade Zahlen aus dem Array ausgelesen werden und in ein neues Array geschrieben werden. Das neue Array muss dann zum Schluss ausgegeben werden.

Ich habe bisher folgenden Code:


```
import java.util.*;
public class ArrayHandler{

	public int[] getOddNumers(int[] array3){
		int h = 0;
		int lengthArray3 = array3.length;
		int lengthArrayOdd;
		
		if(lengthArray3 % 2 != 0){
			lengthArrayOdd = (lengthArray3 + 1) / 2;
		}
		else{lengthArrayOdd = lengthArray3 / 2;
		}
		int [] arrayOdd = new int [lengthArrayOdd];
		while(h < array3.length){
			int p = array3[h];
			
			if(p % 2 != 0 && p != 1){
				int q = 0;
				
				arrayOdd[q] = p;
				q++;
				//		System.out.println("p " + p);
			}
			h++;
		}
		int z = 0;
		
		while(z < arrayOdd.length){
			System.out.println(arrayOdd[z]);
			
			z++;
		}
		return arrayOdd;
	}
}
```

Also; das ganze klappt zu 50%. Wenn ich die Methode auf ein Objekt anwende erhalte ich folgende Ausgabe:
(etwas gekürzt, aber ich glaube ihr seht das Problem :bae
...
3
0
0
0
0
0
3
0
0
0
0
0
5
0
0
0
0
0
5
0
0
0
0
0
7
0
0
0
0
0
7
0
0
0
0
0
9
0
0
0
0
0
9...

Ich habe schon einige Zeit rumgesucht, rumgebastelt und ausprobiert - bekomme es einfach nicht hin. 
;( 

Es scheint als ob der ganze Code mehrmals ausgeführt und die While Schleife zu früh verlassen wird ???:L

Jemand einen Vorschlag?

Dankeschön & Grüsse

Stibi


----------



## pro2 (9. Nov 2012)

Der Fehler besteht darin, dass du 
	
	
	
	





```
q
```
 immer wieder neu deklarierst und es somit immer wieder auf 0 gesetzt wird. Daher wird nur die letzte Zahl ausgegeben.

Noch ein paar Hinweise:
- Dein Versuch, zu berechnen, wie groß das Array sein wird, wird nicht funktionieren. Das kann man im Vornherein nicht wissen. Es sei denn, du weißt genau, welche Daten kommen. Du müsstest vorher einmal das ganze durchlaufen, dabei zählen und dann die Zahlen hinzufügen. Alternativ Listen verwenden, aber das ist wohl durch die Aufgabenstellung nicht erlaubt.
- Die Eins wird leider gar nicht beachtet. Besser im else if Zweig einführen.


----------



## stibi (9. Nov 2012)

Hallo pro2 und danke für die Antwort!

Zum Hauptproblem: Tatsächlich, hatte schon den selben Fehler mit h gemacht. Hätte ich auch sehen können 

Jetzt schaut die Ausgabe zwar schon etwas besser aus, aber noch immer nicht wie gewünscht:










Zur Berechnung der Länge des neuen Arrays:

Meinst Du, wenn die Zahlen nicht sortiert kommen? Wenn ja; dessen bin ich mir bewusst. Aber hier mal die Main:


```
public class Main{	
	public static void main (String [] args){
		
		
		ArrayHandler object1 = new ArrayHandler();
		
		int p = 0;
		int [] array3 = new int [11];
		while (p < array3.length){
			array3[p] = p;
			p++;
			object1.getOddNumers(arrayxy);
		}
	}
}
```

In diesem Fall änder sich ja nur jeweils die Länge des Arrays. Die Werte bleiben sortiert. So sollte die Berechnung ja funktionieren?

Zu der 1: Meinst Du Zeile 18 das && != 1? Ich weiss gar nicht mehr, wieso ich die 1 weglassen wollte ???:L Hab den Grossteil des Codes schon vorgestern geschrieben.

Wie auch immer, hier mal ne angepasste Version mit dem else if welches die 1 auch mitnehmen sollte:


```
public int[] getOddNumers(int[] array3){
		int q = 0;
		int h = 0;
		int lengthArray3 = array3.length;
		int lengthArrayOdd;
		
		if(lengthArray3 % 2 != 0){
			lengthArrayOdd = (lengthArray3 + 1) / 2;
		}
		else{lengthArrayOdd = lengthArray3 / 2;
		}
		int [] arrayOdd = new int [lengthArrayOdd];
		while(h < array3.length){
			int p = array3[h];
			
			if(p % 2 > 0){
				
				arrayOdd[q] = p;
				q++;
			}
			else if(p == 1){
				arrayOdd[q] = p;
				q++;
			}
		}
		h++;
		
		int z = 0;
		
		while(z < arrayOdd.length){
			System.out.println(arrayOdd[z]);
			z++;
		}
		return arrayOdd;
	}
```

Leider hab ich da wohl ne "verschlimm-besserung" gemacht. Jetzt bleibt er irgendwo in einer Endlosschleife stecken und gibt gar nichts mehr wieder.... Java lernen kann manchmal frustrierend sein ;(

However - Wenn Dir oder sonst jemanden gleich was auffällt... Ansonsten werde ich das Ganze mal bis morgen ruhen.

Grüsse
Stibi

Edit: Das mit der Endlosschleife hat sich erledigt - das h++ ist eine Zeile zu weit runter gerutscht.


----------



## pro2 (9. Nov 2012)

Ja, das mit der Eins frag ich mich jetzt auch. Ich hatte es so in meinen Post geschrieben, aber eigentlich ist es ja komplett unsinnig. Das

```
if (p % 2 != 0)
            {
                arrayOdd[q] = p;
                q++;
            }
```
genügt. 

Was ich mit der Berechnung der Zahlen meine, ist Folgendes. Wenn du weißt, dass immer Zahlenreihen kommen, die dem Format {1, 2, ..., n - 1, n} folgen, dann geht das. Aber was, wenn du mal alle ungerade Zahlen aus solch einem Array holen sollst: {2, 4, 5, 100, 23, 45, 47, 323}? Dann geht diese Berechnung nicht mehr auf.

Meine Idee:


```
public static int[] getOddNumers(int[] oldArray)
    {
        int newSize = 0;
        for (int i = 0; i < oldArray.length; i++)
        {
            if (oldArray[i] % 2 == 1)
            {
                newSize++;
            }
        }
        int newArray[] = new int[newSize];
        for (int i = 0, j = 0; j < newSize; i++)
        {
            if (oldArray[i] % 2 == 1)
            {
                newArray[j++] = oldArray[i];
            }
        }
        return newArray;
    }

    public static void main(String[] args)
    {
        int array[] =
        {
            12, 23, 34, 41, 54, 65, 55, 38, 49, 210
        };

        array = getOddNumers(array);
        for (int i = 0; i < array.length; i++)
        {
            System.out.print(array[i] + " ");
        }
    }
```


----------

