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

Comparing jsr166/src/main/java/util/ArrayList.java (file contents):
Revision 1.66 by jsr166, Thu May 2 14:31:30 2019 UTC vs.
Revision 1.68 by jsr166, Sat Aug 10 16:48:05 2019 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
2 > * Copyright (c) 1997, 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 29 | Line 29 | import java.util.function.Consumer;
29   import java.util.function.Predicate;
30   import java.util.function.UnaryOperator;
31   // OPENJDK import jdk.internal.access.SharedSecrets;
32 + import jdk.internal.util.ArraysSupport;
33  
34   /**
35   * Resizable-array implementation of the {@code List} interface.  Implements
# Line 219 | Line 220 | public class ArrayList<E> extends Abstra
220      }
221  
222      /**
222 –     * The maximum size of array to allocate (unless necessary).
223 –     * Some VMs reserve some header words in an array.
224 –     * Attempts to allocate larger arrays may result in
225 –     * OutOfMemoryError: Requested array size exceeds VM limit
226 –     */
227 –    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
228 –
229 –    /**
223       * Increases the capacity to ensure that it can hold at least the
224       * number of elements specified by the minimum capacity argument.
225       *
# Line 234 | Line 227 | public class ArrayList<E> extends Abstra
227       * @throws OutOfMemoryError if minCapacity is less than zero
228       */
229      private Object[] grow(int minCapacity) {
230 <        return elementData = Arrays.copyOf(elementData,
231 <                                           newCapacity(minCapacity));
230 >        int oldCapacity = elementData.length;
231 >        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
232 >            int newCapacity = ArraysSupport.newLength(oldCapacity,
233 >                    minCapacity - oldCapacity, /* minimum growth */
234 >                    oldCapacity >> 1           /* preferred growth */);
235 >            return elementData = Arrays.copyOf(elementData, newCapacity);
236 >        } else {
237 >            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
238 >        }
239      }
240  
241      private Object[] grow() {
# Line 243 | Line 243 | public class ArrayList<E> extends Abstra
243      }
244  
245      /**
246 –     * Returns a capacity at least as large as the given minimum capacity.
247 –     * Returns the current capacity increased by 50% if that suffices.
248 –     * Will not return a capacity greater than MAX_ARRAY_SIZE unless
249 –     * the given minimum capacity is greater than MAX_ARRAY_SIZE.
250 –     *
251 –     * @param minCapacity the desired minimum capacity
252 –     * @throws OutOfMemoryError if minCapacity is less than zero
253 –     */
254 –    private int newCapacity(int minCapacity) {
255 –        // overflow-conscious code
256 –        int oldCapacity = elementData.length;
257 –        int newCapacity = oldCapacity + (oldCapacity >> 1);
258 –        if (newCapacity - minCapacity <= 0) {
259 –            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
260 –                return Math.max(DEFAULT_CAPACITY, minCapacity);
261 –            if (minCapacity < 0) // overflow
262 –                throw new OutOfMemoryError();
263 –            return minCapacity;
264 –        }
265 –        return (newCapacity - MAX_ARRAY_SIZE <= 0)
266 –            ? newCapacity
267 –            : hugeCapacity(minCapacity);
268 –    }
269 –
270 –    private static int hugeCapacity(int minCapacity) {
271 –        if (minCapacity < 0) // overflow
272 –            throw new OutOfMemoryError();
273 –        return (minCapacity > MAX_ARRAY_SIZE)
274 –            ? Integer.MAX_VALUE
275 –            : MAX_ARRAY_SIZE;
276 –    }
277 –
278 –    /**
246       * Returns the number of elements in this list.
247       *
248       * @return the number of elements in this list
# Line 571 | Line 538 | public class ArrayList<E> extends Abstra
538          if (to > es.length) {
539              throw new ConcurrentModificationException();
540          }
541 <        Iterator<?> oit = other.iterator();
541 >        var oit = other.iterator();
542          for (; from < to; from++) {
543              if (!oit.hasNext() || !Objects.equals(es[from], oit.next())) {
544                  return false;

Diff Legend

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