Java的枚舉

版權聲明：本文系博主原創，未經博主許可，禁止轉載。保留所有權利。

引用網址：https://www.cnblogs.com/zhizaixingzou/p/10050579.html

 

目錄

 

1. 枚舉

1.1. 枚舉的概念

在我們網購的過程中，訂單在某個時刻將始終處於幾種狀態中的一種，它們分別為待付款、已取消、已付款、已發貨、交易完成、已退貨等。類似這樣的例子還有很多，即在描述某個事物時，它的屬性總是可列舉並且可能值是固定且有窮的，所謂枚舉，就是列舉出所有可能的值的過程。可以看到，枚舉是個動詞，然而其要義則是得到目標集合，所以直接將此目標集合划為重點，也叫枚舉了，此時它是一個名詞，用來描述事物屬性的范圍。

1.2. 枚舉的引入

枚舉類型是在JDK1.5引入的。

 

在此之前，描述枚舉的現象是通過常量實現的，如仍以訂單狀態為例，則1代表待付款、2代表已取消、3代表已付款、4代表已發貨、5代表交易完成、6代表已退貨等。總之，我們要將枚舉在整數范圍內做一個映射，並不直觀。作為彌補，往往要寫注釋或文檔，描述什么數字代表什么狀態。

 

我們知道，程序設計的要點在於更精確地模擬現實世界，而引入枚舉達到了這個目的。引入后，我們只需要將可能用到的值集合在一起，而不用映射一個更大范圍的集合，而且描述上也更加地體現自注釋，因而也更好，這就是引入枚舉的初衷。

1.3. 枚舉的常規使用

這里定義一個打印接口。

package com.cjw.learning.enumeration;

public interface Printer {
    void println();
}

 

這里為前面講的訂單狀態定義一個枚舉類型。

package com.cjw.learning.enumeration;

public enum OrderStatus implements Printer {
    UNPAID("unpaid", "goods are ready, wait to be paid"),
    CANCELED("canceled", "goods are ready, but canceled at last"),
    PAID("paid", "goods are payed"),
    SHIPPED("shipped", "goods are in the way"),
    DOWN("down", "goods are accepted by buyer"),
    REFUNDED("refunded", "goods are returned for some reason");

    private String id;
    private String description;

    OrderStatus(String id, String description) {
        this.id = id;
        this.description = description;
    }

    public static OrderStatus fromId(String id) {
        for (OrderStatus orderStatus : values()) {
            if (orderStatus.id.equals(id)) {
                return orderStatus;
            }
        }
        return null;
    }

    public String getId() {
        return id;
    }

    public String getDescription() {
        return description;
    }

    public void println() {
        System.out.println(toString());
    }

    @Override
    public String toString() {
        return "OrderStatus [ id = " + id + ", description = " + description + "]";
    }
}

 

枚舉的使用。

package com.cjw.learning.enumeration;

public class Demo01 {
    private static void process(OrderStatus orderStatus) {
        switch (orderStatus) {
            case UNPAID:
                // do something.
                break;
            case CANCELED:
                // do something.
                break;
            case PAID:
                // do something.
                break;
            case SHIPPED:
                // do something.
                break;
            case DOWN:
                // do something.
                break;
            case REFUNDED:
                // do something.
                break;
            default:
                throw new IllegalArgumentException("Unknown status");
        }
    }

    public static void main(String[] args) {
        process(OrderStatus.fromId(args[0]));
    }
}

 

枚舉可以實現接口。

如果枚舉類型要添加自定義方法，則枚舉常量的定義必須放在最前面。

枚舉常量的標識符全大寫，如果是幾個單詞組成則單詞間使用下划線分隔。

對於枚舉值的判斷，使用switch是極為自然的，此語法在JDK1.6引入。

枚舉的公共基類是默認的，是java.lang.Enum。

枚舉的構造方法默認是私有的。

 

每個枚舉常量還可以重寫父類的方法，定義自己的方法，只是此時的枚舉常量實際上是枚舉的子類了，而且是匿名子類。

1.4. 枚舉的公共基類java.lang.Enum

1.4.1. 源碼解析

Enum定義如下。

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {

 

枚舉實現了Comparable接口，不同枚舉比較的前提是兩個枚舉值同類型，比較的結果依照其在枚舉類型中定義的順序。

public final int compareTo(E o) {
    Enum<?> other = (Enum<?>)o;
    Enum<E> self = this;
    if (self.getClass() != other.getClass() && // optimization
        self.getDeclaringClass() != other.getDeclaringClass())
        throw new ClassCastException();
    return self.ordinal - other.ordinal;
}

 

判斷兩個同類型的枚舉值是否相等，可以直接用==號，equals方法等價。

public final boolean equals(Object other) {
    return this==other;
}

 

枚舉常量是單例的，為了保證這點，枚舉直接不支持克隆方法。

protected final Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
}

 

根據枚舉類型和枚舉值名稱得到枚舉常量。

public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                            String name) {
    T result = enumType.enumConstantDirectory().get(name);
    if (result != null)
        return result;
    if (name == null)
        throw new NullPointerException("Name is null");
    throw new IllegalArgumentException(
        "No enum constant " + enumType.getCanonicalName() + "." + name);
}

進一步跟蹤代碼，返回值乃是根據枚舉值名稱查詢Map<枚舉值名稱, 枚舉常量>得到。

Map<String, T> enumConstantDirectory() {
    if (enumConstantDirectory == null) {
        T[] universe = getEnumConstantsShared();
        if (universe == null)
            throw new IllegalArgumentException(
                getName() + " is not an enum type");
        Map<String, T> m = new HashMap<>(2 * universe.length);
        for (T constant : universe)
            m.put(((Enum<?>)constant).name(), constant);
        enumConstantDirectory = m;
    }
    return enumConstantDirectory;
}

而此Map實際上是通過指定的枚舉類型的反射調用values方法得到的數組轉換而來。

T[] getEnumConstantsShared() {
    if (enumConstants == null) {
        if (!isEnum()) return null;
        try {
            final Method values = getMethod("values");
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction<Void>() {
                    public Void run() {
                            values.setAccessible(true);
                            return null;
                        }
                    });
            @SuppressWarnings("unchecked")
            T[] temporaryConstants = (T[])values.invoke(null);
            enumConstants = temporaryConstants;
        }
        // These can happen when users concoct enum-like classes
        // that don't comply with the enum spec.
        catch (InvocationTargetException | NoSuchMethodException |
               IllegalAccessException ex) { return null; }
    }
    return enumConstants;
}

1.4.2. java.lang.Enum的使用實例

package com.cjw.learning.enumeration;

public class Demo02 {
    public static void main(String[] args) {
        for (OrderStatus orderStatus : OrderStatus.values()) {
            System.out.println(orderStatus.name() + ": " + orderStatus.ordinal());

        }

        OrderStatus unpaid = OrderStatus.fromId("paid");
        System.out.println(unpaid == OrderStatus.PAID);
        // 這里調用equals方法時讓枚舉常量在前，而非枚舉變量在前，乃是一種好習慣：可以避免拋空指針異常。
        System.out.println(OrderStatus.PAID.equals(unpaid));

        System.out.println(OrderStatus.UNPAID.compareTo(OrderStatus.PAID));
        System.out.println(OrderStatus.PAID.compareTo(OrderStatus.PAID));

        System.out.println(Enum.valueOf(OrderStatus.class, "PAID"));
        System.out.println(OrderStatus.valueOf("PAID"));
    }
}

輸出如下：

1.5. 專為枚舉設計的集合類

1.5.1. Key為枚舉的Map：java.util.EnumMap

1.5.1.1. Key為枚舉類型

它的Key必須來自同一個枚舉類型，當Map創建時指定。

public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
    implements java.io.Serializable, Cloneable

1.5.1.2. 存儲結構

如下分別存儲枚舉類型、所有枚舉常量數組、Map的值集合（個數與枚舉常量數一致，數組索引號即枚舉常量的定義順序）、Map當前的大小（為某個枚舉常量放入了值，則加一，反之則減一）。

private final Class<K> keyType;
private transient K[] keyUniverse;
private transient Object[] vals;
private transient int size = 0;

1.5.1.3. 創建實例

定義實例。

public EnumMap(Class<K> keyType) {
    this.keyType = keyType;
    keyUniverse = getKeyUniverse(keyType);
    vals = new Object[keyUniverse.length];
}

此時會初始化Key的類型等值，可以看到值集合全為null，表示Map為空。

1.5.1.4. 存入鍵值對（null封裝的巧妙）

在添加鍵值對時，首先檢查Key是否是創建時指定的枚舉類型，接着將值封裝后存入指定的位置，對應的舊值如果是null，則大小加一，表示存入值了。

public V put(K key, V value) {
    typeCheck(key);

    int index = key.ordinal();
    Object oldValue = vals[index];
    vals[index] = maskNull(value);
    if (oldValue == null)
        size++;
    return unmaskNull(oldValue);
}

可以看到，一般的Map的大小是動態增減的，而EnumMap不是，而是一開始就創建了指定枚舉常量數的數組。區分是否添加了值，是通過為null還是不為null來的，而真正存放null，則是通過封裝為NULL來表示的，這是一個技巧。

private static final Object NULL = new Object() {
    public int hashCode() {
        return 0;
    }

    public String toString() {
        return "java.util.EnumMap.NULL";
    }
};

存入時，如果為null，則存NULL，以區別於沒有存放null值。

private Object maskNull(Object value) {
    return (value == null ? NULL : value);
}

讀取時，如果得到的NULL，則表示之前存入的是null值。

private V unmaskNull(Object value) {
    return (V)(value == NULL ? null : value);
}

1.5.1.5. 讀取鍵對應的值

首先檢查鍵的類型，如果不對，則返回null。否則返回值，如果沒有為它賦過值，它為null，如果為它賦過值，如果是NULL，則還是返回null，否則返回對應的值。

public V get(Object key) {
    return (isValidKey(key) ?
            unmaskNull(vals[((Enum<?>)key).ordinal()]) : null);
}

1.5.1.6. 刪除鍵對應的值

public V remove(Object key) {
    if (!isValidKey(key))
        return null;
    int index = ((Enum<?>)key).ordinal();
    Object oldValue = vals[index];
    vals[index] = null;
    if (oldValue != null)
        size--;
    return unmaskNull(oldValue);
}

1.5.1.7. 總結

此Map的結構和原理在上面已經講清，其他方法都自然而然可以推導。

 

清除：

public void clear() {
    Arrays.fill(vals, null);
    size = 0;
}

 

獲取Map大小：

public int size() {
    return size;
}

 

是否包含指定的鍵：

public boolean containsKey(Object key) {
    return isValidKey(key) && vals[((Enum<?>)key).ordinal()] != null;
}

 

是否包含指定的值：

public boolean containsValue(Object value) {
    value = maskNull(value);

    for (Object val : vals)
        if (value.equals(val))
            return true;

    return false;
}

 

可以看到，此Map內部呈現為數組，數組是大小固定為枚舉常量數的。通過元素值是否為null來區分是否為指定的枚舉常量鍵指定了值，而在此前提下為了支持null值的存儲，對null進行了封裝，正如其方面名一樣，“給null帶上面具”。總之，EnumMap相對一般Map是緊湊而高效的。

 

另外，多提一句，此類被聲明為可序列化的，但它使用了名為序列化代理的特性，關於該特性的具體描述見講解序列化的章節。

1.5.2. 只存枚舉的Set：java.util.EnumSet

1.5.2.1. EnumSet的使用實例

下面是EnumSet的主要使用方法（當然，它本身是個Set，因而也有Set的方法，只是這里只講專屬於它的方法）。

package com.cjw.learning.enumeration;

import java.util.Collection;
import java.util.EnumSet;
import java.util.stream.Collectors;

public class Demo03 {
    private static Collection<String> listNames(EnumSet<OrderStatus> orderStatuses) {
        return orderStatuses.stream().map(OrderStatus::name).collect(Collectors.toList());
    }

    public static void main(String[] args) {
        EnumSet<OrderStatus> enumSet01 = EnumSet.noneOf(OrderStatus.class);
        System.out.println("noneOf：" + listNames(enumSet01));

        enumSet01.add(OrderStatus.UNPAID);
        enumSet01.add(OrderStatus.PAID);
        System.out.println("add：" + listNames(enumSet01));

        EnumSet<OrderStatus> enumSet02 = EnumSet.complementOf(enumSet01);
        System.out.println("complementOf：" + listNames(enumSet02));

        EnumSet<OrderStatus> enumSet03 = EnumSet.allOf(OrderStatus.class);
        System.out.println("allOf：" + listNames(enumSet03));

        EnumSet<OrderStatus> enumSet04 = EnumSet.copyOf(enumSet03);
        System.out.println("copyOf：" + listNames(enumSet04));

        EnumSet<OrderStatus> enumSet05 = EnumSet.of(OrderStatus.UNPAID, OrderStatus.CANCELED, OrderStatus.PAID);
        System.out.println("of：" + listNames(enumSet05));

        EnumSet<OrderStatus> enumSet06 = EnumSet.range(OrderStatus.CANCELED, OrderStatus.DOWN);
        System.out.println("range：" + listNames(enumSet06));
    }
}

程序輸出：

1.5.2.2. EnumSet的實現原理

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
    implements Cloneable, java.io.Serializable

 

EnumSet含如下字段：

final Class<E> elementType;
final Enum<?>[] universe;

其中，elementType指存放的枚舉的類型，universe則為存儲枚舉的數組，EnumSet一創建就存了全部的枚舉常量。后面看到，Set上的增減並不在這個字段上體現。

 

下面是創建空EnumSet的方法。

public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
    Enum<?>[] universe = getUniverse(elementType);
    if (universe == null)
        throw new ClassCastException(elementType + " not an enum");

    if (universe.length <= 64)
        return new RegularEnumSet<>(elementType, universe);
    else
        return new JumboEnumSet<>(elementType, universe);
}

下面是創建包含全部枚舉常量EnumSet的方法。

public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType) {
    EnumSet<E> result = noneOf(elementType);
    result.addAll();
    return result;
}

可以看到EnumSet的具體實現是由兩個子類承擔的。

 

如果枚舉常量的個數不超過64個，就使用RegularEnumSet子類實現。

這里的elements是一個64位存儲的long型，它就是實際用於Set存儲的字段。如果Set中含有某個枚舉常量，該枚舉常量的定義序數為ordinal，那么該long型值第ordinal位低位為1。

 

而如果枚舉常量的個數超過64個，就使用JumboEnumSet子類實現。它存儲枚舉常量使用的是如下字段：

private long elements[];

可以看到，是long的數組。它仍舊是一個比特對應一個枚舉常量。

1.6. 枚舉的實現原理

通過OrderStatus的字節碼，可以看到枚舉類型包含了該類型的幾個常量，和這些常量的數組$VALUES，$VALUES編譯器生成的私有靜態字段。

 

也看到生成了公共方法values，它返回$VALUES的克隆結果。

而根據枚舉常量名稱生成枚舉常量的valueOf方法，則借助了Enum的valueOf方法。

 

另外，靜態初始化方法會收集枚舉類型中定義的靜態語句執行，該方法創建了指定的幾個枚舉常量，並將它們存進數組$VALUES。可以看到，前面幾個常量，都是生成了OrderStatus對象后，調用其含4參的<init>，是私有的構造方法，最后一個枚舉常量仍然是OrderStatus類型，但實例化用的是它的匿名子類，該匿名子類也是用含4參的<init>。

 

OrderStatus含4參（分別對應name、ordinal和兩個自定義的字段）的<init>，實際上內部會調用枚舉的默認私有的含2參的構造方法。

 

OrderStatus匿名子類含4參的<init>，最后調用OrderStatus含5參的<init>。

而OrderStatus含5參（另一參為匿名子類實例）的<init>由調用其含4參的<init>，實際上在OrderStatus中，匿名子類的實例沒有用到，所以指定為null的。

1.7. 參考資料

JDK 1.8源碼

http://blog.lichengwu.cn/java/2011/09/26/the-usage-of-enum-in-java/

https://blog.csdn.net/javazejian/article/details/71333103