Discussion :

[Regis.C]

Bonsoir à tous,

je parcourais le forum java comme à mon habitude, lorsque par mégarde je tombe 2 fois de suite sur des sujets contenant les codes de java 5.0 Tiger (generics) avec des ArrayList<String> , et des for(String: ArrayList) et j'en passe et des pires.

Un effroi me parcours soudainement la peau du dos :
Est-on condamné à ne plus voir de bonne vieille boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for(int i = 0;i < maListe.size(); i++)
{}

et nos bons vieux Vector ou ArrayList non pré-typé ??
Suis-je le seul à ne rien comprendre quand je lis les "nouvelles" syntaxes ?


Help !

[RadicalBob]

C'est vrai que ça fait bizar, mais après tout je trouve ça pas mal.

Moi j'utilise énormement les ArrayList, pas les Vectors, et c'est vrai que de leur ajouter un typage ça peut ajouter pas mal de propreté et de sureté au code (pas de castage a faire etc...)
Et puis le plus souvent on parcout l'intégralité d'un liste donc for(String: ArrayList) ça à l'air pas mal non ? si ça vaut bien dire : "parcourir tout la liste et en faire des String"

[Djakisback]

Salut, perso je trouve ca cool, ca évite le cast et les Exception de transtypage. Par contre j'avais fait quelques tests de rapidités :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  List<Integer> list = new ArrayList(8888888);
        for(Integer l = 0; l < 8888888; l++) {
            list.add(l);
        }
 
        long sTime2 = System.currentTimeMillis();
        for (Integer l : list) { ; }
        System.out.println("for étendue: " + (System.currentTimeMillis() - sTime2));
 
        long sTime5 = System.currentTimeMillis();
        for (Integer l = 0; l < 8888888; l++) { ; }
        System.out.println("Taille en dur: " + (System.currentTimeMillis() - sTime5));
 
        long sTime6 = System.currentTimeMillis();
        for (Integer l = 0; l < list.size(); l++) { ; }
        System.out.println("list.size(): " + (System.currentTimeMillis() - sTime6));

Je sais pas si ces tests sont très significatifs mais le for étendue prenait tjrs plus de temps...
Bye ^^

[le y@m's]

Un effroi me parcours soudainement la peau du dos :
Est-on condamné à ne plus voir de bonne vieille boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for(int i = 0;i < maListe.size(); i++)
{}

et nos bons vieux Vector ou ArrayList non pré-typé ??

Help !

Relax
Personnellement je trouve ces nouvelles fonctionnalités vraiment très pratiques. En effet pouvoir simplifier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
List list = new ArrayList();
//  ....
for(int i = 0; i < list.size(); i ++) {
     String string = (String) list.get(i);
      System.out.println(string);
}

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
List<String> list = new ArrayList<String>();
//  ....
for(String string : list) {
     System.out.println(string);
}

est vraiment très pratique autant en économie de code (for) qu'en sécurité du code (générics).
Cependant je ne pense pas que les "anciennes" boucles for disparaitront étant donné que l'on a parfois besoin de l'index dans le traitement (la variable i est donc nécessaire).

Suis-je le seul à ne rien comprendre quand je lis les "nouvelles" syntaxes ?

Je suppose que tu parle notamment de la syntaxe du nouveau for qui est, il est vrai, pas très explicite mais on s'y fait vite (en tout cas moi je l'utilise dès que j'en ai l'occasion ).

[le y@m's]

Je sais pas si ces tests sont très significatifs mais le for étendue prenait tjrs plus de temps...
Bye ^^

Non ces test ne sont pas significatifs, modifie l'ordre des boucles et tu veras que le première est toujours plus longue .

[bouye]

Disons que s'ils l'avaient appelé foreach au lieu de for cela aurait été plus clair pour tout le monde.
Je n'ai pas trop regardé le bytecode généré mais j'imagine très bien que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for(Truc truc : trucList) {
  ...
}

doit donner une fois compilé, un bytecode à 90~100% similaire à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for (Iterator<Truc> it = trucList.iterator() ; it.hasNext() ; ) {
  Truc truc = it.next();
   ...
}

ou (pour les versions pre 1.5) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for (Iterator it = trucList.iterator() ; it.hasNext() ; ) {
  Truc truc = (Truc)it.next();
   ...
}

Donc à priori (à vérifier) il y a au moins création d'un objet au départ et appel de deux méthodes à chque itération par rapport à une boucle classique (mais bon il faut quand même allouer un entier pour stocker l'index sans parler des vérifications de bornes). Mais ca ne devrait pas être une source de trop gros ralentissements.

[Djakisback]

Bin en fait j'avais mis une quinzaine de boucles (d'où les sTime1, 2, 3, etc.) et mélangé l'ordre des traitements plusieurs fois et le for étendue était toujours le plus long. Le plus court était pratiquement tout le temps la taille en dur, quelque soit l'ordre. D'ailleurs ca m'a étonné, size() ne fait pas juste retourner un int stocké ? enfin j'en ai conclu que size() recalculait à chaque fois la taille. Mais bon, je dérive du post, désolé ^^

[adiGuba]

Salut,

Disons que s'ils l'avaient appelé foreach au lieu de for cela aurait été plus clair pour tout le monde.

Cela aurait été plus clair en effet... Tout cela pour ne pas ajouter un nouveau mot*clef...

doit donner une fois compilé, un bytecode à 90~100% similaire à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for (Iterator<Truc> it = trucList.iterator() ; it.hasNext() ; ) {
  Truc truc = it.next();
   ...
}

Oui il y a de forte chance (sauf pour les tableaux "standard" où il doit y avoir un accès par index). D'ailleurs les boucles "foreach" fonctionnent avec n'importe quel classe qui implémente la nouvelle interface Iterable qui définit la méthode iterator()...

Mais ca ne devrait pas être une source de trop gros ralentissements.

Cela dépend de l'implémentation. En terme de performance, l'Iterator (et donc la boucle "foreach") est un bon compromis pour le parcours des collections, en laissant l'implémentation du parcours à la charge de la classe collection...

En effet, même si un parcours par index est bien plus performant sur un Vector ou une ArrayList qu'un Iterator, il peut être catastrophique sur une LinkedList, car on peut avoir à parcourir un grand nombre d'élément avant d'arriver à l'index souhaité...

Si on a vraiment besoin de grosse performance, on peut utiliser l'interface marqueur RamdomAccess qui indique qu'on peut accéder rapidement aux index de la liste, par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
List<String> list = ...
 
if (list instanceof RandomAccess) {
    /* Le parcours direct par index est plus performant */
    for (int i=0; i<list.size(); i++) {
        String s = list.get(i);
        ...
    }
} else {
    /* Le parcours par Iterator est plus rapide */
    for (String s : list) {
        ...
    }
}

enfin j'en ai conclu que size() recalculait à chaque fois la taille. Mais bon, je dérive du post, désolé ^^

Je pense plutôt que c'est l'appel de méthode qui est couteux. On peut optimiser cela en copiant la taille dans une variable locale....


Toutefois dans la plupart des cas la différence entre un parcours via index ou via itérator est bien minime... Il est donc préférable de passer via le foreach si pratique

a++

[mavina]

Bonsoir à tous,

je parcourais le forum java comme à mon habitude, lorsque par mégarde je tombe 2 fois de suite sur des sujets contenant les codes de java 5.0 Tiger (generics) avec des ArrayList<String> , et des for(String: ArrayList) et j'en passe et des pires.

Un effroi me parcours soudainement la peau du dos :
Est-on condamné à ne plus voir de bonne vieille boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for(int i = 0;i < maListe.size(); i++)
{}

et nos bons vieux Vector ou ArrayList non pré-typé ??

Salut,

Rien ne t'empeche en fait d'utiliser la version "classique" du for, et ce meme en 5.0. Le seul problème est que si l'on te donne un tourne-vis éléctrique, pourquoi continuer à tourner à la main ?

Pour moi, java 5.0 apporte, malgré le mot clé foreach qui aurait été préférable, une énorme dose de simplicité et de compréhension. De plus, il apporte une façon d'avoir des collections typées, et donc de ne plus se tromper dans des casts rébarbatifs, rebutants et très lourds dans leur écriture.

Suis-je le seul à ne rien comprendre quand je lis les "nouvelles" syntaxes ?


Help !

Eh bien écoute, c'est vrai qu'au début ca peut parraitre déroutant, surtout quand tu viens d'un langage comme le C++ ...
Mais, comme dit la pub, L'essayer, c'est l'adopter.

Bien à vous

mavina

[adiGuba]

Pour vous familiarisez avec Java 5.0, vous pouvez toujours jeter un coup d'oeil sur la présentation de Lionel Roux : Tiger: la révolution de Java 5

a++

[bouye]

Eh bien écoute, c'est vrai qu'au début ca peut parraitre déroutant, surtout quand tu viens d'un langage comme le C++ ...

Suis pas d'accord meme si c'est vrai que cela depend de quelle version de C++ tu parles.

La syntaxe des Collections + Generics est quand meme relativement similaire a celle de la STL + templates y compris au niveau des boucles sur les iterator. Le foreach est un peu a part mais une fois qu'on a compris qu'il ne s'agit que de sucre syntaxique pour cacher une manipulation d'iterateur (ou quelques chose d'equivalent)...

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <list>
#include "Truc.h"
 
using std;
 
list<Truc&> trucList;
...
for (list<Truc&>::iterator it = trucList.begin(); it != trucList.end() ; it++) {
  Truc &truc = *it;
  ...
}

ou un truc du genre en esperant ne pas trop avoir ecrit de betises, mon C++ etant plutot rouille ces temps-ci.

[mavina]

moui je suis pas spécialiste du C++, et personnellement je trouve plus accessible le foreach de Java que celui de C++, rien qu'au niveau de l'écriture...
Ton truc me fait froid dans le dos

Fred

[Regis.C]

moui je suis pas spécialiste du C++, et personnellement je trouve plus accessible le []foreach[/i] de Java que celui de C++, rien qu'au niveau de l'écriture...
Ton truc me fait froid dans le dos

Fred

Je te rassure mavina, j'ai quelques notions en C++ et cela me fait le même effet !!
VIVE JAVA, MORT AU ROI !!!..heu....pardon, un moment d'égarement.

[jollyy]

Le for classique est tjs utile lorsqu'on a besoin de l'indice:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
int[] tab1={1,2,3};
int[] tab2=new int[tab1.length];
 
for(int i=0; i<tab1.length; i++){
   tab2[i]=traitementAPartirDe(tab1[i]);
}