Déclaration de variables à l'intérieur d'une boucle

Question

Un dilemme auquel j'ai été confronté tout au long de la programmation concerne la déclaration des variables dans une boucle. Dire que je dois faire quelque chose comme ce qui suit:

List list=myObject.getList(); 
Iterator itr=list.iterator(); 
while (itr.hasNext()){ 
    BusinessObject myBo=(BusinessObject)itr.next(); 
    process(myBo); 
} 

Dans l'extrait ci-dessus, devrait myBo être déclarée en dehors de la boucle ou ne déclarant à l'intérieur de la boucle ne causer des dommages à la mémoire et la performance?

Answer 1

myBo est simplement une référence à un objet (qui est renvoyé par itr.next()). En tant que tel, la quantité de mémoire dont il a besoin est très petite, et seulement créée une fois, et l'ajouter à l'intérieur de la boucle ne devrait pas affecter votre programme. IMO, en le déclarant dans la boucle où il est utilisé, aide réellement à le rendre plus lisible.

Answer 2

La déclaration à l'intérieur de la boucle ne causera aucun dommage à la mémoire et aux performances.

Answer 3

Si possible, utilisez List<BusinessObject> et Iterator<BusinessObject> pour éviter la coulée:

List<BusinessObject> list = myObject.getList(); 
Iterator<BusinessObject> itr = list.iterator(); 

while (itr.hasNext()) { 
    process(itr.next()); 
} 

Answer 4

Un principe de conception de logiciels est de limiter la portée des variables locales, à savoir les déclarer juste à temps dans un bloc qui se termine peu de temps après la dernière utilisation de cette variable. Cela n'affecte pas les performances ou d'autres aspects "durs", mais rend le programme plus lisible et plus facile à analyser. En résumé, faire ce que vous faites est considéré comme BON.

Answer 5

Si court - no. En C++ cela pourrait poser un problème si myBo est créé en copiant mais en Java il y a toujours des références utilisées, n'est-ce pas?

Answer 6

La référence temporaire myBo est placée sur la pile et doit être optimisée pour l'essentiel. Il ne devrait pas y avoir de pénalité de performance dans votre code.

Answer 7

La solution la plus élégante pour votre boucle serait une améliorée boucle (Java 5 ou plus récent):

List<BusinessObject> list = myObject.getList(); 

for(BusinessObject myBo : list) { 
    process(myBo); 
} 

Mais même avec le code pourvu qu'il n'y ait pas de problème de performance, parce que toutes les variables temporaires ne contenir que des références au BusinessObject, ce qui est très bon marché.

Answer 8

Cela ne cause aucun dommage à la mémoire.

BTW à moins que vous omettre un code que vous pouvez ignorer la déclaration tout à fait:

while (itr.hasNext()){ 
    //BusinessObject myBo=(BusinessObject)itr.next(); 
    process((BusinessObject)itr.next()); 
} 

Answer 9

Juste un coup d'oeil sur le code d'octets avec javap -c [ClassName]. Voici une classe montrant quelques exemples de variables à usage unique avec des boucles. La décharge de bytecode est pertinente dans les commentaires:

class HelloWorldLoopsAnnotated { 
    // 
    // HelloWorldLoopsAnnotated(); 
    // Code: 
    // 0: aload_0 
    // 1: invokespecial #1; //Method java/lang/Object."<init>":()V 
    // 4: return 
    //////////////////////////////////////////////////////////////////////////// 

    void stringDeclaredInsideLoop(){ 
     while (true) { 
      // 0: ldC#2; //String Hello World! 
      String greeting = "Hello World!"; 
      doNothing(greeting); 
     } 
    } 
    // 
    // void stringDeclaredInsideLoop(); 
    // Code: 
    // 0: ldC#2; //String Hello World! 
    // 2: astore_1 
    // 3: aload_0 
    // 4: aload_1 
    // 5: invokespecial #3; //Method doNothing:(Ljava/lang/String;)V 
    // 8: goto 0 
    //////////////////////////////////////////////////////////////////////////// 

    void stringDeclaredOutsideLoop(){ 
     String greeting; 
     while (true) { 
      greeting = "Hello World!"; 
      doNothing(greeting); 
     } 
    } 
    // 
    // void stringDeclaredOutsideLoop(); 
    // Code: 
    // 0: ldC#2; //String Hello World! 
    // 2: astore_1 
    // 3: aload_0 
    // 4: aload_1 
    // 5: invokespecial #3; //Method doNothing:(Ljava/lang/String;)V 
    // 8: goto 0 
    //////////////////////////////////////////////////////////////////////////// 

    void stringAsDirectArgument(){ 
     while (true) { 
      doNothing("Hello World!"); 
     } 
    } 
    // void stringAsDirectArgument(); 
    // Code: 
    // 0: aload_0 
    // 1: ldC#2; //String Hello World! 
    // 3: invokespecial #3; //Method doNothing:(Ljava/lang/String;)V 
    // 6: goto 0 
    //////////////////////////////////////////////////////////////////////////// 

    private void doNothing(String s) { 
    } 
} 

stringDeclaredInsideLoop() et stringDeclaredOutsideLoop() rendement identique bytecode six instruction. stringDeclaredInsideLoop() gagne toujours: portée limitée est le meilleur.Après quelques réflexions, je ne vois pas vraiment comment le serrage pourrait affecter les performances: des données identiques dans la pile nécessiteraient des instructions identiques.

stringAsDirectArgument(), cependant, définit l'opération dans seulement quatre instructions. Les environnements à faible mémoire (par exemple, mon téléphone magnifiquement stupide) peuvent apprécier l'optimisation alors qu'un collègue lisant votre code ne peut pas, alors exercez votre jugement avant de raser les octets de votre code.

Voir le full gist pour plus.