001 /* Vector.java -- Class that provides growable arrays. 002 Copyright (C) 1998, 1999, 2000, 2001, 2004, 2005, 2006, 003 Free Software Foundation, Inc. 004 005 This file is part of GNU Classpath. 006 007 GNU Classpath is free software; you can redistribute it and/or modify 008 it under the terms of the GNU General Public License as published by 009 the Free Software Foundation; either version 2, or (at your option) 010 any later version. 011 012 GNU Classpath is distributed in the hope that it will be useful, but 013 WITHOUT ANY WARRANTY; without even the implied warranty of 014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 015 General Public License for more details. 016 017 You should have received a copy of the GNU General Public License 018 along with GNU Classpath; see the file COPYING. If not, write to the 019 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 020 02110-1301 USA. 021 022 Linking this library statically or dynamically with other modules is 023 making a combined work based on this library. Thus, the terms and 024 conditions of the GNU General Public License cover the whole 025 combination. 026 027 As a special exception, the copyright holders of this library give you 028 permission to link this library with independent modules to produce an 029 executable, regardless of the license terms of these independent 030 modules, and to copy and distribute the resulting executable under 031 terms of your choice, provided that you also meet, for each linked 032 independent module, the terms and conditions of the license of that 033 module. An independent module is a module which is not derived from 034 or based on this library. If you modify this library, you may extend 035 this exception to your version of the library, but you are not 036 obligated to do so. If you do not wish to do so, delete this 037 exception statement from your version. */ 038 039 040 package java.util; 041 042 import java.io.IOException; 043 import java.io.ObjectOutputStream; 044 import java.io.Serializable; 045 import java.lang.reflect.Array; 046 047 /** 048 * The <code>Vector</code> classes implements growable arrays of Objects. 049 * You can access elements in a Vector with an index, just as you 050 * can in a built in array, but Vectors can grow and shrink to accommodate 051 * more or fewer objects.<p> 052 * 053 * Vectors try to mantain efficiency in growing by having a 054 * <code>capacityIncrement</code> that can be specified at instantiation. 055 * When a Vector can no longer hold a new Object, it grows by the amount 056 * in <code>capacityIncrement</code>. If this value is 0, the vector doubles in 057 * size.<p> 058 * 059 * Vector implements the JDK 1.2 List interface, and is therefore a fully 060 * compliant Collection object. The iterators are fail-fast - if external 061 * code structurally modifies the vector, any operation on the iterator will 062 * then throw a {@link ConcurrentModificationException}. The Vector class is 063 * fully synchronized, but the iterators are not. So, when iterating over a 064 * vector, be sure to synchronize on the vector itself. If you don't want the 065 * expense of synchronization, use ArrayList instead. On the other hand, the 066 * Enumeration of elements() is not thread-safe, nor is it fail-fast; so it 067 * can lead to undefined behavior even in a single thread if you modify the 068 * vector during iteration.<p> 069 * 070 * Note: Some methods, especially those specified by List, specify throwing 071 * {@link IndexOutOfBoundsException}, but it is easier to implement by 072 * throwing the subclass {@link ArrayIndexOutOfBoundsException}. Others 073 * directly specify this subclass. 074 * 075 * @author Scott G. Miller 076 * @author Bryce McKinlay 077 * @author Eric Blake (ebb9@email.byu.edu) 078 * @see Collection 079 * @see List 080 * @see ArrayList 081 * @see LinkedList 082 * @since 1.0 083 * @status updated to 1.4 084 */ 085 public class Vector<T> extends AbstractList<T> 086 implements List<T>, RandomAccess, Cloneable, Serializable 087 { 088 /** 089 * Compatible with JDK 1.0+. 090 */ 091 private static final long serialVersionUID = -2767605614048989439L; 092 093 /** 094 * The internal array used to hold members of a Vector. The elements are 095 * in positions 0 through elementCount - 1, and all remaining slots are null. 096 * @serial the elements 097 */ 098 protected T[] elementData; 099 100 /** 101 * The number of elements currently in the vector, also returned by 102 * {@link #size}. 103 * @serial the size 104 */ 105 protected int elementCount; 106 107 /** 108 * The amount the Vector's internal array should be increased in size when 109 * a new element is added that exceeds the current size of the array, 110 * or when {@link #ensureCapacity} is called. If <= 0, the vector just 111 * doubles in size. 112 * @serial the amount to grow the vector by 113 */ 114 protected int capacityIncrement; 115 116 /** 117 * Constructs an empty vector with an initial size of 10, and 118 * a capacity increment of 0 119 */ 120 public Vector() 121 { 122 this(10, 0); 123 } 124 125 /** 126 * Constructs a vector containing the contents of Collection, in the 127 * order given by the collection. 128 * 129 * @param c collection of elements to add to the new vector 130 * @throws NullPointerException if c is null 131 * @since 1.2 132 */ 133 public Vector(Collection<? extends T> c) 134 { 135 elementCount = c.size(); 136 elementData = c.toArray((T[]) new Object[elementCount]); 137 } 138 139 /** 140 * Constructs a Vector with the initial capacity and capacity 141 * increment specified. 142 * 143 * @param initialCapacity the initial size of the Vector's internal array 144 * @param capacityIncrement the amount the internal array should be 145 * increased by when necessary, 0 to double the size 146 * @throws IllegalArgumentException if initialCapacity < 0 147 */ 148 public Vector(int initialCapacity, int capacityIncrement) 149 { 150 if (initialCapacity < 0) 151 throw new IllegalArgumentException(); 152 elementData = (T[]) new Object[initialCapacity]; 153 this.capacityIncrement = capacityIncrement; 154 } 155 156 /** 157 * Constructs a Vector with the initial capacity specified, and a capacity 158 * increment of 0 (double in size). 159 * 160 * @param initialCapacity the initial size of the Vector's internal array 161 * @throws IllegalArgumentException if initialCapacity < 0 162 */ 163 public Vector(int initialCapacity) 164 { 165 this(initialCapacity, 0); 166 } 167 168 /** 169 * Copies the contents of the Vector into the provided array. If the 170 * array is too small to fit all the elements in the Vector, an 171 * {@link IndexOutOfBoundsException} is thrown without modifying the array. 172 * Old elements in the array are overwritten by the new elements. 173 * 174 * @param a target array for the copy 175 * @throws IndexOutOfBoundsException the array is not large enough 176 * @throws NullPointerException the array is null 177 * @see #toArray(Object[]) 178 */ 179 public synchronized void copyInto(Object[] a) 180 { 181 System.arraycopy(elementData, 0, a, 0, elementCount); 182 } 183 184 /** 185 * Trims the Vector down to size. If the internal data array is larger 186 * than the number of Objects its holding, a new array is constructed 187 * that precisely holds the elements. Otherwise this does nothing. 188 */ 189 public synchronized void trimToSize() 190 { 191 // Don't bother checking for the case where size() == the capacity of the 192 // vector since that is a much less likely case; it's more efficient to 193 // not do the check and lose a bit of performance in that infrequent case 194 195 T[] newArray = (T[]) new Object[elementCount]; 196 System.arraycopy(elementData, 0, newArray, 0, elementCount); 197 elementData = newArray; 198 } 199 200 /** 201 * Ensures that <code>minCapacity</code> elements can fit within this Vector. 202 * If <code>elementData</code> is too small, it is expanded as follows: 203 * If the <code>elementCount + capacityIncrement</code> is adequate, that 204 * is the new size. If <code>capacityIncrement</code> is non-zero, the 205 * candidate size is double the current. If that is not enough, the new 206 * size is <code>minCapacity</code>. 207 * 208 * @param minCapacity the desired minimum capacity, negative values ignored 209 */ 210 public synchronized void ensureCapacity(int minCapacity) 211 { 212 if (elementData.length >= minCapacity) 213 return; 214 215 int newCapacity; 216 if (capacityIncrement <= 0) 217 newCapacity = elementData.length * 2; 218 else 219 newCapacity = elementData.length + capacityIncrement; 220 221 T[] newArray = (T[]) new Object[Math.max(newCapacity, minCapacity)]; 222 223 System.arraycopy(elementData, 0, newArray, 0, elementCount); 224 elementData = newArray; 225 } 226 227 /** 228 * Explicitly sets the size of the vector (but not necessarily the size of 229 * the internal data array). If the new size is smaller than the old one, 230 * old values that don't fit are lost. If the new size is larger than the 231 * old one, the vector is padded with null entries. 232 * 233 * @param newSize The new size of the internal array 234 * @throws ArrayIndexOutOfBoundsException if the new size is negative 235 */ 236 public synchronized void setSize(int newSize) 237 { 238 // Don't bother checking for the case where size() == the capacity of the 239 // vector since that is a much less likely case; it's more efficient to 240 // not do the check and lose a bit of performance in that infrequent case 241 modCount++; 242 ensureCapacity(newSize); 243 if (newSize < elementCount) 244 Arrays.fill(elementData, newSize, elementCount, null); 245 elementCount = newSize; 246 } 247 248 /** 249 * Returns the size of the internal data array (not the amount of elements 250 * contained in the Vector). 251 * 252 * @return capacity of the internal data array 253 */ 254 public synchronized int capacity() 255 { 256 return elementData.length; 257 } 258 259 /** 260 * Returns the number of elements stored in this Vector. 261 * 262 * @return the number of elements in this Vector 263 */ 264 public synchronized int size() 265 { 266 return elementCount; 267 } 268 269 /** 270 * Returns true if this Vector is empty, false otherwise 271 * 272 * @return true if the Vector is empty, false otherwise 273 */ 274 public synchronized boolean isEmpty() 275 { 276 return elementCount == 0; 277 } 278 279 /** 280 * Returns an Enumeration of the elements of this Vector. The enumeration 281 * visits the elements in increasing index order, but is NOT thread-safe. 282 * 283 * @return an Enumeration 284 * @see #iterator() 285 */ 286 // No need to synchronize as the Enumeration is not thread-safe! 287 public Enumeration<T> elements() 288 { 289 return new Enumeration<T>() 290 { 291 private int i = 0; 292 293 public boolean hasMoreElements() 294 { 295 return i < elementCount; 296 } 297 298 public T nextElement() 299 { 300 if (i >= elementCount) 301 throw new NoSuchElementException(); 302 return elementData[i++]; 303 } 304 }; 305 } 306 307 /** 308 * Returns true when <code>elem</code> is contained in this Vector. 309 * 310 * @param elem the element to check 311 * @return true if the object is contained in this Vector, false otherwise 312 */ 313 public boolean contains(Object elem) 314 { 315 return indexOf(elem, 0) >= 0; 316 } 317 318 /** 319 * Returns the first occurrence of <code>elem</code> in the Vector, or -1 if 320 * <code>elem</code> is not found. 321 * 322 * @param elem the object to search for 323 * @return the index of the first occurrence, or -1 if not found 324 */ 325 public int indexOf(Object elem) 326 { 327 return indexOf(elem, 0); 328 } 329 330 /** 331 * Searches the vector starting at <code>index</code> for object 332 * <code>elem</code> and returns the index of the first occurrence of this 333 * Object. If the object is not found, or index is larger than the size 334 * of the vector, -1 is returned. 335 * 336 * @param e the Object to search for 337 * @param index start searching at this index 338 * @return the index of the next occurrence, or -1 if it is not found 339 * @throws IndexOutOfBoundsException if index < 0 340 */ 341 public synchronized int indexOf(Object e, int index) 342 { 343 for (int i = index; i < elementCount; i++) 344 if (equals(e, elementData[i])) 345 return i; 346 return -1; 347 } 348 349 /** 350 * Returns the last index of <code>elem</code> within this Vector, or -1 351 * if the object is not within the Vector. 352 * 353 * @param elem the object to search for 354 * @return the last index of the object, or -1 if not found 355 */ 356 public int lastIndexOf(Object elem) 357 { 358 return lastIndexOf(elem, elementCount - 1); 359 } 360 361 /** 362 * Returns the index of the first occurrence of <code>elem</code>, when 363 * searching backwards from <code>index</code>. If the object does not 364 * occur in this Vector, or index is less than 0, -1 is returned. 365 * 366 * @param e the object to search for 367 * @param index the index to start searching in reverse from 368 * @return the index of the Object if found, -1 otherwise 369 * @throws IndexOutOfBoundsException if index >= size() 370 */ 371 public synchronized int lastIndexOf(Object e, int index) 372 { 373 checkBoundExclusive(index); 374 for (int i = index; i >= 0; i--) 375 if (equals(e, elementData[i])) 376 return i; 377 return -1; 378 } 379 380 /** 381 * Returns the Object stored at <code>index</code>. 382 * 383 * @param index the index of the Object to retrieve 384 * @return the object at <code>index</code> 385 * @throws ArrayIndexOutOfBoundsException index < 0 || index >= size() 386 * @see #get(int) 387 */ 388 public synchronized T elementAt(int index) 389 { 390 checkBoundExclusive(index); 391 return elementData[index]; 392 } 393 394 /** 395 * Returns the first element (index 0) in the Vector. 396 * 397 * @return the first Object in the Vector 398 * @throws NoSuchElementException the Vector is empty 399 */ 400 public synchronized T firstElement() 401 { 402 if (elementCount == 0) 403 throw new NoSuchElementException(); 404 405 return elementData[0]; 406 } 407 408 /** 409 * Returns the last element in the Vector. 410 * 411 * @return the last Object in the Vector 412 * @throws NoSuchElementException the Vector is empty 413 */ 414 public synchronized T lastElement() 415 { 416 if (elementCount == 0) 417 throw new NoSuchElementException(); 418 419 return elementData[elementCount - 1]; 420 } 421 422 /** 423 * Changes the element at <code>index</code> to be <code>obj</code> 424 * 425 * @param obj the object to store 426 * @param index the position in the Vector to store the object 427 * @throws ArrayIndexOutOfBoundsException the index is out of range 428 * @see #set(int, Object) 429 */ 430 public void setElementAt(T obj, int index) 431 { 432 set(index, obj); 433 } 434 435 /** 436 * Removes the element at <code>index</code>, and shifts all elements at 437 * positions greater than index to their index - 1. 438 * 439 * @param index the index of the element to remove 440 * @throws ArrayIndexOutOfBoundsException index < 0 || index >= size(); 441 * @see #remove(int) 442 */ 443 public void removeElementAt(int index) 444 { 445 remove(index); 446 } 447 448 /** 449 * Inserts a new element into the Vector at <code>index</code>. Any elements 450 * at or greater than index are shifted up one position. 451 * 452 * @param obj the object to insert 453 * @param index the index at which the object is inserted 454 * @throws ArrayIndexOutOfBoundsException index < 0 || index > size() 455 * @see #add(int, Object) 456 */ 457 public synchronized void insertElementAt(T obj, int index) 458 { 459 checkBoundInclusive(index); 460 if (elementCount == elementData.length) 461 ensureCapacity(elementCount + 1); 462 modCount++; 463 System.arraycopy(elementData, index, elementData, index + 1, 464 elementCount - index); 465 elementCount++; 466 elementData[index] = obj; 467 } 468 469 /** 470 * Adds an element to the Vector at the end of the Vector. The vector 471 * is increased by ensureCapacity(size() + 1) if needed. 472 * 473 * @param obj the object to add to the Vector 474 */ 475 public synchronized void addElement(T obj) 476 { 477 if (elementCount == elementData.length) 478 ensureCapacity(elementCount + 1); 479 modCount++; 480 elementData[elementCount++] = obj; 481 } 482 483 /** 484 * Removes the first (the lowest index) occurrence of the given object from 485 * the Vector. If such a remove was performed (the object was found), true 486 * is returned. If there was no such object, false is returned. 487 * 488 * @param obj the object to remove from the Vector 489 * @return true if the Object was in the Vector, false otherwise 490 * @see #remove(Object) 491 */ 492 public synchronized boolean removeElement(Object obj) 493 { 494 int idx = indexOf(obj, 0); 495 if (idx >= 0) 496 { 497 remove(idx); 498 return true; 499 } 500 return false; 501 } 502 503 /** 504 * Removes all elements from the Vector. Note that this does not 505 * resize the internal data array. 506 * 507 * @see #clear() 508 */ 509 public synchronized void removeAllElements() 510 { 511 if (elementCount == 0) 512 return; 513 514 modCount++; 515 Arrays.fill(elementData, 0, elementCount, null); 516 elementCount = 0; 517 } 518 519 /** 520 * Creates a new Vector with the same contents as this one. The clone is 521 * shallow; elements are not cloned. 522 * 523 * @return the clone of this vector 524 */ 525 public synchronized Object clone() 526 { 527 try 528 { 529 Vector clone = (Vector) super.clone(); 530 clone.elementData = (Object[]) elementData.clone(); 531 return clone; 532 } 533 catch (CloneNotSupportedException ex) 534 { 535 // Impossible to get here. 536 throw new InternalError(ex.toString()); 537 } 538 } 539 540 /** 541 * Returns an Object array with the contents of this Vector, in the order 542 * they are stored within this Vector. Note that the Object array returned 543 * is not the internal data array, and that it holds only the elements 544 * within the Vector. This is similar to creating a new Object[] with the 545 * size of this Vector, then calling Vector.copyInto(yourArray). 546 * 547 * @return an Object[] containing the contents of this Vector in order 548 * @since 1.2 549 */ 550 public synchronized Object[] toArray() 551 { 552 Object[] newArray = new Object[elementCount]; 553 copyInto(newArray); 554 return newArray; 555 } 556 557 /** 558 * Returns an array containing the contents of this Vector. 559 * If the provided array is large enough, the contents are copied 560 * into that array, and a null is placed in the position size(). 561 * In this manner, you can obtain the size of a Vector by the position 562 * of the null element, if you know the vector does not itself contain 563 * null entries. If the array is not large enough, reflection is used 564 * to create a bigger one of the same runtime type. 565 * 566 * @param a an array to copy the Vector into if large enough 567 * @return an array with the contents of this Vector in order 568 * @throws ArrayStoreException the runtime type of the provided array 569 * cannot hold the elements of the Vector 570 * @throws NullPointerException if <code>a</code> is null 571 * @since 1.2 572 */ 573 public synchronized <S> S[] toArray(S[] a) 574 { 575 if (a.length < elementCount) 576 a = (S[]) Array.newInstance(a.getClass().getComponentType(), 577 elementCount); 578 else if (a.length > elementCount) 579 a[elementCount] = null; 580 System.arraycopy(elementData, 0, a, 0, elementCount); 581 return a; 582 } 583 584 /** 585 * Returns the element at position <code>index</code>. 586 * 587 * @param index the position from which an element will be retrieved 588 * @return the element at that position 589 * @throws ArrayIndexOutOfBoundsException index < 0 || index >= size() 590 * @since 1.2 591 */ 592 public T get(int index) 593 { 594 return elementAt(index); 595 } 596 597 /** 598 * Puts <code>element</code> into the Vector at position <code>index</code> 599 * and returns the Object that previously occupied that position. 600 * 601 * @param index the index within the Vector to place the Object 602 * @param element the Object to store in the Vector 603 * @return the previous object at the specified index 604 * @throws ArrayIndexOutOfBoundsException index < 0 || index >= size() 605 * @since 1.2 606 */ 607 public synchronized T set(int index, T element) 608 { 609 checkBoundExclusive(index); 610 T temp = elementData[index]; 611 elementData[index] = element; 612 return temp; 613 } 614 615 /** 616 * Adds an object to the Vector. 617 * 618 * @param o the element to add to the Vector 619 * @return true, as specified by List 620 * @since 1.2 621 */ 622 public boolean add(T o) 623 { 624 addElement(o); 625 return true; 626 } 627 628 /** 629 * Removes the given Object from the Vector. If it exists, true 630 * is returned, if not, false is returned. 631 * 632 * @param o the object to remove from the Vector 633 * @return true if the Object existed in the Vector, false otherwise 634 * @since 1.2 635 */ 636 public boolean remove(Object o) 637 { 638 return removeElement(o); 639 } 640 641 /** 642 * Adds an object at the specified index. Elements at or above 643 * index are shifted up one position. 644 * 645 * @param index the index at which to add the element 646 * @param element the element to add to the Vector 647 * @throws ArrayIndexOutOfBoundsException index < 0 || index > size() 648 * @since 1.2 649 */ 650 public void add(int index, T element) 651 { 652 insertElementAt(element, index); 653 } 654 655 /** 656 * Removes the element at the specified index, and returns it. 657 * 658 * @param index the position from which to remove the element 659 * @return the object removed 660 * @throws ArrayIndexOutOfBoundsException index < 0 || index >= size() 661 * @since 1.2 662 */ 663 public synchronized T remove(int index) 664 { 665 checkBoundExclusive(index); 666 T temp = elementData[index]; 667 modCount++; 668 elementCount--; 669 if (index < elementCount) 670 System.arraycopy(elementData, index + 1, elementData, index, 671 elementCount - index); 672 elementData[elementCount] = null; 673 return temp; 674 } 675 676 /** 677 * Clears all elements in the Vector and sets its size to 0. 678 */ 679 public void clear() 680 { 681 removeAllElements(); 682 } 683 684 /** 685 * Returns true if this Vector contains all the elements in c. 686 * 687 * @param c the collection to compare to 688 * @return true if this vector contains all elements of c 689 * @throws NullPointerException if c is null 690 * @since 1.2 691 */ 692 public synchronized boolean containsAll(Collection<?> c) 693 { 694 // Here just for the sychronization. 695 return super.containsAll(c); 696 } 697 698 /** 699 * Appends all elements of the given collection to the end of this Vector. 700 * Behavior is undefined if the collection is modified during this operation 701 * (for example, if this == c). 702 * 703 * @param c the collection to append 704 * @return true if this vector changed, in other words c was not empty 705 * @throws NullPointerException if c is null 706 * @since 1.2 707 */ 708 public synchronized boolean addAll(Collection<? extends T> c) 709 { 710 return addAll(elementCount, c); 711 } 712 713 /** 714 * Remove from this vector all elements contained in the given collection. 715 * 716 * @param c the collection to filter out 717 * @return true if this vector changed 718 * @throws NullPointerException if c is null 719 * @since 1.2 720 */ 721 public synchronized boolean removeAll(Collection<?> c) 722 { 723 // The NullPointerException is thrown implicitly when the Vector 724 // is not empty and c is null. The RI allows null arguments when 725 // the vector is empty. See Mauve test: 726 // gnu/testlet/java/util/Vector/removeAll.java 727 728 int i; 729 int j; 730 for (i = 0; i < elementCount; i++) 731 if (c.contains(elementData[i])) 732 break; 733 if (i == elementCount) 734 return false; 735 736 modCount++; 737 for (j = i++; i < elementCount; i++) 738 if (! c.contains(elementData[i])) 739 elementData[j++] = elementData[i]; 740 elementCount -= i - j; 741 return true; 742 } 743 744 /** 745 * Retain in this vector only the elements contained in the given collection. 746 * 747 * @param c the collection to filter by 748 * @return true if this vector changed 749 * @throws NullPointerException if c is null 750 * @since 1.2 751 */ 752 public synchronized boolean retainAll(Collection<?> c) 753 { 754 // The NullPointerException is thrown implicitly when the Vector 755 // is not empty and c is null. The RI allows null arguments when 756 // the vector is empty. See Mauve test: 757 // gnu/testlet/java/util/Vector/retainAll.java 758 759 int i; 760 int j; 761 for (i = 0; i < elementCount; i++) 762 if (! c.contains(elementData[i])) 763 break; 764 if (i == elementCount) 765 return false; 766 767 modCount++; 768 for (j = i++; i < elementCount; i++) 769 if (c.contains(elementData[i])) 770 elementData[j++] = elementData[i]; 771 elementCount -= i - j; 772 return true; 773 } 774 775 /** 776 * Inserts all elements of the given collection at the given index of 777 * this Vector. Behavior is undefined if the collection is modified during 778 * this operation (for example, if this == c). 779 * 780 * @param c the collection to append 781 * @return true if this vector changed, in other words c was not empty 782 * @throws NullPointerException if c is null 783 * @throws ArrayIndexOutOfBoundsException index < 0 || index > size() 784 * @since 1.2 785 */ 786 public synchronized boolean addAll(int index, Collection<? extends T> c) 787 { 788 checkBoundInclusive(index); 789 Iterator<? extends T> itr = c.iterator(); 790 int csize = c.size(); 791 792 modCount++; 793 ensureCapacity(elementCount + csize); 794 int end = index + csize; 795 if (elementCount > 0 && index != elementCount) 796 System.arraycopy(elementData, index, 797 elementData, end, elementCount - index); 798 elementCount += csize; 799 for ( ; index < end; index++) 800 elementData[index] = itr.next(); 801 return (csize > 0); 802 } 803 804 /** 805 * Compares this to the given object. 806 * 807 * @param o the object to compare to 808 * @return true if the two are equal 809 * @since 1.2 810 */ 811 public synchronized boolean equals(Object o) 812 { 813 // Here just for the sychronization. 814 return super.equals(o); 815 } 816 817 /** 818 * Computes the hashcode of this object. 819 * 820 * @return the hashcode 821 * @since 1.2 822 */ 823 public synchronized int hashCode() 824 { 825 // Here just for the sychronization. 826 return super.hashCode(); 827 } 828 829 /** 830 * Returns a string representation of this Vector in the form 831 * "[element0, element1, ... elementN]". 832 * 833 * @return the String representation of this Vector 834 */ 835 public synchronized String toString() 836 { 837 // Here just for the sychronization. 838 return super.toString(); 839 } 840 841 /** 842 * Obtain a List view of a subsection of this list, from fromIndex 843 * (inclusive) to toIndex (exclusive). If the two indices are equal, the 844 * sublist is empty. The returned list is modifiable, and changes in one 845 * reflect in the other. If this list is structurally modified in 846 * any way other than through the returned list, the result of any subsequent 847 * operations on the returned list is undefined. 848 * <p> 849 * 850 * @param fromIndex the index that the returned list should start from 851 * (inclusive) 852 * @param toIndex the index that the returned list should go to (exclusive) 853 * @return a List backed by a subsection of this vector 854 * @throws IndexOutOfBoundsException if fromIndex < 0 855 * || toIndex > size() 856 * @throws IllegalArgumentException if fromIndex > toIndex 857 * @see ConcurrentModificationException 858 * @since 1.2 859 */ 860 public synchronized List<T> subList(int fromIndex, int toIndex) 861 { 862 List<T> sub = super.subList(fromIndex, toIndex); 863 // We must specify the correct object to synchronize upon, hence the 864 // use of a non-public API 865 return new Collections.SynchronizedList<T>(this, sub); 866 } 867 868 /** 869 * Removes a range of elements from this list. 870 * Does nothing when toIndex is equal to fromIndex. 871 * 872 * @param fromIndex the index to start deleting from (inclusive) 873 * @param toIndex the index to delete up to (exclusive) 874 * @throws IndexOutOfBoundsException if fromIndex > toIndex 875 */ 876 // This does not need to be synchronized, because it is only called through 877 // clear() of a sublist, and clear() had already synchronized. 878 protected void removeRange(int fromIndex, int toIndex) 879 { 880 int change = toIndex - fromIndex; 881 if (change > 0) 882 { 883 modCount++; 884 System.arraycopy(elementData, toIndex, elementData, fromIndex, 885 elementCount - toIndex); 886 int save = elementCount; 887 elementCount -= change; 888 Arrays.fill(elementData, elementCount, save, null); 889 } 890 else if (change < 0) 891 throw new IndexOutOfBoundsException(); 892 } 893 894 /** 895 * Checks that the index is in the range of possible elements (inclusive). 896 * 897 * @param index the index to check 898 * @throws ArrayIndexOutOfBoundsException if index > size 899 */ 900 private void checkBoundInclusive(int index) 901 { 902 // Implementation note: we do not check for negative ranges here, since 903 // use of a negative index will cause an ArrayIndexOutOfBoundsException 904 // with no effort on our part. 905 if (index > elementCount) 906 throw new ArrayIndexOutOfBoundsException(index + " > " + elementCount); 907 } 908 909 /** 910 * Checks that the index is in the range of existing elements (exclusive). 911 * 912 * @param index the index to check 913 * @throws ArrayIndexOutOfBoundsException if index >= size 914 */ 915 private void checkBoundExclusive(int index) 916 { 917 // Implementation note: we do not check for negative ranges here, since 918 // use of a negative index will cause an ArrayIndexOutOfBoundsException 919 // with no effort on our part. 920 if (index >= elementCount) 921 throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); 922 } 923 924 /** 925 * Serializes this object to the given stream. 926 * 927 * @param s the stream to write to 928 * @throws IOException if the underlying stream fails 929 * @serialData just calls default write function 930 */ 931 private synchronized void writeObject(ObjectOutputStream s) 932 throws IOException 933 { 934 s.defaultWriteObject(); 935 } 936 937 }