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.26 by jsr166, Wed Jul 22 00:00:07 2009 UTC vs.
Revision 1.34 by jsr166, Sun Nov 13 19:58:47 2016 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright 1994-2008 Sun Microsystems, Inc.  All Rights Reserved.
2 > * Copyright (c) 1994, 2013, 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
6   * under the terms of the GNU General Public License version 2 only, as
7 < * published by the Free Software Foundation.  Sun designates this
7 > * published by the Free Software Foundation.  Oracle designates this
8   * particular file as subject to the "Classpath" exception as provided
9 < * by Sun in the LICENSE file that accompanied this code.
9 > * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# Line 18 | Line 18
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21 < * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 < * CA 95054 USA or visit www.sun.com if you need additional information or
23 < * have any questions.
21 > * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 > * or visit www.oracle.com if you need additional information or have any
23 > * questions.
24   */
25  
26   package java.util;
27  
28 + import java.util.function.Consumer;
29 + import java.util.function.Predicate;
30 + import java.util.function.UnaryOperator;
31 +
32   /**
33   * The {@code Vector} class implements a growable array of
34   * objects. Like an array, it contains components that can be
# Line 41 | Line 45 | package java.util;
45   * capacity of a vector before inserting a large number of
46   * components; this reduces the amount of incremental reallocation.
47   *
48 < * <p><a name="fail-fast"/>
48 > * <p id="fail-fast">
49   * The iterators returned by this class's {@link #iterator() iterator} and
50   * {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:
51   * if the vector is structurally modified at any time after the iterator is
# Line 52 | Line 56 | package java.util;
56   * concurrent modification, the iterator fails quickly and cleanly, rather
57   * than risking arbitrary, non-deterministic behavior at an undetermined
58   * time in the future.  The {@link Enumeration Enumerations} returned by
59 < * the {@link #elements() elements} method are <em>not</em> fail-fast.
59 > * the {@link #elements() elements} method are <em>not</em> fail-fast; if the
60 > * Vector is structurally modified at any time after the enumeration is
61 > * created then the results of enumerating are undefined.
62   *
63   * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
64   * as it is, generally speaking, impossible to make any hard guarantees in the
# Line 70 | Line 76 | package java.util;
76   * implementation is not needed, it is recommended to use {@link
77   * ArrayList} in place of {@code Vector}.
78   *
79 + * @param <E> Type of component elements
80 + *
81   * @author  Lee Boynton
82   * @author  Jonathan Payne
83   * @see Collection
84   * @see LinkedList
85 < * @since   JDK1.0
85 > * @since   1.0
86   */
87   public class Vector<E>
88      extends AbstractList<E>
# Line 166 | Line 174 | public class Vector<E>
174      public Vector(Collection<? extends E> c) {
175          elementData = c.toArray();
176          elementCount = elementData.length;
177 <        // c.toArray might (incorrectly) not return Object[] (see 6260652)
177 >        // defend against c.toArray (incorrectly) not returning Object[]
178 >        // (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
179          if (elementData.getClass() != Object[].class)
180              elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
181      }
# Line 222 | Line 231 | public class Vector<E>
231       * @param minCapacity the desired minimum capacity
232       */
233      public synchronized void ensureCapacity(int minCapacity) {
234 <        modCount++;
235 <        ensureCapacityHelper(minCapacity);
234 >        if (minCapacity > 0) {
235 >            modCount++;
236 >            if (minCapacity > elementData.length)
237 >                grow(minCapacity);
238 >        }
239 >    }
240 >
241 >    /**
242 >     * The maximum size of array to allocate (unless necessary).
243 >     * Some VMs reserve some header words in an array.
244 >     * Attempts to allocate larger arrays may result in
245 >     * OutOfMemoryError: Requested array size exceeds VM limit
246 >     */
247 >    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
248 >
249 >    /**
250 >     * Increases the capacity to ensure that it can hold at least the
251 >     * number of elements specified by the minimum capacity argument.
252 >     *
253 >     * @param minCapacity the desired minimum capacity
254 >     * @throws OutOfMemoryError if minCapacity is less than zero
255 >     */
256 >    private Object[] grow(int minCapacity) {
257 >        return elementData = Arrays.copyOf(elementData,
258 >                                           newCapacity(minCapacity));
259 >    }
260 >
261 >    private Object[] grow() {
262 >        return grow(elementCount + 1);
263      }
264  
265      /**
266 <     * This implements the unsynchronized semantics of ensureCapacity.
267 <     * Synchronized methods in this class can internally call this
268 <     * method for ensuring capacity without incurring the cost of an
233 <     * extra synchronization.
266 >     * Returns a capacity at least as large as the given minimum capacity.
267 >     * Will not return a capacity greater than MAX_ARRAY_SIZE unless
268 >     * the given minimum capacity is greater than MAX_ARRAY_SIZE.
269       *
270 <     * @see #ensureCapacity(int)
270 >     * @param minCapacity the desired minimum capacity
271 >     * @throws OutOfMemoryError if minCapacity is less than zero
272       */
273 <    private void ensureCapacityHelper(int minCapacity) {
273 >    private int newCapacity(int minCapacity) {
274 >        // overflow-conscious code
275          int oldCapacity = elementData.length;
276 <        if (minCapacity > oldCapacity) {
277 <            Object[] oldData = elementData;
278 <            int newCapacity = (capacityIncrement > 0) ?
279 <                (oldCapacity + capacityIncrement) : (oldCapacity * 2);
280 <            if (newCapacity < minCapacity) {
281 <                newCapacity = minCapacity;
282 <            }
283 <            elementData = Arrays.copyOf(elementData, newCapacity);
284 <        }
276 >        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
277 >                                         capacityIncrement : oldCapacity);
278 >        if (newCapacity - minCapacity <= 0) {
279 >            if (minCapacity < 0) // overflow
280 >                throw new OutOfMemoryError();
281 >            return minCapacity;
282 >        }
283 >        return (newCapacity - MAX_ARRAY_SIZE <= 0)
284 >            ? newCapacity
285 >            : hugeCapacity(minCapacity);
286 >    }
287 >
288 >    private static int hugeCapacity(int minCapacity) {
289 >        if (minCapacity < 0) // overflow
290 >            throw new OutOfMemoryError();
291 >        return (minCapacity > MAX_ARRAY_SIZE) ?
292 >            Integer.MAX_VALUE :
293 >            MAX_ARRAY_SIZE;
294      }
295  
296      /**
# Line 258 | Line 304 | public class Vector<E>
304       */
305      public synchronized void setSize(int newSize) {
306          modCount++;
307 <        if (newSize > elementCount) {
308 <            ensureCapacityHelper(newSize);
309 <        } else {
310 <            for (int i = newSize ; i < elementCount ; i++) {
265 <                elementData[i] = null;
266 <            }
267 <        }
307 >        if (newSize > elementData.length)
308 >            grow(newSize);
309 >        for (int i = newSize; i < elementCount; i++)
310 >            elementData[i] = null;
311          elementCount = newSize;
312      }
313  
# Line 303 | Line 346 | public class Vector<E>
346       * Returns an enumeration of the components of this vector. The
347       * returned {@code Enumeration} object will generate all items in
348       * this vector. The first item generated is the item at index {@code 0},
349 <     * then the item at index {@code 1}, and so on.
349 >     * then the item at index {@code 1}, and so on. If the vector is
350 >     * structurally modified while enumerating over the elements then the
351 >     * results of enumerating are undefined.
352       *
353       * @return  an enumeration of the components of this vector
354       * @see     Iterator
# Line 331 | Line 376 | public class Vector<E>
376       * Returns {@code true} if this vector contains the specified element.
377       * More formally, returns {@code true} if and only if this vector
378       * contains at least one element {@code e} such that
379 <     * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
379 >     * {@code Objects.equals(o, e)}.
380       *
381       * @param o element whose presence in this vector is to be tested
382       * @return {@code true} if this vector contains the specified element
# Line 344 | Line 389 | public class Vector<E>
389       * Returns the index of the first occurrence of the specified element
390       * in this vector, or -1 if this vector does not contain the element.
391       * More formally, returns the lowest index {@code i} such that
392 <     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
392 >     * {@code Objects.equals(o, get(i))},
393       * or -1 if there is no such index.
394       *
395       * @param o element to search for
# Line 360 | Line 405 | public class Vector<E>
405       * this vector, searching forwards from {@code index}, or returns -1 if
406       * the element is not found.
407       * More formally, returns the lowest index {@code i} such that
408 <     * <tt>(i&nbsp;&gt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
408 >     * {@code (i >= index && Objects.equals(o, get(i)))},
409       * or -1 if there is no such index.
410       *
411       * @param o element to search for
# Line 388 | Line 433 | public class Vector<E>
433       * Returns the index of the last occurrence of the specified element
434       * in this vector, or -1 if this vector does not contain the element.
435       * More formally, returns the highest index {@code i} such that
436 <     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
436 >     * {@code Objects.equals(o, get(i))},
437       * or -1 if there is no such index.
438       *
439       * @param o element to search for
# Line 404 | Line 449 | public class Vector<E>
449       * this vector, searching backwards from {@code index}, or returns -1 if
450       * the element is not found.
451       * More formally, returns the highest index {@code i} such that
452 <     * <tt>(i&nbsp;&lt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
452 >     * {@code (i <= index && Objects.equals(o, get(i)))},
453       * or -1 if there is no such index.
454       *
455       * @param o element to search for
# Line 468 | Line 513 | public class Vector<E>
513       * Returns the last component of the vector.
514       *
515       * @return  the last component of the vector, i.e., the component at index
516 <     *          <code>size()&nbsp;-&nbsp;1</code>.
516 >     *          {@code size() - 1}
517       * @throws NoSuchElementException if this vector is empty
518       */
519      public synchronized E lastElement() {
# Line 526 | Line 571 | public class Vector<E>
571       *         ({@code index < 0 || index >= size()})
572       */
573      public synchronized void removeElementAt(int index) {
529        modCount++;
574          if (index >= elementCount) {
575              throw new ArrayIndexOutOfBoundsException(index + " >= " +
576                                                       elementCount);
# Line 538 | Line 582 | public class Vector<E>
582          if (j > 0) {
583              System.arraycopy(elementData, index + 1, elementData, index, j);
584          }
585 +        modCount++;
586          elementCount--;
587          elementData[elementCount] = null; /* to let gc do its work */
588      }
# Line 566 | Line 611 | public class Vector<E>
611       *         ({@code index < 0 || index > size()})
612       */
613      public synchronized void insertElementAt(E obj, int index) {
569        modCount++;
614          if (index > elementCount) {
615              throw new ArrayIndexOutOfBoundsException(index
616                                                       + " > " + elementCount);
617          }
618 <        ensureCapacityHelper(elementCount + 1);
619 <        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
618 >        modCount++;
619 >        final int s = elementCount;
620 >        Object[] elementData = this.elementData;
621 >        if (s == elementData.length)
622 >            elementData = grow();
623 >        System.arraycopy(elementData, index,
624 >                         elementData, index + 1,
625 >                         s - index);
626          elementData[index] = obj;
627 <        elementCount++;
627 >        elementCount = s + 1;
628      }
629  
630      /**
# Line 590 | Line 640 | public class Vector<E>
640       */
641      public synchronized void addElement(E obj) {
642          modCount++;
643 <        ensureCapacityHelper(elementCount + 1);
594 <        elementData[elementCount++] = obj;
643 >        add(obj, elementData, elementCount);
644      }
645  
646      /**
# Line 626 | Line 675 | public class Vector<E>
675       * method (which is part of the {@link List} interface).
676       */
677      public synchronized void removeAllElements() {
629        modCount++;
678          // Let gc do its work
679          for (int i = 0; i < elementCount; i++)
680              elementData[i] = null;
681  
682 +        modCount++;
683          elementCount = 0;
684      }
685  
# Line 644 | Line 693 | public class Vector<E>
693      public synchronized Object clone() {
694          try {
695              @SuppressWarnings("unchecked")
696 <                Vector<E> v = (Vector<E>) super.clone();
696 >            Vector<E> v = (Vector<E>) super.clone();
697              v.elementData = Arrays.copyOf(elementData, elementCount);
698              v.modCount = 0;
699              return v;
700          } catch (CloneNotSupportedException e) {
701              // this shouldn't happen, since we are Cloneable
702 <            throw new InternalError();
702 >            throw new InternalError(e);
703          }
704      }
705  
# Line 678 | Line 727 | public class Vector<E>
727       * of the Vector <em>only</em> if the caller knows that the Vector
728       * does not contain any null elements.)
729       *
730 +     * @param <T> type of array elements. The same type as {@code <E>} or a
731 +     * supertype of {@code <E>}.
732       * @param a the array into which the elements of the Vector are to
733       *          be stored, if it is big enough; otherwise, a new array of the
734       *          same runtime type is allocated for this purpose.
735       * @return an array containing the elements of the Vector
736 <     * @throws ArrayStoreException if the runtime type of a is not a supertype
737 <     * of the runtime type of every element in this Vector
736 >     * @throws ArrayStoreException if the runtime type of a, {@code <T>}, is not
737 >     * a supertype of the runtime type, {@code <E>}, of every element in this
738 >     * Vector
739       * @throws NullPointerException if the given array is null
740       * @since 1.2
741       */
# Line 707 | Line 759 | public class Vector<E>
759          return (E) elementData[index];
760      }
761  
762 +    @SuppressWarnings("unchecked")
763 +    static <E> E elementAt(Object[] es, int index) {
764 +        return (E) es[index];
765 +    }
766 +
767      /**
768       * Returns the element at the specified position in this Vector.
769       *
# Line 744 | Line 801 | public class Vector<E>
801      }
802  
803      /**
804 +     * This helper method split out from add(E) to keep method
805 +     * bytecode size under 35 (the -XX:MaxInlineSize default value),
806 +     * which helps when add(E) is called in a C1-compiled loop.
807 +     */
808 +    private void add(E e, Object[] elementData, int s) {
809 +        if (s == elementData.length)
810 +            elementData = grow();
811 +        elementData[s] = e;
812 +        elementCount = s + 1;
813 +    }
814 +
815 +    /**
816       * Appends the specified element to the end of this Vector.
817       *
818       * @param e element to be appended to this Vector
# Line 752 | Line 821 | public class Vector<E>
821       */
822      public synchronized boolean add(E e) {
823          modCount++;
824 <        ensureCapacityHelper(elementCount + 1);
756 <        elementData[elementCount++] = e;
824 >        add(e, elementData, elementCount);
825          return true;
826      }
827  
# Line 761 | Line 829 | public class Vector<E>
829       * Removes the first occurrence of the specified element in this Vector
830       * If the Vector does not contain the element, it is unchanged.  More
831       * formally, removes the element with the lowest index i such that
832 <     * {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such
832 >     * {@code Objects.equals(o, get(i))} (if such
833       * an element exists).
834       *
835       * @param o element to be removed from this Vector, if present
# Line 792 | Line 860 | public class Vector<E>
860       * Shifts any subsequent elements to the left (subtracts one from their
861       * indices).  Returns the element that was removed from the Vector.
862       *
795     * @throws ArrayIndexOutOfBoundsException if the index is out of range
796     *         ({@code index < 0 || index >= size()})
863       * @param index the index of the element to be removed
864       * @return element that was removed
865 +     * @throws ArrayIndexOutOfBoundsException if the index is out of range
866 +     *         ({@code index < 0 || index >= size()})
867       * @since 1.2
868       */
869      public synchronized E remove(int index) {
# Line 852 | Line 920 | public class Vector<E>
920       * @throws NullPointerException if the specified collection is null
921       * @since 1.2
922       */
923 <    public synchronized boolean addAll(Collection<? extends E> c) {
856 <        modCount++;
923 >    public boolean addAll(Collection<? extends E> c) {
924          Object[] a = c.toArray();
925 +        modCount++;
926          int numNew = a.length;
927 <        ensureCapacityHelper(elementCount + numNew);
928 <        System.arraycopy(a, 0, elementData, elementCount, numNew);
929 <        elementCount += numNew;
930 <        return numNew != 0;
927 >        if (numNew == 0)
928 >            return false;
929 >        synchronized (this) {
930 >            Object[] elementData = this.elementData;
931 >            final int s = elementCount;
932 >            if (numNew > elementData.length - s)
933 >                elementData = grow(s + numNew);
934 >            System.arraycopy(a, 0, elementData, s, numNew);
935 >            elementCount = s + numNew;
936 >            return true;
937 >        }
938      }
939  
940      /**
# Line 870 | Line 945 | public class Vector<E>
945       * @return true if this Vector changed as a result of the call
946       * @throws ClassCastException if the types of one or more elements
947       *         in this vector are incompatible with the specified
948 <     *         collection (optional)
948 >     *         collection
949 >     * (<a href="Collection.html#optional-restrictions">optional</a>)
950       * @throws NullPointerException if this vector contains one or more null
951       *         elements and the specified collection does not support null
952 <     *         elements (optional), or if the specified collection is null
952 >     *         elements
953 >     * (<a href="Collection.html#optional-restrictions">optional</a>),
954 >     *         or if the specified collection is null
955       * @since 1.2
956       */
957 <    public synchronized boolean removeAll(Collection<?> c) {
958 <        return super.removeAll(c);
957 >    public boolean removeAll(Collection<?> c) {
958 >        Objects.requireNonNull(c);
959 >        return bulkRemove(e -> c.contains(e));
960      }
961  
962      /**
# Line 890 | Line 969 | public class Vector<E>
969       * @return true if this Vector changed as a result of the call
970       * @throws ClassCastException if the types of one or more elements
971       *         in this vector are incompatible with the specified
972 <     *         collection (optional)
972 >     *         collection
973 >     * (<a href="Collection.html#optional-restrictions">optional</a>)
974       * @throws NullPointerException if this vector contains one or more null
975       *         elements and the specified collection does not support null
976 <     *         elements (optional), or if the specified collection is null
976 >     *         elements
977 >     *         (<a href="Collection.html#optional-restrictions">optional</a>),
978 >     *         or if the specified collection is null
979       * @since 1.2
980       */
981 <    public synchronized boolean retainAll(Collection<?> c)  {
982 <        return super.retainAll(c);
981 >    public boolean retainAll(Collection<?> c) {
982 >        Objects.requireNonNull(c);
983 >        return bulkRemove(e -> !c.contains(e));
984 >    }
985 >
986 >    @Override
987 >    public boolean removeIf(Predicate<? super E> filter) {
988 >        Objects.requireNonNull(filter);
989 >        return bulkRemove(filter);
990 >    }
991 >
992 >    // A tiny bit set implementation
993 >
994 >    private static long[] nBits(int n) {
995 >        return new long[((n - 1) >> 6) + 1];
996 >    }
997 >    private static void setBit(long[] bits, int i) {
998 >        bits[i >> 6] |= 1L << i;
999 >    }
1000 >    private static boolean isClear(long[] bits, int i) {
1001 >        return (bits[i >> 6] & (1L << i)) == 0;
1002 >    }
1003 >
1004 >    private synchronized boolean bulkRemove(Predicate<? super E> filter) {
1005 >        int expectedModCount = modCount;
1006 >        final Object[] es = elementData;
1007 >        final int end = elementCount;
1008 >        final boolean modified;
1009 >        int i;
1010 >        // Optimize for initial run of survivors
1011 >        for (i = 0; i < end && !filter.test(elementAt(es, i)); i++)
1012 >            ;
1013 >        // Tolerate predicates that reentrantly access the collection for
1014 >        // read (but writers still get CME), so traverse once to find
1015 >        // elements to delete, a second pass to physically expunge.
1016 >        if (modified = (i < end)) {
1017 >            expectedModCount++;
1018 >            modCount++;
1019 >            final int beg = i;
1020 >            final long[] deathRow = nBits(end - beg);
1021 >            deathRow[0] = 1L;   // set bit 0
1022 >            for (i = beg + 1; i < end; i++)
1023 >                if (filter.test(elementAt(es, i)))
1024 >                    setBit(deathRow, i - beg);
1025 >            int w = beg;
1026 >            for (i = beg; i < end; i++)
1027 >                if (isClear(deathRow, i - beg))
1028 >                    es[w++] = es[i];
1029 >            Arrays.fill(es, elementCount = w, end, null);
1030 >        }
1031 >        if (modCount != expectedModCount)
1032 >            throw new ConcurrentModificationException();
1033 >        return modified;
1034      }
1035  
1036      /**
# Line 918 | Line 1051 | public class Vector<E>
1051       * @since 1.2
1052       */
1053      public synchronized boolean addAll(int index, Collection<? extends E> c) {
921        modCount++;
1054          if (index < 0 || index > elementCount)
1055              throw new ArrayIndexOutOfBoundsException(index);
1056  
1057          Object[] a = c.toArray();
1058 +        modCount++;
1059          int numNew = a.length;
1060 <        ensureCapacityHelper(elementCount + numNew);
1060 >        if (numNew == 0)
1061 >            return false;
1062 >        Object[] elementData = this.elementData;
1063 >        final int s = elementCount;
1064 >        if (numNew > elementData.length - s)
1065 >            elementData = grow(s + numNew);
1066  
1067 <        int numMoved = elementCount - index;
1067 >        int numMoved = s - index;
1068          if (numMoved > 0)
1069 <            System.arraycopy(elementData, index, elementData, index + numNew,
1069 >            System.arraycopy(elementData, index,
1070 >                             elementData, index + numNew,
1071                               numMoved);
933
1072          System.arraycopy(a, 0, elementData, index, numNew);
1073 <        elementCount += numNew;
1074 <        return numNew != 0;
1073 >        elementCount = s + numNew;
1074 >        return true;
1075      }
1076  
1077      /**
# Line 941 | Line 1079 | public class Vector<E>
1079       * true if and only if the specified Object is also a List, both Lists
1080       * have the same size, and all corresponding pairs of elements in the two
1081       * Lists are <em>equal</em>.  (Two elements {@code e1} and
1082 <     * {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null :
1083 <     * e1.equals(e2))}.)  In other words, two Lists are defined to be
1082 >     * {@code e2} are <em>equal</em> if {@code Objects.equals(e1, e2)}.)
1083 >     * In other words, two Lists are defined to be
1084       * equal if they contain the same elements in the same order.
1085       *
1086       * @param o the Object to be compared for equality with this Vector
# Line 1014 | Line 1152 | public class Vector<E>
1152       * (If {@code toIndex==fromIndex}, this operation has no effect.)
1153       */
1154      protected synchronized void removeRange(int fromIndex, int toIndex) {
1017        modCount++;
1155          int numMoved = elementCount - toIndex;
1156          System.arraycopy(elementData, toIndex, elementData, fromIndex,
1157                           numMoved);
1158  
1159          // Let gc do its work
1160 +        modCount++;
1161          int newElementCount = elementCount - (toIndex-fromIndex);
1162          while (elementCount != newElementCount)
1163              elementData[--elementCount] = null;
# Line 1027 | Line 1165 | public class Vector<E>
1165  
1166      /**
1167       * Save the state of the {@code Vector} instance to a stream (that
1168 <     * is, serialize it).  This method is present merely for synchronization.
1169 <     * It just calls the default writeObject method.
1170 <     */
1171 <    private synchronized void writeObject(java.io.ObjectOutputStream s)
1172 <        throws java.io.IOException
1173 <    {
1174 <        s.defaultWriteObject();
1168 >     * is, serialize it).
1169 >     * This method performs synchronization to ensure the consistency
1170 >     * of the serialized data.
1171 >     */
1172 >    private void writeObject(java.io.ObjectOutputStream s)
1173 >            throws java.io.IOException {
1174 >        final java.io.ObjectOutputStream.PutField fields = s.putFields();
1175 >        final Object[] data;
1176 >        synchronized (this) {
1177 >            fields.put("capacityIncrement", capacityIncrement);
1178 >            fields.put("elementCount", elementCount);
1179 >            data = elementData.clone();
1180 >        }
1181 >        fields.put("elementData", data);
1182 >        s.writeFields();
1183      }
1184  
1185      /**
# Line 1114 | Line 1260 | public class Vector<E>
1260              lastRet = -1;
1261          }
1262  
1263 +        @Override
1264 +        public void forEachRemaining(Consumer<? super E> action) {
1265 +            Objects.requireNonNull(action);
1266 +            synchronized (Vector.this) {
1267 +                final int size = elementCount;
1268 +                int i = cursor;
1269 +                if (i >= size) {
1270 +                    return;
1271 +                }
1272 +                final Object[] es = elementData;
1273 +                if (i >= es.length)
1274 +                    throw new ConcurrentModificationException();
1275 +                while (i < size && modCount == expectedModCount)
1276 +                    action.accept(elementAt(es, i++));
1277 +                // update once at end of iteration to reduce heap write traffic
1278 +                cursor = i;
1279 +                lastRet = i - 1;
1280 +                checkForComodification();
1281 +            }
1282 +        }
1283 +
1284          final void checkForComodification() {
1285              if (modCount != expectedModCount)
1286                  throw new ConcurrentModificationException();
# Line 1172 | Line 1339 | public class Vector<E>
1339              lastRet = -1;
1340          }
1341      }
1342 +
1343 +    @Override
1344 +    public synchronized void forEach(Consumer<? super E> action) {
1345 +        Objects.requireNonNull(action);
1346 +        final int expectedModCount = modCount;
1347 +        final Object[] es = elementData;
1348 +        final int size = elementCount;
1349 +        for (int i = 0; modCount == expectedModCount && i < size; i++)
1350 +            action.accept(elementAt(es, i));
1351 +        if (modCount != expectedModCount)
1352 +            throw new ConcurrentModificationException();
1353 +    }
1354 +
1355 +    @Override
1356 +    public synchronized void replaceAll(UnaryOperator<E> operator) {
1357 +        Objects.requireNonNull(operator);
1358 +        final int expectedModCount = modCount;
1359 +        final Object[] es = elementData;
1360 +        final int size = elementCount;
1361 +        for (int i = 0; modCount == expectedModCount && i < size; i++)
1362 +            es[i] = operator.apply(elementAt(es, i));
1363 +        if (modCount != expectedModCount)
1364 +            throw new ConcurrentModificationException();
1365 +        modCount++;
1366 +    }
1367 +
1368 +    @SuppressWarnings("unchecked")
1369 +    @Override
1370 +    public synchronized void sort(Comparator<? super E> c) {
1371 +        final int expectedModCount = modCount;
1372 +        Arrays.sort((E[]) elementData, 0, elementCount, c);
1373 +        if (modCount != expectedModCount) {
1374 +            throw new ConcurrentModificationException();
1375 +        }
1376 +        modCount++;
1377 +    }
1378 +
1379 +    /**
1380 +     * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
1381 +     * and <em>fail-fast</em> {@link Spliterator} over the elements in this
1382 +     * list.
1383 +     *
1384 +     * <p>The {@code Spliterator} reports {@link Spliterator#SIZED},
1385 +     * {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}.
1386 +     * Overriding implementations should document the reporting of additional
1387 +     * characteristic values.
1388 +     *
1389 +     * @return a {@code Spliterator} over the elements in this list
1390 +     * @since 1.8
1391 +     */
1392 +    @Override
1393 +    public Spliterator<E> spliterator() {
1394 +        return new VectorSpliterator<>(this, null, 0, -1, 0);
1395 +    }
1396 +
1397 +    /** Similar to ArrayList Spliterator */
1398 +    static final class VectorSpliterator<E> implements Spliterator<E> {
1399 +        private final Vector<E> list;
1400 +        private Object[] array;
1401 +        private int index; // current index, modified on advance/split
1402 +        private int fence; // -1 until used; then one past last index
1403 +        private int expectedModCount; // initialized when fence set
1404 +
1405 +        /** Create new spliterator covering the given range */
1406 +        VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,
1407 +                          int expectedModCount) {
1408 +            this.list = list;
1409 +            this.array = array;
1410 +            this.index = origin;
1411 +            this.fence = fence;
1412 +            this.expectedModCount = expectedModCount;
1413 +        }
1414 +
1415 +        private int getFence() { // initialize on first use
1416 +            int hi;
1417 +            if ((hi = fence) < 0) {
1418 +                synchronized (list) {
1419 +                    array = list.elementData;
1420 +                    expectedModCount = list.modCount;
1421 +                    hi = fence = list.elementCount;
1422 +                }
1423 +            }
1424 +            return hi;
1425 +        }
1426 +
1427 +        public Spliterator<E> trySplit() {
1428 +            int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
1429 +            return (lo >= mid) ? null :
1430 +                new VectorSpliterator<>(list, array, lo, index = mid,
1431 +                                        expectedModCount);
1432 +        }
1433 +
1434 +        @SuppressWarnings("unchecked")
1435 +        public boolean tryAdvance(Consumer<? super E> action) {
1436 +            int i;
1437 +            if (action == null)
1438 +                throw new NullPointerException();
1439 +            if (getFence() > (i = index)) {
1440 +                index = i + 1;
1441 +                action.accept((E)array[i]);
1442 +                if (list.modCount != expectedModCount)
1443 +                    throw new ConcurrentModificationException();
1444 +                return true;
1445 +            }
1446 +            return false;
1447 +        }
1448 +
1449 +        @SuppressWarnings("unchecked")
1450 +        public void forEachRemaining(Consumer<? super E> action) {
1451 +            int i, hi; // hoist accesses and checks from loop
1452 +            Vector<E> lst; Object[] a;
1453 +            if (action == null)
1454 +                throw new NullPointerException();
1455 +            if ((lst = list) != null) {
1456 +                if ((hi = fence) < 0) {
1457 +                    synchronized (lst) {
1458 +                        expectedModCount = lst.modCount;
1459 +                        a = array = lst.elementData;
1460 +                        hi = fence = lst.elementCount;
1461 +                    }
1462 +                }
1463 +                else
1464 +                    a = array;
1465 +                if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {
1466 +                    while (i < hi)
1467 +                        action.accept((E) a[i++]);
1468 +                    if (lst.modCount == expectedModCount)
1469 +                        return;
1470 +                }
1471 +            }
1472 +            throw new ConcurrentModificationException();
1473 +        }
1474 +
1475 +        public long estimateSize() {
1476 +            return getFence() - index;
1477 +        }
1478 +
1479 +        public int characteristics() {
1480 +            return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
1481 +        }
1482 +    }
1483   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines