Durchlaufen Sie das String-Array in Java

Ich habe ein String-Array mit einigen Komponenten, dieses Array hat 5 Komponenten und es variiert manchmal. Was ich tun möchte, ist, durch dieses Array zu iterieren und die erste Komponente und die Komponente neben dieser zu erhalten. Das erste Mal würde ich die Komponentennummer eins und die Komponentennummer 2 erhalten, das zweite Mal die Nummer 2 und 3, das dritte Mal die Nummern 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 erweiterte for-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 in diesem Fall elements.length4 ist, sodass Sie iterieren möchten [0,2], um Elemente zu erhalten 0,1, 1,2und 2,3.

String current = elements[i];
if (i != elements.length - 1) {
   String next = elements[i+1];
}

Dies stellt sicher, dass Sie kein ArrayIndexOutOfBoundsExceptionfür das letzte Element erhalten (es gibt dort kein "nächstes"). Die andere Option ist das Iterieren zu i < elements.length - 1. 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 iweniger zu elements.length - 1 testen i + 1als weniger als zu testen elements.length. Sie ändern nicht die Domäne des Arrays, das Sie betrachten (dh das letzte Element ignorieren), sondern 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 beibehalten, 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++;

    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);
    }

Diese Algorithmen sind aufgrund des Vergleichs beide falsch:

für (int i = 0; i <elements.length - 1; i ++)

oder

für (int i = 0; i + 1 <elements.length; i ++) {

Es ist wahr, dass die Array-Elemente von 0bis reichen length - 1, aber der Vergleich sollte in diesem Fall sein less than or equal to. Das sollten sein:

für (int i = 0; i <elements.length; i ++) {

oder

für (int i = 0; i <= elements.length - 1; i ++) {

oder

für (int i = 0; i + 1 <= elements.length; i ++) {

Das Array ["a", "b"] würde iterieren als:

i = 0 ist <2: Elemente [0] ergeben "a"

i = 1 ist <2: Elemente [1] ergeben "b"

Verlassen Sie dann die Schleife, da 2 nicht <2 ist.

Die falschen Beispiele verlassen beide die Schleife vorzeitig und werden in diesem einfachen Fall von zwei Elementen nur mit dem ersten Element ausgeführt.

Solange diese Frage unbeantwortet bleibt und sich Java im Laufe der Jahre weiterentwickelt hat, habe ich beschlossen, meine eigene zu stellen.

Lassen Sie uns der Übersichtlichkeit halber das Eingabe-String-Array so ändern, dass es 5 eindeutige Elemente enthält.

String[] elements = {"a", "b", "c", "d", "e"};

Sie möchten auf zwei Geschwister in der Liste zugreifen, wobei jede Iteration um einen Index erhöht wird.

for (int i=0; i<elements.length-1; i++) {        // note the condition
    String left = elements[i];
    String right = elements[i+1];

    System.out.println(left + " " + right);      // prints 4 lines
}

Drucken der Paare von linken und rechten in vier Iterationen führen in den Leitungen a b, b c, c d, d ein der Konsole.

Was kann passieren, wenn das Eingabezeichenfolgenarray weniger als 2 Elemente enthält? Nichts druckt unsere, solange diese for-Schleife immer zwei Geschwisterknoten extrahiert . Mit weniger als 2 Elementen tritt das Programm nicht in die Schleife selbst ein.

Soweit Ihr Snippet angibt, möchten Sie die extrahierten Werte nicht verwerfen, sondern ihnen eine weitere Variable hinzufügen, vorausgesetzt, Sie möchten sie außerhalb des Bereichs der for-Schleife entweder in einer Liste oder in einem Array speichern. Angenommen, Sie möchten die Geschwister mit dem +Charakter verketten .

List<String> list = new ArrayList<>();
String[] array = new String[elements.length-1];  // note the defined size

for (int i=0; i<elements.length-1; i++) {
    String left = elements[i];
    String right = elements[i+1];

    list.add(left + "+" + right);            // adds to the list
    array[i] = left + "+" + right;           // adds to the array
}

Das Drucken des Inhalts sowohl der Liste als auch des Arrays ( Arrays.toString(array)) führt zu:

[a+b, b+c, c+d, d+e]

Java 8

Ab Java 8 könnten Sie versucht sein, den Vorteil der Stream-API zu nutzen. Sie wurde jedoch für die Verarbeitung der einzelnen Elemente aus einer Quellensammlung entwickelt. Es gibt keine solche Methode, um zwei oder mehr Geschwisterknoten gleichzeitig zu verarbeiten.

Die einzige Möglichkeit besteht darin, die Stream-API zu verwenden, um stattdessen die Indizes zu verarbeiten und sie dem tatsächlichen Wert zuzuordnen. Solange Sie mit einem primitiven Stream beginnen, der aufgerufen wird IntStream, müssen Sie die IntStream::mapToObjMethode verwenden, um eine Box zu erhalten Stream<T>:

String[] array = IntStream.range(0, elements.length-1)
    .mapToObj(i -> elements[i] + "+" + elements[i + 1])
    .toArray(String[]::new);                              // [a+b, b+c, c+d, d+e]

List<String> list = IntStream.range(0, elements.length-1)
    .mapToObj(i -> elements[i] + "+" + elements[i + 1])
    .collect(Collectors.toList());                        // [a+b, b+c, c+d, d+e]

Wenn Sie nach Leistung suchen und die Reihenfolge der Iteration nicht relevant ist, können Sie mithilfe einer optimierten Rückwärtsschleife iterieren:

int elemLength = elements.length;
if(elemLength < 2){
  // avoid ArrayIndexOutOfBoundsException ...
} else {
  String elem1, elem2;
  for(int i = elemLength -1; --i >= 0;) {
    elem1 = elements[i];
    elem2 = elements[i+1];
    // do whatever you want with those two strings
  }
}

Auf diese Weise rufen Sie die Länge des Arrays einmal ab, dekrementieren dann den Index und vergleichen ihn in einer einzigen Operation mit Null. Der Vergleich mit Null ist eine sehr schnelle Operation, die häufig von vielen Architekturen optimiert wird (einfacher / schneller als der Vergleich mit der Länge des Arrays).