详解Java的 不可变集合工厂方法of()

1
//  List
2
static final class List12<E> extends AbstractImmutableList<E>
3
        implements Serializable {
4

5
    @Stable
6
    private final E e0;
7

8
    @Stable
9
    private final Object e1;
10

11
    List12(E e0) {
12
        this.e0 = Objects.requireNonNull(e0);
13
        // Use EMPTY as a sentinel for an unused element: not using null
14
        // enables constant folding optimizations over single-element lists
15
        this.e1 = EMPTY;
16
    }
17

18
    List12(E e0, E e1) {
19
        this.e0 = Objects.requireNonNull(e0);
20
        this.e1 = Objects.requireNonNull(e1);
21
    }
22

23
    @Override
24
    public int size() {
25
        return e1 != EMPTY ? 2 : 1;
26
    }
27
}
28
//  Map
29
static final class Map1<K,V> extends AbstractImmutableMap<K,V> {
30
    @Stable
31
    private final K k0;
32
    @Stable
33
    private final V v0;
34

35
    Map1(K k0, V v0) {
36
        this.k0 = Objects.requireNonNull(k0);
37
        this.v0 = Objects.requireNonNull(v0);
38
    }
39
}

1
static final class List12<E> extends AbstractImmutableList<E>
2
        implements Serializable {
3
    @java.io.Serial
4
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
5
        throw new InvalidObjectException("not serial proxy");
6
    }
7

8
    @java.io.Serial
9
    private Object writeReplace() {
10
        if (e1 == EMPTY) {
11
            return new CollSer(CollSer.IMM_LIST, e0);
12
        } else {
13
            return new CollSer(CollSer.IMM_LIST, e0, e1);
14
        }
15
    }
16
}

1
final class CollSer implements Serializable {
2
    @java.io.Serial
3
    private static final long serialVersionUID = 6309168927139932177L;
4

5
    static final int IMM_LIST       = 1;
6
    static final int IMM_SET        = 2;
7
    static final int IMM_MAP        = 3;
8
    static final int IMM_LIST_NULLS = 4;
9

10
    /**
11
     * Indicates the type of collection that is serialized.
12
     * The low order 8 bits have the value 1 for an immutable
13
     * {@code List}, 2 for an immutable {@code Set}, 3 for
14
     * an immutable {@code Map}, and 4 for an immutable
15
     * {@code List} that allows null elements.
16
     *
17
     * Any other value causes an
18
     * {@link InvalidObjectException} to be thrown. The high
19
     * order 24 bits are zero when an instance is serialized,
20
     * and they are ignored when an instance is deserialized.
21
     * They can thus be used by future implementations without
22
     * causing compatibility issues.
23
     *
24
     * <p>The tag value also determines the interpretation of the
25
     * transient {@code Object[] array} field.
26
     * For {@code List} and {@code Set}, the array's length is the size
27
     * of the collection, and the array contains the elements of the collection.
28
     * Null elements are not allowed. For {@code Set}, duplicate elements
29
     * are not allowed.
30
     *
31
     * <p>For {@code Map}, the array's length is twice the number of mappings
32
     * present in the map. The array length is necessarily even.
33
     * The array contains a succession of key and value pairs:
34
     * {@code k1, v1, k2, v2, ..., kN, vN.} Nulls are not allowed,
35
     * and duplicate keys are not allowed.
36
     *
37
     * @serial
38
     * @since 9
39
     */
40
    private final int tag;
41

42
    /**
43
     * @serial
44
     * @since 9
45
     */
46
    private transient Object[] array;
47

48

49
    CollSer(int t, Object... a) {
50
        tag = t;
51
        array = a;
52
    }
53

54
    /**
55
     * Reads objects from the stream and stores them
56
     * in the transient {@code Object[] array} field.
57
     *
58
     * @serialData
59
     * A nonnegative int, indicating the count of objects,
60
     * followed by that many objects.
61
     *
62
     * @param ois the ObjectInputStream from which data is read
63
     * @throws IOException if an I/O error occurs
64
     * @throws ClassNotFoundException if a serialized class cannot be loaded
65
     * @throws InvalidObjectException if the count is negative
66
     * @since 9
67
     */
68
    @java.io.Serial
69
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
70
        ois.defaultReadObject();
71
        int len = ois.readInt();
72

73
        if (len < 0) {
74
            throw new InvalidObjectException("negative length " + len);
75
        }
76

77
        SharedSecrets.getJavaObjectInputStreamAccess().checkArray(ois, Object[].class, len);
78
        Object[] a = new Object[len];
79
        for (int i = 0; i < len; i++) {
80
            a[i] = ois.readObject();
81
        }
82

83
        array = a;
84
    }
85

86
    /**
87
     * Writes objects to the stream from
88
     * the transient {@code Object[] array} field.
89
     *
90
     * @serialData
91
     * A nonnegative int, indicating the count of objects,
92
     * followed by that many objects.
93
     *
94
     * @param oos the ObjectOutputStream to which data is written
95
     * @throws IOException if an I/O error occurs
96
     * @since 9
97
     */
98
    @java.io.Serial
99
    private void writeObject(ObjectOutputStream oos) throws IOException {
100
        oos.defaultWriteObject();
101
        oos.writeInt(array.length);
102
        for (int i = 0; i < array.length; i++) {
103
            oos.writeObject(array[i]);
104
        }
105
    }
106

107
    private Object readResolve() throws ObjectStreamException {
108
        try {
109
            if (array == null) {
110
                throw new InvalidObjectException("null array");
111
            }
112

113
            // use low order 8 bits to indicate "kind"
114
            // ignore high order 24 bits
115
            switch (tag & 0xff) {
116
                case IMM_LIST:
117
                    return List.of(array);
118
                case IMM_LIST_NULLS:
119
                    return ImmutableCollections.listFromTrustedArrayNullsAllowed(
120
                            Arrays.copyOf(array, array.length, Object[].class));
121
                case IMM_SET:
122
                    return Set.of(array);
123
                case IMM_MAP:
124
                    if (array.length == 0) {
125
                        return ImmutableCollections.EMPTY_MAP;
126
                    } else if (array.length == 2) {
127
                        return new ImmutableCollections.Map1<>(array[0], array[1]);
128
                    } else {
129
                        return new ImmutableCollections.MapN<>(array);
130
                    }
131
                default:
132
                    throw new InvalidObjectException(String.format("invalid flags 0x%x", tag));
133
            }
134
        } catch (NullPointerException|IllegalArgumentException ex) {
135
            InvalidObjectException ioe = new InvalidObjectException("invalid object");
136
            ioe.initCause(ex);
137
            throw ioe;
138
        }
139
    }
140
}