Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. What are the differences between ArrayList and Vector?
What are the differences between these two data structures and where should you use each of them?
2. ArrayList vs. Vectors in Java if thread safety isn't a concern
Is there really that much of a difference between the performance of Vectors and ArrayLists? Is it good practice to use ArrayLists at all times when thread safety isn't an issue?
3. What does it mean to program to a interface?
I keep hearing the statement on most programming related sites: Program to an interface and not to an Implementation However I don't understand the implications? Examples would help. EDIT: I have received a lot of good answers even so could you'll supplement it with some snippets of code for a better understanding of the subject. Thanks!
4. Why is vector array doubled?
Why does the classic implementation of Vector (ArrayList for Java people) double its internal array size on each expansion instead of tripling or quadrupling it?
5. Use Hashtable, Vector or HashMap or ArrayList in Java
One meme that gets stressed with Java development is always use ArrayList over Vector. Vector is deprecated. That may be true, but Vector and Hashtable have the advantage that they are synchronized. I am working with a heavily concurrent oriented application, wouldn't it benefit to use objects that are synchronized like Vector? It seems that they have their place?
6. Java Error using Vectors: unchecked call to add(E)
Offending bit of code Vector moves = new Vector(); moves.add(new Integer(x)); Error: ConnectFour.java:82: warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.Vector moves.add(new Integer(x)); Not really sure how much info is needed for an error like this....
7. Default Collection type
Assume you need to store/retrieve items in a Collection, don't care about ordering, and duplicates are allowed, what type of Collection do you use? By default, I've always used ArrayList, but I remember reading/hearing somewhere that a Queue implementation may be a better choice. A List allows items to be added/retrieved/removed at arbitrary positions, which incurs a performance penalty. As a ...
8. Sorting vector in java
I cant find any sorting function in the java API for vectors. Collections.sort is only for List and not for Vector I dont want to write my own sorting algo because I think java should implement this Im looking for something like, class ClassName implements Comparator ... ClassName cn; sort(cn);
9. Java List , Vector comparison
I saw the following program on the internet public class Test1{ public static void main(String[] args) { Integer int1 = new Integer(10); Vector vec1 = new Vector(); LinkedList list = new LinkedList(); vec1.add(int1); list.add(int1); if(vec1.equals(list)) System.out.println("equal"); else System.out.println("not equal"); } } The answer it print is "equal". How it is possible? ...
10. Why Java DefaultTableModel use Vector?
I know we have to use AWT thread for all table model update operations. Under the single AWT thread, any table model will be thread-safe. Why DefaultTableModel picks thread-safe Vector as its data stucture, which slower than other data structures like ArrayList?
11. Convert vector to list
How to convert a vector to a list?
12. How to convert Vector to String array in java
How to convert Vector with string to String array in java?
13. How to write a method that accepts stacks and queues?
So I have this really large method I wrote. If it's given a stack, it will return a stack. If it's given a queue, it will return a queue. It uses a lot of recursion, and it accepts a queue/stack and returns that same queue/stack modified accordingly. I don't want to copy/paste my method just so I can change the type used inside, so is there any way I can make this generic? As in, it will accep...
14. About Sorting Algorithms applied to Stacks and Queues
I want to know why we always use Sorting algorithm like (Insertion Sort or Merge Sort,...) just for lists and arrays? And why we do not use these algorithms for stack or queue?
15. Java: Object Oriented Design; LinkedList and Stack
I am writing a BFS and DFS in Java. What I was hoping to do was create one class like this: /** Preforms BFS and DFS on ... */ public class Search{ private XXX toSearch; // where XXX is an interface of Stack and LinkedList that has // remove() and add() methods. public Search(boolean isBFS){ if(isBFS) toSearch = new LinkedList(); else toSearch = new Stack(); ...
16. Java concurrency
i have a list of personId .. There are two api calls to update (add and remove ) from it public void add(String newPersonName){ if(personNameIdMap.get(newPersonName) != null){ myPersonId.add(personNameIdMap.get(newPersonName) }else{ // get the id from twitter and add to the list } // make an api call to twitter } public void delete(String personNAme){ if...
17. Change String[] into Vector
How can I convert in the quickest way String[] to Vector<String>?
18. Problem with object oriented programming in Java
So I would like to start out by telling you that I am learning Java on my own and you guys are the nearest thing I have to teachers. So thank you so much for putting up with my simple and obvious question. I am just trying to learn. Once again I am getting an error that for the life of me I cannot figure out. Here is the error: Exception in thread "main" java.lang.NullPointerException at Advi...
19. How to convert Vector to an int[]?
Possible Duplicate: How to convert List<Integer> to int[] in Java? Is there some method to convert a Vector< Integer> to an int[]? Thanks
20. Java Vector: clear vs removeAllElements method
I'm new to Java. Which is more efficient for Vectors -- clear() or removeAllElements(). I would guess removeAllElements since it leaves the capacity unchanged (doesn't release memory) whereas clear() releases memory. Depending on the application, either may be desirable. I would appreciate some input. Thanks.
21. Putting sql result set into JList
I'm working on my second year project and I'm nearly finished, but I've got a problem. I have a table set up in Oracle that holds user names, recipients, and messages. I wanted to make a contacts list for sending messages that would take the user names and put them into a swing jlist but i cant figure out how. I thought maybe if I put the usernames into an array from the SQL it'd be easier ... 
1
   /*
2
    * Copyright 1994-2007 Sun Microsystems, Inc.  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
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Sun 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 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.
24
   */
25
  
26
  package java.util;

The Vector class implements a growable array of objects. Like an array, it contains components that can be accessed using an integer index. However, the size of a Vector can grow or shrink as needed to accommodate adding and removing items after the Vector has been created.

Each vector tries to optimize storage management by maintaining a capacity and a capacityIncrement. The capacity is always at least as large as the vector size; it is usually larger because as components are added to the vector, the vector's storage increases in chunks the size of capacityIncrement. An application can increase the capacity of a vector before inserting a large number of components; this reduces the amount of incremental reallocation.

The iterators returned by this class's iterator and listIterator methods are fail-fast: if the vector is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove or add methods, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future. The Enumerations returned by the elements method are not fail-fast.

Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

As of the Java 2 platform v1.2, this class was retrofitted to implement the List interface, making it a member of the Java Collections Framework. Unlike the new collection implementations, Vector is synchronized.

Author(s):
Lee Boynton
Jonathan Payne
Since:
JDK1.0
See also:
Collection
List
ArrayList
LinkedList

78
  
79
  public class Vector<E>
80
      extends AbstractList<E>
81
      implements List<E>, RandomAccess, Cloneable, java.io.Serializable
82
  {
    
The array buffer into which the components of the vector are stored. The capacity of the vector is the length of this array buffer, and is at least large enough to contain all the vector's elements.

Any array elements following the last element in the Vector are null.

Serial:
91
  
92
      protected Object[] elementData;

    
The number of valid components in this Vector object. Components elementData[0] through elementData[elementCount-1] are the actual items.

Serial:
100
 
101
     protected int elementCount;

    
The amount by which the capacity of the vector is automatically incremented when its size becomes greater than its capacity. If the capacity increment is less than or equal to zero, the capacity of the vector is doubled each time it needs to grow.

Serial:
110
 
111
     protected int capacityIncrement;

    
use serialVersionUID from JDK 1.0.2 for interoperability
113
 
114
     private static final long serialVersionUID = -2767605614048989439L;

    
Constructs an empty vector with the specified initial capacity and capacity increment.

Parameters:
initialCapacity the initial capacity of the vector
capacityIncrement the amount by which the capacity is increased when the vector overflows
Throws:
java.lang.IllegalArgumentException if the specified initial capacity is negative
125
 
126
     public Vector(int initialCapacity, int capacityIncrement) {
127
         super();
128
         if (initialCapacity < 0)
129
             throw new IllegalArgumentException("Illegal Capacity: "+
130
                                                initialCapacity);
131
         this. = new Object[initialCapacity];
132
         this. = capacityIncrement;
133
     }

    
Constructs an empty vector with the specified initial capacity and with its capacity increment equal to zero.

Parameters:
initialCapacity the initial capacity of the vector
Throws:
java.lang.IllegalArgumentException if the specified initial capacity is negative
142
 
143
     public Vector(int initialCapacity) {
144
         this(initialCapacity, 0);
145
     }

    
Constructs an empty vector so that its internal data array has size 10 and its standard capacity increment is zero. 
151
 
152
     public Vector() {
153
         this(10);
154
     }

    
Constructs a vector containing the elements of the specified collection, in the order they are returned by the collection's iterator.

Parameters:
c the collection whose elements are to be placed into this vector
Throws:
java.lang.NullPointerException if the specified collection is null
Since:
1.2
165
 
166
     public Vector(Collection<? extends E> c) {
167
          = c.toArray();
168
          = .;
169
         // c.toArray might (incorrectly) not return Object[] (see 6260652)
170
         if (.getClass() != Object[].class)
171
              = Arrays.copyOf(, , Object[].class);
172
     }

    
Copies the components of this vector into the specified array. The item at index k in this vector is copied into component k of anArray.

Parameters:
anArray the array into which the components get copied
Throws:
java.lang.NullPointerException if the given array is null
java.lang.IndexOutOfBoundsException if the specified array is not large enough to hold all the components of this vector
java.lang.ArrayStoreException if a component of this vector is not of a runtime type that can be stored in the specified array
See also:
toArray(java.lang.Object[])
186
 
187
     public synchronized void copyInto(Object[] anArray) {
188
         System.arraycopy(, 0, anArray, 0, );
189
     }

    
Trims the capacity of this vector to be the vector's current size. If the capacity of this vector is larger than its current size, then the capacity is changed to equal the size by replacing its internal data array, kept in the field elementData, with a smaller one. An application can use this operation to minimize the storage of a vector. 
198
 
199
     public synchronized void trimToSize() {
200
         ++;
201
         int oldCapacity = .;
202
         if ( < oldCapacity) {
203
              = Arrays.copyOf(, );
204
         }
205
     }

    
Increases the capacity of this vector, if necessary, to ensure that it can hold at least the number of components specified by the minimum capacity argument.

If the current capacity of this vector is less than minCapacity, then its capacity is increased by replacing its internal data array, kept in the field elementData, with a larger one. The size of the new data array will be the old size plus capacityIncrement, unless the value of capacityIncrement is less than or equal to zero, in which case the new capacity will be twice the old capacity; but if this new size is still smaller than minCapacity, then the new capacity will be minCapacity.

Parameters:
minCapacity the desired minimum capacity
223
 
224
     public synchronized void ensureCapacity(int minCapacity) {
225
         ++;
226
         ensureCapacityHelper(minCapacity);
227
     }

    
This implements the unsynchronized semantics of ensureCapacity. Synchronized methods in this class can internally call this method for ensuring capacity without incurring the cost of an extra synchronization.

See also:
ensureCapacity(int)
236
 
237
     private void ensureCapacityHelper(int minCapacity) {
238
         int oldCapacity = .;
239
         if (minCapacity > oldCapacity) {
240
             Object[] oldData = ;
241
             int newCapacity = ( > 0) ?
242
                 (oldCapacity + ) : (oldCapacity * 2);
243
             if (newCapacity < minCapacity) {
244
                 newCapacity = minCapacity;
245
             }
246
              = Arrays.copyOf(, newCapacity);
247
         }
248
     }

    
Sets the size of this vector. If the new size is greater than the current size, new null items are added to the end of the vector. If the new size is less than the current size, all components at index newSize and greater are discarded.

Parameters:
newSize the new size of this vector
Throws:
java.lang.ArrayIndexOutOfBoundsException if the new size is negative
258
 
259
     public synchronized void setSize(int newSize) {
260
         ++;
261
         if (newSize > ) {
262
             ensureCapacityHelper(newSize);
263
         } else {
264
             for (int i = newSize ; i <  ; i++) {
265
                 [i] = null;
266
             }
267
         }
268
          = newSize;
269
     }

    
Returns the current capacity of this vector.

Returns:
the current capacity (the length of its internal data array, kept in the field elementData of this vector)
277
 
278
     public synchronized int capacity() {
279
         return .;
280
     }

    
Returns the number of components in this vector.

Returns:
the number of components in this vector
286
 
287
     public synchronized int size() {
288
         return ;
289
     }

    
Tests if this vector has no components.

Returns:
true if and only if this vector has no components, that is, its size is zero; false otherwise.
297
 
298
     public synchronized boolean isEmpty() {
299
         return  == 0;
300
     }

    
Returns an enumeration of the components of this vector. The returned Enumeration object will generate all items in this vector. The first item generated is the item at index 0, then the item at index 1, and so on.

Returns:
an enumeration of the components of this vector
See also:
Iterator
310
 
311
     public Enumeration<E> elements() {
312
         return new Enumeration<E>() {
313
             int count = 0;
314
 
315
             public boolean hasMoreElements() {
316
                 return  < ;
317
             }
318
 
319
             public E nextElement() {
320
                 synchronized (Vector.this) {
321
                     if ( < ) {
322
                         return elementData(++);
323
                     }
324
                 }
325
                 throw new NoSuchElementException("Vector Enumeration");
326
             }
327
         };
328
     }

    
Returns true if this vector contains the specified element. More formally, returns true if and only if this vector contains at least one element e such that (o==null ? e==null : o.equals(e)).

Parameters:
o element whose presence in this vector is to be tested
Returns:
true if this vector contains the specified element
338
 
339
     public boolean contains(Object o) {
340
         return indexOf(o, 0) >= 0;
341
     }

    
Returns the index of the first occurrence of the specified element in this vector, or -1 if this vector does not contain the element. More formally, returns the lowest index i such that (o==null ? get(i)==null : o.equals(get(i))), or -1 if there is no such index.

Parameters:
o element to search for
Returns:
the index of the first occurrence of the specified element in this vector, or -1 if this vector does not contain the element
353
 
354
     public int indexOf(Object o) {
355
         return indexOf(o, 0);
356
     }

    
Returns the index of the first occurrence of the specified element in this vector, searching forwards from index, or returns -1 if the element is not found. More formally, returns the lowest index i such that (i >= index && (o==null ? get(i)==null : o.equals(get(i)))), or -1 if there is no such index.

Parameters:
o element to search for
index index to start searching from
Returns:
the index of the first occurrence of the element in this vector at position index or later in the vector; -1 if the element is not found.
Throws:
java.lang.IndexOutOfBoundsException if the specified index is negative
See also:
java.lang.Object.equals(java.lang.Object)
373
 
374
     public synchronized int indexOf(Object o, int index) {
375
         if (o == null) {
376
             for (int i = index ; i <  ; i++)
377
                 if ([i]==null)
378
                     return i;
379
         } else {
380
             for (int i = index ; i <  ; i++)
381
                 if (o.equals([i]))
382
                     return i;
383
         }
384
         return -1;
385
     }

    
Returns the index of the last occurrence of the specified element in this vector, or -1 if this vector does not contain the element. More formally, returns the highest index i such that (o==null ? get(i)==null : o.equals(get(i))), or -1 if there is no such index.

Parameters:
o element to search for
Returns:
the index of the last occurrence of the specified element in this vector, or -1 if this vector does not contain the element
397
 
398
     public synchronized int lastIndexOf(Object o) {
399
         return lastIndexOf(o, -1);
400
     }

    
Returns the index of the last occurrence of the specified element in this vector, searching backwards from index, or returns -1 if the element is not found. More formally, returns the highest index i such that (i <= index && (o==null ? get(i)==null : o.equals(get(i)))), or -1 if there is no such index.

Parameters:
o element to search for
index index to start searching backwards from
Returns:
the index of the last occurrence of the element at position less than or equal to index in this vector; -1 if the element is not found.
Throws:
java.lang.IndexOutOfBoundsException if the specified index is greater than or equal to the current size of this vector
417
 
418
     public synchronized int lastIndexOf(Object o, int index) {
419
         if (index >= )
420
             throw new IndexOutOfBoundsException(index + " >= "+ );
421
 
422
         if (o == null) {
423
             for (int i = index; i >= 0; i--)
424
                 if ([i]==null)
425
                     return i;
426
         } else {
427
             for (int i = index; i >= 0; i--)
428
                 if (o.equals([i]))
429
                     return i;
430
         }
431
         return -1;
432
     }

    
Returns the component at the specified index.

This method is identical in functionality to the get(int) method (which is part of the List interface).

Parameters:
index an index into this vector
Returns:
the component at the specified index
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index >= size())
444
 
445
     public synchronized E elementAt(int index) {
446
         if (index >= ) {
447
             throw new ArrayIndexOutOfBoundsException(index + " >= " + );
448
         }
449
 
450
         return elementData(index);
451
     }

    
Returns the first component (the item at index 0) of this vector.

Returns:
the first component of this vector
Throws:
NoSuchElementException if this vector has no components
459
 
460
     public synchronized E firstElement() {
461
         if ( == 0) {
462
             throw new NoSuchElementException();
463
         }
464
         return elementData(0);
465
     }

    
Returns the last component of the vector.

Returns:
the last component of the vector, i.e., the component at index size() - 1.
Throws:
NoSuchElementException if this vector is empty
473
 
474
     public synchronized E lastElement() {
475
         if ( == 0) {
476
             throw new NoSuchElementException();
477
         }
478
         return elementData( - 1);
479
     }

    
Sets the component at the specified index of this vector to be the specified object. The previous component at that position is discarded.

The index must be a value greater than or equal to 0 and less than the current size of the vector.

This method is identical in functionality to the set(int, E) method (which is part of the List interface). Note that the set method reverses the order of the parameters, to more closely match array usage. Note also that the set method returns the old value that was stored at the specified position.

Parameters:
obj what the component is to be set to
index the specified index
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index >= size())
500
 
501
     public synchronized void setElementAt(E obj, int index) {
502
         if (index >= ) {
503
             throw new ArrayIndexOutOfBoundsException(index + " >= " +
504
                                                      );
505
         }
506
         [index] = obj;
507
     }

    
Deletes the component at the specified index. Each component in this vector with an index greater or equal to the specified index is shifted downward to have an index one smaller than the value it had previously. The size of this vector is decreased by 1.

The index must be a value greater than or equal to 0 and less than the current size of the vector.

This method is identical in functionality to the remove(int) method (which is part of the List interface). Note that the remove method returns the old value that was stored at the specified position.

Parameters:
index the index of the object to remove
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index >= size())
527
 
528
     public synchronized void removeElementAt(int index) {
529
         ++;
530
         if (index >= ) {
531
             throw new ArrayIndexOutOfBoundsException(index + " >= " +
532
                                                      );
533
         }
534
         else if (index < 0) {
535
             throw new ArrayIndexOutOfBoundsException(index);
536
         }
537
         int j =  - index - 1;
538
         if (j > 0) {
539
             System.arraycopy(, index + 1, , index, j);
540
         }
541
         --;
542
         [] = null; /* to let gc do its work */
543
     }

    
Inserts the specified object as a component in this vector at the specified index. Each component in this vector with an index greater or equal to the specified index is shifted upward to have an index one greater than the value it had previously.

The index must be a value greater than or equal to 0 and less than or equal to the current size of the vector. (If the index is equal to the current size of the vector, the new element is appended to the Vector.)

This method is identical in functionality to the add(int, E) method (which is part of the List interface). Note that the add method reverses the order of the parameters, to more closely match array usage.

Parameters:
obj the component to insert
index where to insert the new component
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index > size())
567
 
568
     public synchronized void insertElementAt(E obj, int index) {
569
         ++;
570
         if (index > ) {
571
             throw new ArrayIndexOutOfBoundsException(index
572
                                                      + " > " + );
573
         }
574
         ensureCapacityHelper( + 1);
575
         System.arraycopy(, index, , index + 1,  - index);
576
         [index] = obj;
577
         ++;
578
     }

    
Adds the specified component to the end of this vector, increasing its size by one. The capacity of this vector is increased if its size becomes greater than its capacity.

This method is identical in functionality to the add(E) method (which is part of the List interface).

Parameters:
obj the component to be added
590
 
591
     public synchronized void addElement(E obj) {
592
         ++;
593
         ensureCapacityHelper( + 1);
594
         [++] = obj;
595
     }

    
Removes the first (lowest-indexed) occurrence of the argument from this vector. If the object is found in this vector, each component in the vector with an index greater or equal to the object's index is shifted downward to have an index one smaller than the value it had previously.

This method is identical in functionality to the remove(java.lang.Object) method (which is part of the List interface).

Parameters:
obj the component to be removed
Returns:
true if the argument was a component of this vector; false otherwise.
611
 
612
     public synchronized boolean removeElement(Object obj) {
613
         ++;
614
         int i = indexOf(obj);
615
         if (i >= 0) {
616
             removeElementAt(i);
617
             return true;
618
         }
619
         return false;
620
     }

    
Removes all components from this vector and sets its size to zero.

This method is identical in functionality to the clear() method (which is part of the List interface). 

627
 
628
     public synchronized void removeAllElements() {
629
         ++;
630
         // Let gc do its work
631
         for (int i = 0; i < ; i++)
632
             [i] = null;
633
 
634
          = 0;
635
     }

    
Returns a clone of this vector. The copy will contain a reference to a clone of the internal data array, not a reference to the original internal data array of this Vector object.

Returns:
a clone of this vector
643
 
644
     public synchronized Object clone() {
645
         try {
646
             @SuppressWarnings("unchecked")
647
                 Vector<E> v = (Vector<E>) super.clone();
648
             v.elementData = Arrays.copyOf(, );
649
             v.modCount = 0;
650
             return v;
651
         } catch (CloneNotSupportedException e) {
652
             // this shouldn't happen, since we are Cloneable
653
             throw new InternalError();
654
         }
655
     }

    
Returns an array containing all of the elements in this Vector in the correct order.

Since:
1.2
662
 
663
     public synchronized Object[] toArray() {
664
         return Arrays.copyOf(, );
665
     }

    
Returns an array containing all of the elements in this Vector in the correct order; the runtime type of the returned array is that of the specified array. If the Vector fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this Vector.

If the Vector fits in the specified array with room to spare (i.e., the array has more elements than the Vector), the element in the array immediately following the end of the Vector is set to null. (This is useful in determining the length of the Vector only if the caller knows that the Vector does not contain any null elements.)

Parameters:
a the array into which the elements of the Vector are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.
Returns:
an array containing the elements of the Vector
Throws:
java.lang.ArrayStoreException if the runtime type of a is not a supertype of the runtime type of every element in this Vector
java.lang.NullPointerException if the given array is null
Since:
1.2
689
 
690
     @SuppressWarnings("unchecked")
691
     public synchronized <T> T[] toArray(T[] a) {
692
         if (a.length < )
693
             return (T[]) Arrays.copyOf(, , a.getClass());
694
 
695
         System.arraycopy(, 0, a, 0, );
696
 
697
         if (a.length > )
698
             a[] = null;
699
 
700
         return a;
701
     }
702
 
703
     // Positional Access Operations
704
 
705
     @SuppressWarnings("unchecked")
706
     E elementData(int index) {
707
         return (E) [index];
708
     }

    
Returns the element at the specified position in this Vector.

Parameters:
index index of the element to return
Returns:
object at the specified index
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index >= size())
Since:
1.2
718
 
719
     public synchronized E get(int index) {
720
         if (index >= )
721
             throw new ArrayIndexOutOfBoundsException(index);
722
 
723
         return elementData(index);
724
     }

    
Replaces the element at the specified position in this Vector with the specified element.

Parameters:
index index of the element to replace
element element to be stored at the specified position
Returns:
the element previously at the specified position
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index >= size())
Since:
1.2
736
 
737
     public synchronized E set(int index, E element) {
738
         if (index >= )
739
             throw new ArrayIndexOutOfBoundsException(index);
740
 
741
         E oldValue = elementData(index);
742
         [index] = element;
743
         return oldValue;
744
     }

    
Appends the specified element to the end of this Vector.

Parameters:
e element to be appended to this Vector
Returns:
true (as specified by Collection.add(java.lang.Object))
Since:
1.2
752
 
753
     public synchronized boolean add(E e) {
754
         ++;
755
         ensureCapacityHelper( + 1);
756
         [++] = e;
757
         return true;
758
     }

    
Removes the first occurrence of the specified element in this Vector If the Vector does not contain the element, it is unchanged. More formally, removes the element with the lowest index i such that (o==null ? get(i)==null : o.equals(get(i))) (if such an element exists).

Parameters:
o element to be removed from this Vector, if present
Returns:
true if the Vector contained the specified element
Since:
1.2
770
 
771
     public boolean remove(Object o) {
772
         return removeElement(o);
773
     }

    
Inserts the specified element at the specified position in this Vector. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

Parameters:
index index at which the specified element is to be inserted
element element to be inserted
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index > size())
Since:
1.2
785
 
786
     public void add(int index, E element) {
787
         insertElementAt(element, index);
788
     }

    
Removes the element at the specified position in this Vector. Shifts any subsequent elements to the left (subtracts one from their indices). Returns the element that was removed from the Vector.

Parameters:
index the index of the element to be removed
Returns:
element that was removed
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index >= size())
Since:
1.2
800
 
801
     public synchronized E remove(int index) {
802
         ++;
803
         if (index >= )
804
             throw new ArrayIndexOutOfBoundsException(index);
805
         E oldValue = elementData(index);
806
 
807
         int numMoved =  - index - 1;
808
         if (numMoved > 0)
809
             System.arraycopy(, index+1, , index,
810
                              numMoved);
811
         [--] = null; // Let gc do its work
812
 
813
         return oldValue;
814
     }

    
Removes all of the elements from this Vector. The Vector will be empty after this call returns (unless it throws an exception).

Since:
1.2
821
 
822
     public void clear() {
823
         removeAllElements();
824
     }
825
 
826
     // Bulk Operations
827
 
    
Returns true if this Vector contains all of the elements in the specified Collection.

Parameters:
c a collection whose elements will be tested for containment in this Vector
Returns:
true if this Vector contains all of the elements in the specified collection
Throws:
java.lang.NullPointerException if the specified collection is null
837
 
838
     public synchronized boolean containsAll(Collection<?> c) {
839
         return super.containsAll(c);
840
     }

    
Appends all of the elements in the specified Collection to the end of this Vector, in the order that they are returned by the specified Collection's Iterator. The behavior of this operation is undefined if the specified Collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified Collection is this Vector, and this Vector is nonempty.)

Parameters:
c elements to be inserted into this Vector
Returns:
true if this Vector changed as a result of the call
Throws:
java.lang.NullPointerException if the specified collection is null
Since:
1.2
854
 
855
     public synchronized boolean addAll(Collection<? extends E> c) {
856
         ++;
857
         Object[] a = c.toArray();
858
         int numNew = a.length;
859
         ensureCapacityHelper( + numNew);
860
         System.arraycopy(a, 0, , , numNew);
861
          += numNew;
862
         return numNew != 0;
863
     }

    
Removes from this Vector all of its elements that are contained in the specified Collection.

Parameters:
c a collection of elements to be removed from the Vector
Returns:
true if this Vector changed as a result of the call
Throws:
java.lang.ClassCastException if the types of one or more elements in this vector are incompatible with the specified collection (optional)
java.lang.NullPointerException if this vector contains one or more null elements and the specified collection does not support null elements (optional), or if the specified collection is null
Since:
1.2
878
 
879
     public synchronized boolean removeAll(Collection<?> c) {
880
         return super.removeAll(c);
881
     }

    
Retains only the elements in this Vector that are contained in the specified Collection. In other words, removes from this Vector all of its elements that are not contained in the specified Collection.

Parameters:
c a collection of elements to be retained in this Vector (all other elements are removed)
Returns:
true if this Vector changed as a result of the call
Throws:
java.lang.ClassCastException if the types of one or more elements in this vector are incompatible with the specified collection (optional)
java.lang.NullPointerException if this vector contains one or more null elements and the specified collection does not support null elements (optional), or if the specified collection is null
Since:
1.2
898
 
899
     public synchronized boolean retainAll(Collection<?> c)  {
900
         return super.retainAll(c);
901
     }

    
Inserts all of the elements in the specified Collection into this Vector at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in the Vector in the order that they are returned by the specified Collection's iterator.

Parameters:
index index at which to insert the first element from the specified collection
c elements to be inserted into this Vector
Returns:
true if this Vector changed as a result of the call
Throws:
java.lang.ArrayIndexOutOfBoundsException if the index is out of range (index < 0 || index > size())
java.lang.NullPointerException if the specified collection is null
Since:
1.2
919
 
920
     public synchronized boolean addAll(int index, Collection<? extends E> c) {
921
         ++;
922
         if (index < 0 || index > )
923
             throw new ArrayIndexOutOfBoundsException(index);
924
 
925
         Object[] a = c.toArray();
926
         int numNew = a.length;
927
         ensureCapacityHelper( + numNew);
928
 
929
         int numMoved =  - index;
930
         if (numMoved > 0)
931
             System.arraycopy(, index, , index + numNew,
932
                              numMoved);
933
 
934
         System.arraycopy(a, 0, , index, numNew);
935
          += numNew;
936
         return numNew != 0;
937
     }

    
Compares the specified Object with this Vector for equality. Returns true if and only if the specified Object is also a List, both Lists have the same size, and all corresponding pairs of elements in the two Lists are equal. (Two elements e1 and e2 are equal if (e1==null ? e2==null : e1.equals(e2)).) In other words, two Lists are defined to be equal if they contain the same elements in the same order.

Parameters:
o the Object to be compared for equality with this Vector
Returns:
true if the specified Object is equal to this Vector
950
 
951
     public synchronized boolean equals(Object o) {
952
         return super.equals(o);
953
     }

    
Returns the hash code value for this Vector. 
957
 
958
     public synchronized int hashCode() {
959
         return super.hashCode();
960
     }

    
Returns a string representation of this Vector, containing the String representation of each element. 
965
 
966
     public synchronized String toString() {
967
         return super.toString();
968
     }

    
Returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the returned List is empty.) The returned List is backed by this List, so changes in the returned List are reflected in this List, and vice-versa. The returned List supports all of the optional List operations supported by this List.

This method eliminates the need for explicit range operations (of the sort that commonly exist for arrays). Any operation that expects a List can be used as a range operation by operating on a subList view instead of a whole List. For example, the following idiom removes a range of elements from a List: 

      list.subList(from, to).clear();
Similar idioms may be constructed for indexOf and lastIndexOf, and all of the algorithms in the Collections class can be applied to a subList.

The semantics of the List returned by this method become undefined if the backing list (i.e., this List) is structurally modified in any way other than via the returned List. (Structural modifications are those that change the size of the List, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.)

Parameters:
fromIndex low endpoint (inclusive) of the subList
toIndex high endpoint (exclusive) of the subList
Returns:
a view of the specified range within this List
Throws:
java.lang.IndexOutOfBoundsException if an endpoint index value is out of range (fromIndex < 0 || toIndex > size)
java.lang.IllegalArgumentException if the endpoint indices are out of order (fromIndex > toIndex)
1004
    public synchronized List<E> subList(int fromIndex, int toIndex) {
1005
        return Collections.synchronizedList(super.subList(fromIndex, toIndex),
1006
                                            this);
1007
    }

    
Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive. Shifts any succeeding elements to the left (reduces their index). This call shortens the list by (toIndex - fromIndex) elements. (If toIndex==fromIndex, this operation has no effect.) 
1016
    protected synchronized void removeRange(int fromIndex, int toIndex) {
1017
        ++;
1018
        int numMoved =  - toIndex;
1019
        System.arraycopy(, toIndex, , fromIndex,
1020
                         numMoved);
1022
        // Let gc do its work
1023
        int newElementCount =  - (toIndex-fromIndex);
1024
        while ( != newElementCount)
1025
            [--] = null;
1026
    }

    
Save the state of the Vector instance to a stream (that is, serialize it). This method is present merely for synchronization. It just calls the default writeObject method. 
1033
    private synchronized void writeObject(java.io.ObjectOutputStream s)
1034
        throws java.io.IOException
1035
    {
1036
        s.defaultWriteObject();
1037
    }

    
Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list. The specified index indicates the first element that would be returned by an initial call to next. An initial call to previous would return the element with the specified index minus one.

The returned list iterator is fail-fast.

Throws:
java.lang.IndexOutOfBoundsException
1051
    public synchronized ListIterator<E> listIterator(int index) {
1052
        if (index < 0 || index > )
1053
            throw new IndexOutOfBoundsException("Index: "+index);
1054
        return new ListItr(index);
1055
    }

    
Returns a list iterator over the elements in this list (in proper sequence).

The returned list iterator is fail-fast.

See also:
listIterator(int)
1065
    public synchronized ListIterator<E> listIterator() {
1066
        return new ListItr(0);
1067
    }

    
Returns an iterator over the elements in this list in proper sequence.

The returned iterator is fail-fast.

Returns:
an iterator over the elements in this list in proper sequence
1076
    public synchronized Iterator<E> iterator() {
1077
        return new Itr();
1078
    }

    
An optimized version of AbstractList.Itr 
1083
    private class Itr implements Iterator<E> {
1084
        int cursor;       // index of next element to return
1085
        int lastRet = -1; // index of last element returned; -1 if no such
1086
        int expectedModCount = ;
1088
        public boolean hasNext() {
1089
            // Racy but within spec, since modifications are checked
1090
            // within or after synchronization in next/previous
1091
            return  != ;
1092
        }
1094
        public E next() {
1095
            synchronized (Vector.this) {
1096
                checkForComodification();
1097
                int i = ;
1098
                if (i >= )
1099
                    throw new NoSuchElementException();
1100
                 = i + 1;
1101
                return elementData( = i);
1102
            }
1103
        }
1105
        public void remove() {
1106
            if ( == -1)
1107
                throw new IllegalStateException();
1108
            synchronized (Vector.this) {
1109
                checkForComodification();
1110
                Vector.this.remove();
1111
                 = ;
1112
            }
1113
             = ;
1114
             = -1;
1115
        }
1117
        final void checkForComodification() {
1118
            if ( != )
1119
                throw new ConcurrentModificationException();
1120
        }
1121
    }

    
An optimized version of AbstractList.ListItr 
1126
    final class ListItr extends Itr implements ListIterator<E> {
1127
        ListItr(int index) {
1128
            super();
1129
             = index;
1130
        }
1132
        public boolean hasPrevious() {
1133
            return  != 0;
1134
        }
1136
        public int nextIndex() {
1137
            return ;
1138
        }
1140
        public int previousIndex() {
1141
            return  - 1;
1142
        }
1144
        public E previous() {
1145
            synchronized (Vector.this) {
1146
                checkForComodification();
1147
                int i =  - 1;
1148
                if (i < 0)
1149
                    throw new NoSuchElementException();
1150
                 = i;
1151
                return elementData( = i);
1152
            }
1153
        }
1155
        public void set(E e) {
1156
            if ( == -1)
1157
                throw new IllegalStateException();
1158
            synchronized (Vector.this) {
1159
                checkForComodification();
1160
                Vector.this.set(, e);
1161
            }
1162
        }
1164
        public void add(E e) {
1165
            int i = ;
1166
            synchronized (Vector.this) {
1167
                checkForComodification();
1168
                Vector.this.add(i, e);
1169
                 = ;
1170
            }
1171
             = i + 1;
1172
             = -1;
1173
        }
1174
    }
New to GrepCode? Check out our FAQ X