wake-up-neo.com

Durchlaufen Sie ein String-Array in Java

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?

60
ErikssonE

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); 
}
148
Michal
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.

34
Stefan Kendall
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.

5
Bozho
String[] elements = { "a", "a","a","a" };

for( int i=0; i<elements.length-1; i++)
{
    String s1 = elements[i];
    String s2 = elements[i+1];
}
3
ascanio

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
}
2
ILMTitan

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++;
1
Rasel

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.

0
TrustButVerify
    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);
    }
0
Ravichandra S V

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).

0