Existe-t-il une manière élégante de faire quelque chose au dernier élément d'une boucle for-each en Java?

Question

J'utilise Java 6.

Supposons que j'ai un groupe de chats à nourrir, et supposons que myCats est trié.

for (Cat cat : myCats) { 

    feedDryFood(cat); 

    //if this is the last cat (my favorite), give her a tuna 
    if (...) 
     alsoFeedTuna(cat); 
} 

et je voulais traiter mon dernier chat spécialement. Y at-il un moyen de le faire élégamment dans la boucle?

La seule façon dont je peux penser est de les compter.

En revenant un peu en arrière pour une image plus large, existe-t-il un langage de programmation qui supporte cette petite fonctionnalité dans une boucle for-each?

Answer 1

Si vous avez besoin pour ce faire, la meilleure approche pourrait être d'utiliser un Iterator. A part ça, vous devez compter. Le iterator a une méthode

hasNext() 

que vous pouvez utiliser pour déterminer si vous êtes sur le dernier élément de vos itérations.

EDIT - Pour une meilleure lisibilité, vous pouvez faire quelque chose comme ce qui suit dans la boucle à base de iterator (psuedo):

Cat cat = iter.next(); 
feedDryFood(cat); 

boolean shouldGetTuna = !iter.hasNext(); 
if (shouldGetTuna) 
    alsoFeedTuna(cat) 

qui est un code assez auto-documenté par l'utilisation intelligente des noms de variables.

Answer 2

Je le ferais en dehors de la boucle. La sémantique entière d'une boucle foreach est que vous faites la même chose à chaque objet. Dans cette étape, vous traitez un objet différemment. Pour moi, il semble plus raisonnable de le faire en dehors de la boucle.

De plus, les seuls moyens que je pouvais penser à le faire à l'intérieur sont horriblement aki ...

Answer 3

Cat cat; 

for (cat : myCats) { 
    feedDryFood(cat); 
} 

alsoFeedTuna(cat); 

Answer 4

Je pense que la meilleure chose serait de mettre un indicateur sur le chat, isFavoured, ou peut-être un membre statique de la classe Cat qui pointe vers le favori (mais cette façon, vous ne pouvez avoir un favori). Ensuite, il suffit de regarder l'indicateur lorsque vous parcourez la boucle. Après tout, les chats ne mangent pas toujours dans le même ordre. ;)

for (Cat cat : myCats) { 

    feedDryFood(cat); 

    if (cat.isFavoured) 
     alsoFeedTuna(cat); 
} 

Alternativement, vous pouvez convertir ensuite la liste à un tableau, puis il serait facile de savoir quand vous arrivez à la dernière - mais si le dernier n'est pas votre favori?

//only a rough idea, may not compile/run perfectly 
catArray = cats.toArray(cats); 
for (int i = 0 ; i < catArray.length(); i++){ 
    feedDryFood(catArray [i]); 

    //check for last cat. 
    if (i == catArray.length()-1) 
     alsoFeedTuna(catArray [i]); 
} 

---

On ne sait pas qui est plus important: pour le dernier chat pour obtenir le thon ou pour le chat favori pour obtenir le thon. Ou ... est le dernier chat le favori, par définition d'être dernier? Précisez s'il vous plaît!

Answer 5

Il n'y a pas de moyen clair de le faire dans la boucle for-each, mais un moyen simple serait d'utiliser directement un itérateur (le for-each cache l'itérateur).

Answer 6

Y a-t-il une raison pour laquelle vous ne pouvez pas utiliser une construction en boucle normale avec un compteur et un test pour sa position? Ce n'est pas comme si l'utilisation de la syntaxe foreach était inélégante par défaut. Si vous utilisez la construction foreach, alors je serais d'accord avec l'itérateur.

Answer 7

et supposons que myCats est trié

Trier dans l'ordre décroissant de favoritisme au lieu de l'ordre croissant, ou inverser la liste avant itérer

for (Cat cat in catsWithFavouriteFirst) 
{ 
    cat.feed(dryFood); 
    if (!tunaTin.isEmpty()) 
    { 
     cat.feed(tunaTin.getTunaOut()); 
    } 
} 

Answer 8

En ce qui concerne la question de savoir si une les langages de programmation supportent cette fonctionnalité, le Template Toolkit de Perl fait:

[% FOR cat IN cats; feedDryFood(cat); alsoFeedTuna(cat) IF loop.last; END %] 

Answer 9

@ solution de fbcocq

Comment était-ce une mauvaise solution? Ajoutez simplement une autre variable locale.

Cat lastCat = null; 

for (Cat cat : myCats) { 
    feedDryFood(cat); 
    lastCat = cat; 
} 

alsoFeedTuna(lastCat); 

Modifier: set null premier à prendre en charge les cas où myCats ne fixe pas lastCat

Answer 10

Si c'est un comportement spécial qui doit arriver le dernier élément de la boucle, il devrait avoir lieu à l'extérieur la boucle et vous devez fournir moyen de laisser l'information échapper à la boucle:

Cat lastCat = null; 
for (Cat cat : cats) 
{ 
    // do something for each cat 
    lastCat = cat; 
} 

if (lastCat != null) 
{ 
    // do something special to last cat 
} 

Je recommande de transférer les blocs de ces deux déclarations sur les méthodes.

Answer 11

Utilisez directement l'itérateur.

Cat cat 
Iterator<Cat> i = myCats.iterator() 
while (i.hasNext()) 
{ 
    cat = i.next() 
    feedDryFood(cat); 
    if (!i.hasNext()) 
    { 
     alsoFeedTuna(cat); // Last cat. 
    } 
} 

Answer 12

Quelque chose de très simple, vous pouvez faire cela rend explicite que le dernier chat est le favori et devrait obtenir le thon est d'obtenir simplement le dernier chat par index et lui donner le thon après avoir donné tous les chats aliments secs.

Cat favorite = myCats.get(myCats.size() - 1); 
alsoFeedTuna(favorite); 

C'est rapide et très bien si vous utilisez un List qui implémente RandomAccess comme un ArrayList. Si vous utilisez une structure non RandomAccess comme un LinkedList, ce serait lent, mais vous pouvez voir la liste comme Deque au lieu et à écrire:

Cat favorite = myCats.getLast(); 

Vous avez bien sûr besoin de faire en sorte que myCats ISN » t vide pour le faire.

Answer 13

for(Iterator<Cat> iter = cats.iterator() ; iter.hasNext();) 
    { 
     Cat cat = iter.next(); 
     feedDryFood(cat); 
     if(!iter.hasNext()) 
      alsoFeedTuna(cat); 
    } 

Answer 14

la construction for...each n'est pas l'outil approprié à utiliser pour obtenir le comportement spécifique que vous êtes après que la question est formulée, sans avoir plus de fonctionnalités dans l'objet Cat. Le Iterator classique est conçu pour fournir ce type de fonctionnalité. Je pense que la question illustre que la conception est défectueuse, plus sur ce dernier. En supposant qu'il existe une liste triée de chats appelée cats. Un List qui ne garantit pas l'ordre de traversée ne serait pas un bon candidat pour l'itération, quelle que soit la manière dont la liste est traversée.

final Iterator<Cat> iterator = cats.iterator(); 
while (iterator.hasNext()) 
{ 
    final Cat cat = iterator.next(); 
    this.feedDryCatFood(cat); 
    // special case, if there are no more cats in the list 
    // feed the last one tuna as well. 
    if (!iterator.hasNext()) 
    { 
     this.alsoFeedTuna(cat); 
    } 
} 

une meilleure solution serait d'avoir une méthode membre sur Cat. Cat.isSpecial() qui renvoie un boolean.Cela serait plus auto-documenté et déplacer le comportement hors de la construction de la boucle. Vous pouvez ensuite utiliser une construction for...each avec un test simple, autonome et auto-documenté.

if (cat.isSpecial()) 
{ 
    this.feedTuna(cat); 
} 

Je pense que le « dernier élément d'une boucle for..each » dans la question est un faux problème. Je pense que le problème est plus un problème de conception qu'un problème de logique métier, et le fait que la boucle for...each ne puisse pas accepter la règle indique qu'un refactoring doit avoir lieu.

Cette nouvelle conception pourrait également accueillir plusieurs chats «spéciaux» sans aucune complication au code.

D'autres solutions orientées objet plus élégantes seraient le Visitor Pattern ou le Chain of Responsibility Pattern. Le modèle de visiteur résumerait la logique de qui est le favori du Cat et de l'implémentation du visiteur. Pareil avec la chaîne de responsabilité. Avoir une chaîne de CatFeeder objets, et laissez-les décider si «gérer» l'alimentation ou le transmettre sur la chaîne. Dans les deux cas, ce serait un couplage plus lâche et une cohésion plus serrée.

Answer 15

Je suggère de ne pas utiliser une boucle foreach et de mettre la méthode feedTuna en dehors de la boucle.

int i = 0; 
for(i = 0; i < cat.length; i++){ 
    feedDryFood(cat[i]); 
} 
if(cat.length != 0){ 
    feedTuna(cat[i - 1]); 
} 

Cela évite d'autres affectations ou conditions dans la boucle.