Ho un enumin Java per le direzioni cardinali e intermedie:

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

Come posso scrivere un forciclo che scorre attraverso ciascuno di questi enumvalori?

.values()

Puoi chiamare il values()metodo sul tuo enum.

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

Questo values()metodo è implicitamente dichiarato dal compilatore . Quindi non è elencato su Enumdoc.

Tutte le costanti di un tipo enum possono essere ottenute chiamando il public static T[] values()metodo implicito di quel tipo:

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

Puoi farlo come segue:

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

Flussi

Prima di Java 8

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

Java 8

Possiamo anche utilizzare lambda e stream ( Tutorial ):

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

Perché forEachOrderede non forEachcon i flussi?

Il comportamento di forEach è esplicitamente non deterministico dove come forEachOrderedesegue un'azione per ciascun elemento di questo flusso, nell'ordine di incontro del flusso se il flusso ha un ordine di incontro definito. Quindi forEachnon garantisce che l'ordine verrà mantenuto.

Inoltre, quando si lavora con flussi (in particolare quelli paralleli), tenere presente la natura dei flussi. Secondo il documento :

I risultati della pipeline del flusso possono essere non deterministici o errati se i parametri comportamentali per le operazioni del flusso sono stateful. Un lambda con stato è uno il cui risultato dipende da qualsiasi stato che potrebbe cambiare durante l'esecuzione della pipeline del flusso.

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

In questo caso, se l'operazione di mappatura viene eseguita in parallelo, i risultati per lo stesso input potrebbero variare da un'esecuzione all'altra, a causa delle differenze di pianificazione del thread, mentre, con un'espressione lambda senza stato, i risultati sarebbero sempre gli stessi.

Gli effetti collaterali nei parametri comportamentali per le operazioni di streaming sono, in generale, scoraggiati, poiché spesso possono portare a involontarie violazioni del requisito di apolidia, nonché ad altri pericoli per la sicurezza dei thread.

Gli stream possono avere o meno un ordine di incontro definito. Il fatto che uno stream abbia o meno un ordine di incontro dipende dalla sorgente e dalle operazioni intermedie.

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

}

Se non ti interessa l'ordine, dovrebbe funzionare:

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);

da Java5 +

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

Prova a usare a per ciascuno

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

Altri metodi in java 8:

Usando EnumSetconforEach

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

Usando Arrays.asListconforEach

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