web-dev-qa-db-fra.com

Une boucle 'pour' pour parcourir une énumération dans Java

J'ai un enum dans Java pour les directions cardinales et intermédiaires:

public enum Direction {
   NORTH,
   NORTHEAST,
   EAST,
   SOUTHEAST,
   SOUTH,
   SOUTHWEST,
   WEST,
   NORTHWEST
}

Comment puis-je écrire une boucle for qui parcourt chacune de ces valeurs enum?

javaenumsfor-loop
837
Nick Meyer

.values()

Vous pouvez appeler la méthode values() sur votre enum.

for (Direction dir : Direction.values()) {
  // do what you want
}

Cette méthode values() est implicitement déclarée par le compilateur . Donc, il ne figure pas dans la liste Enum doc.

1359
notnoop

Enum # valeurs ():

 for (Direction d : Direction.values()) {
     System.out.println(d);
 }
124
dfa

Vous pouvez le faire comme suit:

for (Direction direction : EnumSet.allOf(Direction.class)) {
  // do stuff
}
60
toluju

Ruisseaux

Avant Java 8

for (Direction dir : Direction.values()) {
            System.out.println(dir);
}

Java 8

Nous pouvons également utiliser lambda et les flux ( Tutorial ):

Stream.of(Direction.values()).forEachOrdered(System.out::println);

Pourquoi forEachOrdered et non forEach avec des flux?

Le comportement de forEach est explicitement non déterministe, étant donné que forEachOrdered exécute une action pour chaque élément de ce flux, dans l'ordre de rencontre du flux si le flux a un ordre de rencontre défini. Donc, forEach ne garantit pas que la commande sera conservée.

Aussi, lorsque vous travaillez avec des flux (en particulier des flux parallèles), gardez à l'esprit la nature des flux. Selon le doc :

Les résultats du pipeline de flux peuvent être non déterministes ou incorrects si les paramètres de comportement des opérations de flux sont avec état. Un lambda avec état en est un dont le résultat dépend de tout état susceptible de changer pendant l'exécution du pipeline.

Set<Integer> seen = Collections.synchronizedSet(new HashSet<>());
stream.parallel().map(e -> { if (seen.add(e)) return 0; else return e; })...

Ici, si l'opération de mappage est effectuée en parallèle, les résultats pour la même entrée peuvent varier d'une exécution à l'autre, en raison de différences d'ordonnancement de threads, alors que, avec une expression lambda sans état, les résultats seraient toujours les mêmes.

Les effets secondaires des paramètres comportementaux sur les opérations de flux sont, en général, découragés, car ils peuvent souvent conduire à des violations involontaires de l'exigence d'apatridie, ainsi qu'à d'autres risques liés à la sécurité du thread.

Les flux peuvent avoir ou non un ordre de rencontre défini. Le fait qu'un flux ait ou non un ordre de rapprochement dépend de la source et des opérations intermédiaires.

40
i_am_zero
for(Direction dir : Direction.values())
{

}
21
user101884

Si vous ne vous souciez pas de l'ordre, cela devrait marcher:

Set<Direction> directions = EnumSet.allOf(Direction.class);
for(Direction direction : directions) {
    // do stuff
}
19
Tom Jefferys
    for (Direction  d : Direction.values()) {
       //your code here   
    }
18
akf

Essayez d'utiliser un pour chaque

for ( Direction direction : Direction.values()){
  System.out.println(direction.toString());
}
5
Irazza

Java8

Stream.of(Direction.values()).forEach(System.out::println);

de Java5 +

for ( Direction d: Direction.values()){
 System.out.println(d);
}
5
Raghu K Nair

Plus de méthodes dans Java 8:

Utiliser EnumSet avec forEach

EnumSet.allOf(Direction.class).forEach(...);

Utiliser Arrays.asList avec forEach

Arrays.asList(Direction.values()).forEach(...);
4
NiVeR