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