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

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

Comment puis-je écrire une forboucle qui parcourt chacune de ces enumvaleurs?

.values()

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

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

Cette values()méthode est implicitement déclarée par le compilateur . Il n'est donc pas répertorié dans le Enumdoc.

Toutes les constantes d'un type enum peuvent être obtenues en appelant la public static T[] values()méthode implicite de ce type:

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

Vous pouvez le faire comme suit:

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

Ruisseaux

Avant Java 8

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

Java 8

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

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

Pourquoi forEachOrderedet non forEachavec des streams?

Le comportement de forEachest explicitement non déterministe alors que le forEachOrderedeffectue 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. forEachNe garantit donc pas que la commande sera conservée.

De plus, 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 est un dont le résultat dépend de tout état qui pourrait changer pendant l'exécution du pipeline de flux.

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 de planification des threads, tandis qu'avec une expression lambda sans état, les résultats seraient toujours les mêmes.

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

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

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

}

Si vous ne vous souciez pas de la commande, cela devrait fonctionner:

Set<Direction> directions = EnumSet.allOf(Direction.class);
for(Direction direction : directions) {
    // do stuff
}

    for (Direction  d : Direction.values()) {
       //your code here   
    }

Java8

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

de Java5 +

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

Essayez d'utiliser un pour chacun

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

Plus de méthodes dans java 8:

Utilisation EnumSetavecforEach

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

Utilisation Arrays.asListavecforEach

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