web-dev-qa-db-fra.com

Itérer dans un tableau de chaînes en Java

J'ai String tableau avec certains composants, ce tableau a 5 composants et il varie parfois. Ce que je voudrais faire, c'est parcourir ce tableau et obtenir le premier composant et le composant à côté de celui-ci. Ainsi, la première fois, j'obtenais le composant numéro un et le composant numéro 2, la deuxième fois, les numéros 2 et 3, le troisième numéro 3 et 4 ... Et ainsi de suite jusqu'à la dernière composante. 

Ce à quel point je suis venu: 

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

Comment puis-je accomplir cela?

javaarrayscollections
60
ErikssonE

Vous pouvez faire un amélioré pour la boucle (pour Java 5 et supérieur) pour l'itération sur les éléments du tableau:

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

Notez que dans ce cas, elements.length est 4, vous devez donc effectuer une itération de [0,2] pour obtenir les éléments 0,1, 1,2 et 2,3.

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

Cela garantit que vous n'obtenez pas une ArrayIndexOutOfBoundsException pour le dernier élément (il n'y a pas de «prochain» ici). L'autre option consiste à itérer sur i < elements.length - 1. Cela dépend de vos besoins.

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

Je dirais au lieu de tester i moins que elements.length - 1 tester i + 1 moins que elements.length. Vous ne changez pas le domaine du tableau que vous regardez (en ignorant le dernier élément), mais le plus grand élément que vous regardez à chaque itération.

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

Vous devez maintenir le numéro de série combien de fois vous accédez au tableau.Utilisez comme ceci

int lookUpTime=0;

    for(int i=lookUpTime;i<lookUpTime+2 && i<elements.length();i++)
     {
    // do something with elements[i]
    }

lookUpTime++;
1
Rasel

Ces algorithmes sont tous les deux incorrects à cause de la comparaison:

pour (int i = 0; i <elements.length - 1; i ++)

ou 

pour (int i = 0; i + 1 <elements.length; i ++) {

Il est vrai que les éléments du tableau vont de 0 à length - 1, mais dans ce cas, la comparaison devrait être less than or equal to. 

pour (int i = 0; i <éléments.longueur; i ++) {

ou

pour (int i = 0; i <= elements.length - 1; i ++) {

ou

pour (int i = 0; i + 1 <= elements.length; i ++) {

Le tableau ["a", "b"].__ s'itérerait ainsi:

i = 0 est <2: les éléments [0] donnent "a" 

i = 1 est <2: les éléments [1] donnent "b"

puis quittez la boucle car 2 n'est pas <2.

Les exemples incorrects quittent la boucle prématurément et ne s'exécutent qu'avec le premier élément dans ce cas simple de deux éléments.

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

Si vous recherchez des performances et que l'ordre des itérations n'est pas pertinent, vous pouvez effectuer une itération à l'aide d'une boucle inverse optimisée:

for(int i=elements.lenth; --i>=0;) {...}

De cette manière, vous récupérez une fois la longueur du tableau, puis décrémentez l'index et comparez à zéro en une seule opération atomique. La dernière mais non la dernière comparaison avec zéro est une opération très rapide, souvent optimisée par de nombreux processeurs (plus rapide que la comparaison avec la longueur du tableau).

0
Marco Carlo Moriggi