ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/Vector.java
(Generate patch)

Comparing jsr166/src/main/java/util/Vector.java (file contents):
Revision 1.53 by jsr166, Mon Oct 1 00:10:53 2018 UTC vs.
Revision 1.57 by jsr166, Thu Oct 10 16:53:08 2019 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright (c) 1994, 2018, Oracle and/or its affiliates. All rights reserved.
2 > * Copyright (c) 1994, 2019, Oracle and/or its affiliates. All rights reserved.
3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4   *
5   * This code is free software; you can redistribute it and/or modify it
# Line 32 | Line 32 | import java.util.function.Consumer;
32   import java.util.function.Predicate;
33   import java.util.function.UnaryOperator;
34  
35 + import jdk.internal.util.ArraysSupport;
36 +
37   /**
38   * The {@code Vector} class implements a growable array of
39   * objects. Like an array, it contains components that can be
# Line 100 | Line 102 | public class Vector<E>
102       *
103       * @serial
104       */
105 +    @SuppressWarnings("serial") // Conditionally serializable
106      protected Object[] elementData;
107  
108      /**
# Line 122 | Line 125 | public class Vector<E>
125      protected int capacityIncrement;
126  
127      /** use serialVersionUID from JDK 1.0.2 for interoperability */
128 +    // OPENJDK @java.io.Serial
129      private static final long serialVersionUID = -2767605614048989439L;
130  
131      /**
# Line 242 | Line 246 | public class Vector<E>
246      }
247  
248      /**
245 –     * The maximum size of array to allocate (unless necessary).
246 –     * Some VMs reserve some header words in an array.
247 –     * Attempts to allocate larger arrays may result in
248 –     * OutOfMemoryError: Requested array size exceeds VM limit
249 –     */
250 –    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
251 –
252 –    /**
249       * Increases the capacity to ensure that it can hold at least the
250       * number of elements specified by the minimum capacity argument.
251       *
# Line 257 | Line 253 | public class Vector<E>
253       * @throws OutOfMemoryError if minCapacity is less than zero
254       */
255      private Object[] grow(int minCapacity) {
256 <        return elementData = Arrays.copyOf(elementData,
257 <                                           newCapacity(minCapacity));
256 >        int oldCapacity = elementData.length;
257 >        int newCapacity = ArraysSupport.newLength(oldCapacity,
258 >                minCapacity - oldCapacity, /* minimum growth */
259 >                capacityIncrement > 0 ? capacityIncrement : oldCapacity
260 >                                           /* preferred growth */);
261 >        return elementData = Arrays.copyOf(elementData, newCapacity);
262      }
263  
264      private Object[] grow() {
# Line 266 | Line 266 | public class Vector<E>
266      }
267  
268      /**
269 –     * Returns a capacity at least as large as the given minimum capacity.
270 –     * Will not return a capacity greater than MAX_ARRAY_SIZE unless
271 –     * the given minimum capacity is greater than MAX_ARRAY_SIZE.
272 –     *
273 –     * @param minCapacity the desired minimum capacity
274 –     * @throws OutOfMemoryError if minCapacity is less than zero
275 –     */
276 –    private int newCapacity(int minCapacity) {
277 –        // overflow-conscious code
278 –        int oldCapacity = elementData.length;
279 –        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
280 –                                         capacityIncrement : oldCapacity);
281 –        if (newCapacity - minCapacity <= 0) {
282 –            if (minCapacity < 0) // overflow
283 –                throw new OutOfMemoryError();
284 –            return minCapacity;
285 –        }
286 –        return (newCapacity - MAX_ARRAY_SIZE <= 0)
287 –            ? newCapacity
288 –            : hugeCapacity(minCapacity);
289 –    }
290 –
291 –    private static int hugeCapacity(int minCapacity) {
292 –        if (minCapacity < 0) // overflow
293 –            throw new OutOfMemoryError();
294 –        return (minCapacity > MAX_ARRAY_SIZE) ?
295 –            Integer.MAX_VALUE :
296 –            MAX_ARRAY_SIZE;
297 –    }
298 –
299 –    /**
269       * Sets the size of this vector. If the new size is greater than the
270       * current size, new {@code null} items are added to the end of
271       * the vector. If the new size is less than the current size, all
# Line 1190 | Line 1159 | public class Vector<E>
1159       * @throws ClassNotFoundException if the stream contains data
1160       *         of a non-existing class
1161       */
1162 +    // OPENJDK @java.io.Serial
1163      private void readObject(ObjectInputStream in)
1164              throws IOException, ClassNotFoundException {
1165          ObjectInputStream.GetField gfields = in.readFields();
# Line 1211 | Line 1181 | public class Vector<E>
1181       * @param s the stream
1182       * @throws java.io.IOException if an I/O error occurs
1183       */
1184 +    // OPENJDK @java.io.Serial
1185      private void writeObject(java.io.ObjectOutputStream s)
1186              throws java.io.IOException {
1187          final java.io.ObjectOutputStream.PutField fields = s.putFields();
# Line 1411 | Line 1382 | public class Vector<E>
1382              es[i] = operator.apply(elementAt(es, i));
1383          if (modCount != expectedModCount)
1384              throw new ConcurrentModificationException();
1385 +        // TODO(8203662): remove increment of modCount from ...
1386 +        modCount++;
1387          // checkInvariants();
1388      }
1389  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines