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

Print this page
rev 6197 : [mq]: collections


   8  * particular file as subject to the "Classpath" exception as provided
   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
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  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 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 /**
  29  * The {@code Vector} class implements a growable array of
  30  * objects. Like an array, it contains components that can be
  31  * accessed using an integer index. However, the size of a
  32  * {@code Vector} can grow or shrink as needed to accommodate
  33  * adding and removing items after the {@code Vector} has been created.
  34  *
  35  * <p>Each vector tries to optimize storage management by maintaining a
  36  * {@code capacity} and a {@code capacityIncrement}. The
  37  * {@code capacity} is always at least as large as the vector
  38  * size; it is usually larger because as components are added to the
  39  * vector, the vector's storage increases in chunks the size of
  40  * {@code capacityIncrement}. An application can increase the
  41  * capacity of a vector before inserting a large number of
  42  * components; this reduces the amount of incremental reallocation.
  43  *
  44  * <p><a name="fail-fast"/>
  45  * The iterators returned by this class's {@link #iterator() iterator} and
  46  * {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:
  47  * if the vector is structurally modified at any time after the iterator is


1191 
1192         public void set(E e) {
1193             if (lastRet == -1)
1194                 throw new IllegalStateException();
1195             synchronized (Vector.this) {
1196                 checkForComodification();
1197                 Vector.this.set(lastRet, e);
1198             }
1199         }
1200 
1201         public void add(E e) {
1202             int i = cursor;
1203             synchronized (Vector.this) {
1204                 checkForComodification();
1205                 Vector.this.add(i, e);
1206                 expectedModCount = modCount;
1207             }
1208             cursor = i + 1;
1209             lastRet = -1;
1210         }























































































1211     }
1212 }


   8  * particular file as subject to the "Classpath" exception as provided
   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
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  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 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.Block;
  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
  35  * accessed using an integer index. However, the size of a
  36  * {@code Vector} can grow or shrink as needed to accommodate
  37  * adding and removing items after the {@code Vector} has been created.
  38  *
  39  * <p>Each vector tries to optimize storage management by maintaining a
  40  * {@code capacity} and a {@code capacityIncrement}. The
  41  * {@code capacity} is always at least as large as the vector
  42  * size; it is usually larger because as components are added to the
  43  * vector, the vector's storage increases in chunks the size of
  44  * {@code capacityIncrement}. An application can increase the
  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"/>
  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


1195 
1196         public void set(E e) {
1197             if (lastRet == -1)
1198                 throw new IllegalStateException();
1199             synchronized (Vector.this) {
1200                 checkForComodification();
1201                 Vector.this.set(lastRet, e);
1202             }
1203         }
1204 
1205         public void add(E e) {
1206             int i = cursor;
1207             synchronized (Vector.this) {
1208                 checkForComodification();
1209                 Vector.this.add(i, e);
1210                 expectedModCount = modCount;
1211             }
1212             cursor = i + 1;
1213             lastRet = -1;
1214         }
1215     }
1216 
1217     @Override
1218     public synchronized void forEach(Block<? super E> block) {
1219         Objects.requireNonNull(block);
1220         final E[] elementData = (E[]) this.elementData;
1221         final int expectedModCount = modCount;
1222         final int size = elementCount;
1223         for (int i=0; modCount == expectedModCount && i < size; i++) {
1224             block.accept(elementData[i]);
1225         }
1226         if (modCount != expectedModCount) {
1227             throw new ConcurrentModificationException();
1228         }
1229     }
1230 
1231     @Override
1232     @SuppressWarnings("unchecked")
1233     public synchronized boolean removeAll(Predicate<? super E> filter) {
1234         Objects.requireNonNull(filter);
1235         // figure out which elements are to be removed
1236         // any exception thrown from the filter predicate at this stage
1237         // will leave the collection unmodified
1238         int removeCount = 0;
1239         final int size = elementCount;
1240         final BitSet removeSet = new BitSet(size);
1241         final int expectedModCount = modCount;
1242         for (int i=0; modCount == expectedModCount && i < size; i++) {
1243             @SuppressWarnings("unchecked")
1244             final E element = (E) elementData[i];
1245             if (filter.test(element)) {
1246                 removeSet.set(i);
1247                 removeCount++;
1248             }
1249         }
1250 
1251         if (modCount != expectedModCount) {
1252             throw new ConcurrentModificationException();
1253         }
1254 
1255         // shift surviving elements left over the spaces left by removed elements
1256         final boolean anyToRemove = removeCount > 0;
1257         if (anyToRemove) {
1258             final int newSize = size - removeCount;
1259             for (int i=0, j=0; modCount == expectedModCount &&
1260                     (i < size) && (j < newSize); i++, j++) {
1261                 i = removeSet.nextClearBit(i);
1262                 elementData[j] = elementData[i];
1263             }
1264             for (int k=newSize; modCount == expectedModCount && k < size; k++) {
1265                 elementData[k] = null;  // Let gc do its work
1266             }
1267             elementCount = newSize;
1268             if (modCount != expectedModCount) {
1269                 throw new ConcurrentModificationException();
1270             }
1271             modCount++;
1272         }
1273 
1274         return anyToRemove;
1275     }
1276 
1277     @Override
1278     @SuppressWarnings("unchecked")
1279     public synchronized void replaceAll(UnaryOperator<E> operator) {
1280         Objects.requireNonNull(operator);
1281         final int expectedModCount = modCount;
1282         final int size = elementCount;
1283         for (int i=0; modCount == expectedModCount && i < size; i++) {
1284             elementData[i] = operator.operate((E) elementData[i]);
1285         }
1286         if (modCount != expectedModCount) {
1287             throw new ConcurrentModificationException();
1288         }
1289         modCount++;
1290     }
1291 
1292     @Override
1293     @SuppressWarnings("unchecked")
1294     public synchronized void sort(Comparator<? super E> c) {
1295         Objects.requireNonNull(c);
1296         final int expectedModCount = modCount;
1297         Arrays.sort((E[]) elementData, 0, elementCount, c);
1298         if (modCount != expectedModCount) {
1299             throw new ConcurrentModificationException();
1300         }
1301         modCount++;
1302     }
1303 }