详解Java的 ArrayList

1
/**
2
 * Constructs an empty list with the specified initial capacity.
3
 *
4
 * @param  initialCapacity  the initial capacity of the list
5
 * @throws IllegalArgumentException if the specified initial capacity
6
 *         is negative
7
 */
8
public ArrayList(int initialCapacity) {
9
    if (initialCapacity > 0) {
10
        this.elementData = new Object[initialCapacity];
11
    } else if (initialCapacity == 0) {
12
        this.elementData = EMPTY_ELEMENTDATA;
13
    } else {
14
        throw new IllegalArgumentException("Illegal Capacity: "+
15
                                            initialCapacity);
16
    }
17
}
18

19
/**
20
 * Constructs an empty list with an initial capacity of ten.
21
 */
22
public ArrayList() {
23
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
24
}
25

26
/**
27
 * Constructs a list containing the elements of the specified
28
 * collection, in the order they are returned by the collection's
29
 * iterator.
30
 *
31
 * @param c the collection whose elements are to be placed into this list
32
 * @throws NullPointerException if the specified collection is null
33
 */
34
public ArrayList(Collection<? extends E> c) {
35
    Object[] a = c.toArray();
36
    if ((size = a.length) != 0) {
37
        if (c.getClass() == ArrayList.class) {
38
            elementData = a;
39
        } else {
40
            elementData = Arrays.copyOf(a, size, Object[].class);
41
        }
42
    } else {
43
        // replace with empty array.
44
        elementData = EMPTY_ELEMENTDATA;
45
    }
46
}

1
/**
2
 * Increases the capacity to ensure that it can hold at least the
3
 * number of elements specified by the minimum capacity argument.
4
 *
5
 * @param minCapacity the desired minimum capacity
6
 * @throws OutOfMemoryError if minCapacity is less than zero
7
 */
8
private Object[] grow(int minCapacity) {
9
    int oldCapacity = elementData.length;
10
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
11
        int newCapacity = ArraysSupport.newLength(oldCapacity,
12
                minCapacity - oldCapacity, /* minimum growth */
13
                oldCapacity >> 1           /* preferred growth */);
14
        return elementData = Arrays.copyOf(elementData, newCapacity);
15
    } else {
16
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
17
    }
18
}

1
public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
2
    // preconditions not checked because of inlining
3
    // assert oldLength >= 0
4
    // assert minGrowth > 0
5

6
    int prefLength = oldLength + Math.max(minGrowth, prefGrowth); // might overflow
7
    if (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) {
8
        return prefLength;
9
    } else {
10
        // put code cold in a separate method
11
        return hugeLength(oldLength, minGrowth);
12
    }
13
}
14

15
private static int hugeLength(int oldLength, int minGrowth) {
16
    int minLength = oldLength + minGrowth;
17
    if (minLength < 0) { // overflow
18
        throw new OutOfMemoryError(
19
            "Required array length " + oldLength + " + " + minGrowth + " is too large");
20
    } else if (minLength <= SOFT_MAX_ARRAY_LENGTH) {
21
        return SOFT_MAX_ARRAY_LENGTH;
22
    } else {
23
        return minLength;
24
    }
25
}

1
@java.io.Serial
2
private void writeObject(java.io.ObjectOutputStream s)
3
    throws java.io.IOException {
4
    // Write out element count, and any hidden stuff
5
    int expectedModCount = modCount;
6
    s.defaultWriteObject();
7

8
    // Write out size as capacity for behavioral compatibility with clone()
9
    s.writeInt(size);
10

11
    // Write out all elements in the proper order.
12
    for (int i=0; i<size; i++) {
13
        s.writeObject(elementData[i]);
14
    }
15

16
    if (modCount != expectedModCount) {
17
        throw new ConcurrentModificationException();
18
    }
19
}