A for-loop to iterate over an enum in Java

Question

I have an enum in Java for the cardinal and intermediate directions:

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

How can I write a for loop that iterates through each of these enum values?

Answer 1

.values()

You can call the values() method on your enum.

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

This values() method is implicitly declared by the compiler. So it is not listed on Enum doc.

Answer 2

All the constants of an enum type can be obtained by calling the implicit public static T[] values() method of that type:

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

Answer 3

You can do this as follows:

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

Answer 4

Streams

Prior to Java 8

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

Java 8

We can also make use of lambda and streams (Tutorial):

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

---

Why forEachOrdered and not forEach with streams ?

The behaviour of forEach is explicitly nondeterministic where as the forEachOrdered performs an action for each element of this stream, in the encounter order of the stream if the stream has a defined encounter order. So forEach does not guarantee that the order would be kept.

Also when working with streams (especially parallel ones) keep in mind the nature of streams. As per the doc:

Stream pipeline results may be nondeterministic or incorrect if the behavioral parameters to the stream operations are stateful. A stateful lambda is one whose result depends on any state which might change during the execution of the stream pipeline.

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

Here, if the mapping operation is performed in parallel, the results for the same input could vary from run to run, due to thread scheduling differences, whereas, with a stateless lambda expression the results would always be the same.

Side-effects in behavioral parameters to stream operations are, in general, discouraged, as they can often lead to unwitting violations of the statelessness requirement, as well as other thread-safety hazards.

Streams may or may not have a defined encounter order. Whether or not a stream has an encounter order depends on the source and the intermediate operations.

Answer 5

If you don't care about the order this should work:

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

Answer 6

Java8

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

from Java5+

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

Answer 7

More methods in java 8:

Using EnumSet with forEach

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

Using Arrays.asList with forEach

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

Answer 8

we can use a filter(JAVA 8) like this.

Stream.of(Direction.values()).filter(name -> !name.toString().startsWith("S")).forEach(System.out::println);

Answer 9

Scenario: Let's say, we have a fixed number of card types. Each card type has fees and a joining bonus associated with it.

package enumPkg;

public enum CardTypes {
//Each enum is object
DEBIT(10,20),
CREDIT(0,10),
CRYPTO(5,30);

//Object properties
int fees;
int bonus;

//Initilize object using constructor
CardTypes(int fee, int bonus){
    this.fees = fee;
    this.bonus = bonus;
}

//access object property
public int getFees(){
    return this.fees;
}

public int getBonus(){
    return this.bonus;
}

}

Now to access enum in other class. Follow the below process in java:

package enumPkg;

public class EnumClass {
public static void main(String[] args) {
    CardTypes cardType = CardTypes.CREDIT; //Each enum element is public static final, when accessed returns a object
    System.out.println(cardType);

    System.out.println("Debit card fees : "+CardTypes.DEBIT.getFees());
    System.out.println("Debit card bonus : "+CardTypes.DEBIT.getBonus());

    CardTypes[] cardTypes = CardTypes.values();//return array of CardTypes i.e all enum elements we have defined

    for (CardTypes type : CardTypes.values()) {
        System.out.println(type); //particular enum object
        System.out.println(type.ordinal()); //return enum position
        System.out.println("Bonus : "+type.getBonus()); //return enum object property: Bonus
        System.out.println("Fees  : "+type.getFees());//return enum object property: Fees
    }

}
}

Output:

CREDIT
Debit card fees : 10
Debit card bonus : 20
DEBIT
0
Bonus : 20
Fees  : 10
CREDIT
1
Bonus : 10
Fees  : 0
CRYPTO
2
Bonus : 30
Fees  : 5