src/java.base/share/classes/java/util/Vector.java

rev 54801 : [mq]: 8223593-Refactor-code-for-reallocating-storage

*** 1,7 ****
  /*
!  * Copyright (c) 1994, 2018, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
--- 1,7 ----
  /*
!  * Copyright (c) 1994, 2019, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
*** 30,39 ****
--- 30,41 ----
  import java.io.StreamCorruptedException;
  import java.util.function.Consumer;
  import java.util.function.Predicate;
  import java.util.function.UnaryOperator;
  
+ import jdk.internal.util.ArraysSupport;
+ 
  /**
   * The {@code Vector} class implements a growable array of
   * objects. Like an array, it contains components that can be
   * accessed using an integer index. However, the size of a
   * {@code Vector} can grow or shrink as needed to accommodate
*** 240,304 ****
                  grow(minCapacity);
          }
      }
  
      /**
-      * The maximum size of array to allocate (unless necessary).
-      * Some VMs reserve some header words in an array.
-      * Attempts to allocate larger arrays may result in
-      * OutOfMemoryError: Requested array size exceeds VM limit
-      */
-     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
- 
-     /**
       * Increases the capacity to ensure that it can hold at least the
       * number of elements specified by the minimum capacity argument.
       *
       * @param minCapacity the desired minimum capacity
       * @throws OutOfMemoryError if minCapacity is less than zero
       */
      private Object[] grow(int minCapacity) {
!         return elementData = Arrays.copyOf(elementData,
!                                            newCapacity(minCapacity));
      }
  
      private Object[] grow() {
          return grow(elementCount + 1);
      }
  
      /**
-      * Returns a capacity at least as large as the given minimum capacity.
-      * Will not return a capacity greater than MAX_ARRAY_SIZE unless
-      * the given minimum capacity is greater than MAX_ARRAY_SIZE.
-      *
-      * @param minCapacity the desired minimum capacity
-      * @throws OutOfMemoryError if minCapacity is less than zero
-      */
-     private int newCapacity(int minCapacity) {
-         // overflow-conscious code
-         int oldCapacity = elementData.length;
-         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
-                                          capacityIncrement : oldCapacity);
-         if (newCapacity - minCapacity <= 0) {
-             if (minCapacity < 0) // overflow
-                 throw new OutOfMemoryError();
-             return minCapacity;
-         }
-         return (newCapacity - MAX_ARRAY_SIZE <= 0)
-             ? newCapacity
-             : hugeCapacity(minCapacity);
-     }
- 
-     private static int hugeCapacity(int minCapacity) {
-         if (minCapacity < 0) // overflow
-             throw new OutOfMemoryError();
-         return (minCapacity > MAX_ARRAY_SIZE) ?
-             Integer.MAX_VALUE :
-             MAX_ARRAY_SIZE;
-     }
- 
-     /**
       * Sets the size of this vector. If the new size is greater than the
       * current size, new {@code null} items are added to the end of
       * the vector. If the new size is less than the current size, all
       * components at index {@code newSize} and greater are discarded.
       *
--- 242,270 ----
                  grow(minCapacity);
          }
      }
  
      /**
       * Increases the capacity to ensure that it can hold at least the
       * number of elements specified by the minimum capacity argument.
       *
       * @param minCapacity the desired minimum capacity
       * @throws OutOfMemoryError if minCapacity is less than zero
       */
      private Object[] grow(int minCapacity) {
!         int oldCapacity = elementData.length;
!         int newCapacity = ArraysSupport.newCapacity(oldCapacity,
!                 minCapacity - oldCapacity,
!                 capacityIncrement > 0 ? capacityIncrement : oldCapacity);
!         return elementData = Arrays.copyOf(elementData, newCapacity);
      }
  
      private Object[] grow() {
          return grow(elementCount + 1);
      }
  
      /**
       * Sets the size of this vector. If the new size is greater than the
       * current size, new {@code null} items are added to the end of
       * the vector. If the new size is less than the current size, all
       * components at index {@code newSize} and greater are discarded.
       *