bestimmte Werte einem Array zuweisen (Java)

achso,
die variable 'eingaben' steht für die anzahl der eingaben, die man tätigen kann und wird an anderer stelle festgelegt. sie beträgt 10.

Du musst halt neu fragen, wenn der Wert nicht korrekt ist; nur dann kriegst du das Array mit richtigen Werten ohne Lücken voll:

for (int i = 0; (i < 10); i++) {
    do {
wert = In.getInteger("Zahl zwischen 1 und 10: ");
korrekt[i] = wert;
    } while (wert >= 1 && wert <= 10)
}
Ansonsten kannst du natürlich ne Liste nehmen, quasi als dynamisches Array:
int wert;
int rAnzahl = 0;
List<Integer> werte = new ArrayList<Integer>();
for (int i = 0; (i < 10); i++) {
    wert = In.getInteger("Zahl zwischen 1 und 10: ");
    if (wert >= 1 && wert <= 10) {
werte.add(wert);
    }
}

// Optional in ein Array kopieren
rAnzahl = werte.size();
int[] korrekt = new int[rAnzahl];
for (int i = 0; i < rAnzahl; i++) {
    korrekt[i] = werte.get(i);
}
Der Teil mit dem Kopieren ist optional, du kannst genausogut mit der Liste weiterarbeiten. Wenn du nicht zwingend auf Arrays angewiesen bist, ist das IMHO sogar angenehmer. Das Kopieren an sich ist hier etwas umständlich, da Listen keine int beinhalten können und man auf Integer ausweichen muss, daher kann man das nicht mit der toArray-Funktion in ein Array casten.

danke für die antwort.
jedoch kann ich die do-while schliefe nicht verwenden, da ich den code nun etwas geändert habe. mit listen hatte ich noch nix zu tun, also wäre ohne listen besser^^

ich poste mal den code:

public void eingabe(int eingabeAnzahl) {

int wert = 1;
for (int i = 0; (i < eingabeAnzahl) && (wert != 0); i++) {
wert = In.getInteger("Zahl zwischen 1 und 10 (0 zum Beenden): ");
pruefen(wert, i);   // Aufruf Methode pruefen
}
} // end eingabe

public void pruefen(int wert, int auktuelleEingabe) {

if (wert == 0) {
System.out.println("Zahl: " + wert + "\nEingabe beendet!\n");
} else {
if (wert < 1 || wert > 10) {
System.out.println("Zahl: " + wert + "\nFalsche Eingabe!\n");
fAnzahl++;
} else {
System.out.println("Zahl: " + wert + "\nEingabe korrekt!\n");
rAnzahl++;
erzeuge(wert);  // Aufruf Methode erzeuge
}
}
} // end pruefen

public void erzeuge(int wert) {

int[] korrekt = new int [rAnzahl];

for (int i = 0; i < korrekt.length; i++ )  {
korrekt[i] = wert;
}
}
so wird das array jedoch immer wieder erzeugt und somit werden die alten werte gelöscht. das array hat dann zwar die richtige länge, aber an jeder position steht dann nur der zuletzt eingegebene korrekte wert.

ich hoffe man da noch durchsehen. durch die ganzen änderungen und probiren, verlier ich langsam den überblick^^

das 'i' beim methodenaufruf von pruefe und der parameter 'int aktuelleEingabe' bei dieser methode können weggelassen werden.

Naja, klar, du erzeugst bei jedem Aufruf von erzeuge() ein neues Array und schreibst in jedes Feld den selben Wert. Dynamische Arrays sind recht umständlich, das könnte etwa so gehen:

private int[] korrekt = new int[0];

public void erzeuge(int wert) {
    int[] temp = korrekt;
    korrekt = new int[rAnzahl];
    System.arraycopy(temp, 0, korrekt, 0, temp.length);
    korrekt[rAnzahl - 1] = wert;
}
Du erzeugst quasi ein neues Array das 1 größer ist als vorher, kopierst die alten Werte ins neue und hängst den neuen Wert hinten dran. Ist bei größeren Arrays nicht gerade schnell...

Zum Vergleich mit Listen (Eine ArrayList ist nichts anderes als ein dynamisches Array; solltest du dir mal ansehen, das lohnt sich*):
private List<Integer> korrekt = new ArrayList<Integer>();

public void erzeuge(int wert) {
    korrekt.add(wert);
}

*) Einige Features:
- Du kannst genauso drüber iterieren wie über Arrays
- Du hast direkten Zugriff auf einen Index (list.get(i))
- Du brauchst dir über die Größe keine Gedanken machen
- Du kannst einfach ans Ende anhängen (list.add(Object))
- Du kannst in der Mitte einfügen (list.add(Object, position))
- Du kannst Löschen ohne dass Lücken entstehen (list.remove(Object), list.remove(position))
- Du kannst prüfen, ob ein Element drin ist (list.contains(Object))

danke. ich hatte gestern auch irgendiie die idee, dass es mit kopieren irgendwie funktionieren müsste.
wird mit der anweisung 'int[] temp = korrekt;' die länge von 'temp' festgelegt oder werden damit auch gleich die werte von 'korrekt' zugewiesen?


ich hätte noch eine kleine frage: und zwar sollen alles korrekten werte addiert werden. ist es besser alles werte des arrays zu addieren oder reicht es aus, wenn ich dafür eine variable rSum verwende? - siehe codeauszug methode 'pruefen'

System.out.println("Zahl: " + wert + "\nEingabe korrekt!\n");
rAnzahl++;
rSum += wert;
erzeuge(wert);
wenn ich es mit hilfe des arrays mache, hätte man wahrscheinlich einen geschwindigkeitsvorteil. jedenfalls wenn es woanders addiert wird - also nicht in der methode / schleife.

das soll's dann erstmal an fragen gewesen sein.^^
schonmal danke für die bisherige hilfe

int[] temp = korrekt; weist auch die Werte zu. Vereinfacht gesagt. In Wirklichkeit enthält temp danach eine Referenz auf das Array, das auch durch korrekt referenziert wird. Kopiert etc. wird da nix, das dient nur dazu die Referenz nicht zu verlieren, wenn du korrekt einem neuen Array zuweist.

Wenn die Werte nur addiert werden sollen (und du sie danach nicht mehr brauchst) ist es deutlich besser und schneller, sie direkt zu addieren. Insbesondere das Kopieren von Arrays fällt dann ja weg. Wenn du das Array trotzdem brauchst ist es so wahrscheinlich auch schneller; die Unterschiede dürften aber minimal sein (und bei <1000000 Werten merkst du da wohl eh nix von)

achso, dann hab ich (erstmal) keine weiteren fragen^^. vielen dank für deine hilfe. hat mir sehr weiter geholfen.