场景:假设，我们有固定数量的纸牌类型。 每种卡类型都有费用和与之相关的加入奖金。

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

}

现在在其他类中访问enum。在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
    }

}
}

输出:

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

java 8中的更多方法:

使用EnumSet和forEach

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

使用数组。asList with forEach

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

如果你不关心顺序，这应该工作:

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

枚举类型的所有常量都可以通过调用该类型的隐式公共静态T[] values()方法来获得:

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

Java8

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

从Java5 +

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

流

Java 8之前

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

Java 8

我们也可以使用lambda和streams(教程):

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

为什么在流中forEachOrdered而不是forEach ?

forEach的行为是显式的不确定的，其中forEachOrdered为流的每个元素执行一个操作，如果流具有定义的遇到顺序，则按照流的遇到顺序执行。因此forEach并不保证顺序会被保持。

另外，当使用流(尤其是并行流)时，请记住流的性质。根据文件:

如果流操作的行为参数是有状态的，则流管道结果可能是不确定的或不正确的。有状态lambda的结果取决于流管道执行过程中可能改变的任何状态。

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

在这里，如果映射操作是并行执行的，由于线程调度的差异，同一输入的结果在不同的运行中可能会有所不同，而使用无状态lambda表达式，结果总是相同的。

流操作的行为参数的副作用通常是不鼓励的，因为它们经常会导致不知情地违反无状态要求，以及其他线程安全危害。

流可能有也可能没有定义的遇到顺序。流是否有遇到顺序取决于源和中间操作。