Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Hallo,
ist es möglich, über mehrere Arrays in ein und der selben Schleife zu iterieren? Mir ist nicht ganz klar, wie das mit dem hasNext() prüfen funktionieren soll und wie ich mehr als 3 Argumente in die for-Schleife einbauen kann.
Zum Anwendungsfall:
Ich hab ein Skelett programmiert, welches ich animieren möchte.
Dazu wollte ich für jedes Gelenk eine Vielzahl von Winkelwerten in einem Array speichern und dann auslesen.
Oder willst du die Arrays parallel bearbeiten? Dann würde ich versuchen sicherzustellen, dass die Arrays gleich lang sind und mit dem Standard vorgehen:
Java:
for(int i = 0; i <array1.length; i++){
System.out.println(array1[i]);
System.out.println(array2[i]);
}
Willst du unterschiedliche Längen wird es kompliziert.
Ich habe wenn mich nicht alles täuscht derzeit 11 Gelenke, die sich über Winkelradien ansprechen lassen.
Damit "er"^^ sich einigermaßen natürlich verhält, möchte ich pro Schleifendurchlauf für jedes Gelenk einen Winkelwert auslesen und die Figur damit berechnen.
Aus dem Grund kommen verschachtelte Schleifen leider nicht in Frage.
Edit:
Das mit der temporären Liste halte ich irgendwie für unnötig in meinem Fall.
Ich hab das jetzt mit einer for-Schleife gelöst und greife über den Index zu. Dann muss ich halt entweder zusehen, dass die Arrays immer gleich lang sind oder wie pl4gu33 schon sagte, innerhalb der for-Schleife nochmal prüfen, ob die jeweiligen Arrays noch Elemente enthalten wobei letzteres wahrscheinlich sinnvoller ist, man weiß ja nie
import java.util.*;
public class AppendIterable<T> implements Iterable<T> {
private final List<Iterable<T>> iterables = new ArrayList<Iterable<T>>();
public AppendIterable(Iterable<T> iterable) {
iterables.add(iterable);
}
public AppendIterable(T ... ts) {
iterables.add(Arrays.asList(ts));
}
public AppendIterable<T> and(Iterable<T> iterable) {
iterables.add(iterable);
return this;
}
public AppendIterable<T> and(T ... ts) {
iterables.add(Arrays.asList(ts));
return this;
}
@Override
public Iterator<T> iterator() {
return new Iterator<T>() {
private int index = 0;
private Iterator<T> it = iterables.isEmpty()
? null
: iterables.get(index).iterator();
@Override
public boolean hasNext() {
if (it == null) {
return false;
} else if (it.hasNext()) {
return true;
} else {
index++;
it = index < iterables.size() ? iterables.get(index).iterator() : null;
return hasNext();
}
}
@Override
public T next() {
if (hasNext()) {
return it.next();
} else {
throw new NoSuchElementException();
}
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
}
Anwendung:
Java:
List<String> list = new ArrayList<String>();
list.add("foo");
list.add("bar");
AppendIterable<String> strings = new AppendIterable<String>("bla","laber").and(list).and().and("sülz").and(list);
for(String s : strings) {
System.out.println(s);
}
Code:
bla
laber
foo
bar
sülz
foo
bar
Man beachte, dass das flexibler ist als eine Lösung, wo man einfach alles in eine einzige Liste packt, weil ja nicht gesagt ist, dass jeder Teil-Iterator auch wirklich terminiert, bzw. das Auslesen eines Iterators sehr lange dauern kann, obwohl vielleicht am Ende die Schleife vorzeitig verlassen wird.
[edit]
Ach, ich sehe gerade, dass du anscheinend doch "parallel" über die Arrays iterieren willst. Ich lasse es trotzdem mal stehen...
[/edit]
import java.util.*;
public class AppendIterable<T> implements Iterable<T> {
private final List<Iterable<T>> iterables = new ArrayList<Iterable<T>>();
public AppendIterable(Iterable<T> iterable) {
iterables.add(iterable);
}
public AppendIterable(T ... ts) {
iterables.add(Arrays.asList(ts));
}
public AppendIterable<T> and(Iterable<T> iterable) {
iterables.add(iterable);
return this;
}
public AppendIterable<T> and(T ... ts) {
iterables.add(Arrays.asList(ts));
return this;
}
@Override
public Iterator<T> iterator() {
return new Iterator<T>() {
private int index = 0;
private Iterator<T> it = iterables.isEmpty()
? null
: iterables.get(index).iterator();
@Override
public boolean hasNext() {
if (it == null) {
return false;
} else if (it.hasNext()) {
return true;
} else {
index++;
it = index < iterables.size() ? iterables.get(index).iterator() : null;
return hasNext();
}
}
@Override
public T next() {
if (hasNext()) {
return it.next();
} else {
throw new NoSuchElementException();
}
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
}
Anwendung:
Java:
List<String> list = new ArrayList<String>();
list.add("foo");
list.add("bar");
AppendIterable<String> strings = new AppendIterable<String>("bla","laber").and(list).and().and("sülz").and(list);
for(String s : strings) {
System.out.println(s);
}
Code:
bla
laber
foo
bar
sülz
foo
bar
Man beachte, dass das flexibler ist als eine Lösung, wo man einfach alles in eine einzige Liste packt, weil ja nicht gesagt ist, dass jeder Teil-Iterator auch wirklich terminiert, bzw. das Auslesen eines Iterators sehr lange dauern kann, obwohl vielleicht am Ende die Schleife vorzeitig verlassen wird.
[edit]
Ach, ich sehe gerade, dass du anscheinend doch "parallel" über die Arrays iterieren willst. Ich lasse es trotzdem mal stehen...
[/edit]
Gut, aber da hätte ich dann wahrscheinlich Probleme, die Werte die ich rausbekomme, den einzelnen Variablen zuzuweisen...außer ich gehe wieder über die Indices der Werte des Ergebnisses.
Bsp:
halswinkel=bla;
bodywinkel=laber;
die Werte müssen wirklich zugewiesen werden, denn ich hab für jedes Gelenk eine andere Funktion, da sie wiederum in Abhängigkeit zu anderen Gelenken stehen
usw...ich glaub da verstrick ich mich nur unnötig
Naja, hätte ich machen können. Ich hab mir überlegt, ob ich jedes Gelenk als Objekt instanziieren soll, hab mich dann jedoch dazu entschieden das Skellet als ganzes zu definieren, weil es so für mich am einfachsten erschien
Klar, aber abstrahieren kann ich später immer noch. Ich war froh als endlich alle Winkel richtig berechnet wurden und da hab ich noch nicht an Objekte gedacht
Das ganze hat auch noch keinen richtigen Verwendungszweck, mir ging es eher um den Probier-Faktor
