Ich habe ein String-Array mit einigen Komponenten, dieses Array hat 5 Komponenten und kann einige Male variieren. Was ich gerne tun würde, ist, dieses Array zu durchlaufen und die erste Komponente und die Komponente neben diesem zu erhalten. Beim ersten Mal würde ich die Komponente Nummer eins und die Komponente Nummer 2 erhalten, beim zweiten Mal die Nummer 2 und 3, das dritte Mal Nummer 3 und 4 ... Und so weiter, bis Sie zur letzten Komponente gelangen.
So weit bin ich gekommen:
String[] elements = { "a", "a","a","a" };
for( int i = 0; i <= elements.length - 1; i++)
{
// get element number 0 and 1 and put it in a variable,
// and the next time get element 1 and 2 and put this in another variable.
}
Wie kann ich das erreichen?
Sie können eine verbesserte Schleife (für Java 5 und höher) für die Iteration der Array-Elemente ausführen:
String[] elements = {"a", "a", "a", "a"};
for (String s: elements) {
//Do your stuff here
System.out.println(s);
}
String[] elements = { "a", "a", "a", "a" };
for( int i = 0; i < elements.length - 1; i++)
{
String element = elements[i];
String nextElement = elements[i+1];
}
Beachten Sie, dass elements.length
in diesem Fall 4 ist. Sie möchten also von [0,2]
aus iterieren, um die Elemente 0,1
, 1,2
und 2,3
zu erhalten.
String current = elements[i];
if (i != elements.length - 1) {
String next = elements[i+1];
}
Dadurch wird sichergestellt, dass Sie für das letzte Element keine ArrayIndexOutOfBoundsException
erhalten (dort ist kein 'nächstes'). Die andere Option besteht darin, zu i < elements.length - 1
zu iterieren. Das hängt von Ihren Anforderungen ab.
String[] elements = { "a", "a","a","a" };
for( int i=0; i<elements.length-1; i++)
{
String s1 = elements[i];
String s2 = elements[i+1];
}
Ich würde argumentieren, anstatt i
weniger als elements.length - 1
zu testen i + 1
weniger als elements.length
. Sie ändern nicht die Domäne des Arrays, das Sie betrachten (d. H. Das letzte Element ignorieren), sondern ändern das größte Element, das Sie in jeder Iteration betrachten.
String[] elements = { "a", "a","a","a" };
for(int i = 0; i + 1 < elements.length; i++) {
String first = elements[i];
String second = elements[i+1];
//do something with the two strings
}
Sie müssen die Seriennummer pflegen, wie oft Sie auf das Array zugreifen. Verwenden Sie diese Option
int lookUpTime=0;
for(int i=lookUpTime;i<lookUpTime+2 && i<elements.length();i++)
{
// do something with elements[i]
}
lookUpTime++;
Diese Algorithmen sind aufgrund des Vergleichs beide falsch:
for (int i = 0; i <Elemente.Länge - 1; i ++)
oder
for (int i = 0; i + 1 <elements.length; i ++) {
Es ist wahr, dass die Array-Elemente von 0
bis length - 1
reichen, aber in diesem Fall sollte less than or equal to
..__ der Vergleich sein.
for (int i = 0; i <Elemente.Länge; i ++) {
oder
for (int i = 0; i <= Elemente.Länge - 1; i ++) {
oder
for (int i = 0; i + 1 <= Elemente.Länge; i ++) {
Das Array ["a", "b"]
Würde folgendermaßen iterieren:
i = 0 ist <2: Elemente [0] ergibt "a"
i = 1 ist <2: Elemente [1] ergibt "b"
dann beenden Sie die Schleife, da 2 nicht <2 ist.
Die fehlerhaften Beispiele verlassen die Schleife vorzeitig und werden nur in diesem einfachen Fall mit zwei Elementen mit dem ersten Element ausgeführt.
String[] nameArray= {"John", "Paul", "Ringo", "George"};
int numberOfItems = nameArray.length;
for (int i=0; i<numberOfItems; i++)
{
String name = nameArray[i];
System.out.println("Hello " + name);
}
Wenn Sie nach Leistung suchen und die Reihenfolge der Iteration nicht relevant ist, können Sie mit einer optimierten Rückwärtsschleife iterieren:
for(int i=elements.lenth; --i>=0;) {...}
Auf diese Weise rufen Sie die Länge des Arrays einmal ab, dekrementieren dann den Index und vergleichen mit Null in einer atomaren Operation. Last-but-not-Last-Vergleich mit Null ist eine sehr schnelle Operation, die häufig von vielen Prozessoren optimiert wird (schneller als der Vergleich mit der Länge des Arrays).