Java/Collections Data Structure/Vector

Материал из Java эксперт
Версия от 10:24, 1 июня 2010; Admin (обсуждение | вклад) (1 версия)
(разн.) ← Предыдущая | Текущая версия (разн.) | Следующая → (разн.)
Перейти к: навигация, поиск

Содержание

Adaptive extension of the java.util.Vector class

   <source lang="java">

//revised from marf import java.util.Vector; import java.util.Collection; import java.util.List;

/**

*

Adaptive extension of the java.util.Vector class.

*
*

You may access elements of a Vector beyond it"s initial length --- the Vector * will be automaticall adjusted as appropriate.

*
*

Useful in the applications where desirable vector"s growth by setting an element * beyond its upper boundary automatticaly lengthens the vector to accomondate the * change (similar to Perl arrays).

*
*

Similarly, getting an element beyond the upper boundary is not desirable failure, but * an empty element returned. This makes the application to see as vector of a theoretically infinite * in length.

*
* TODO: allow negative index boundaries.
* 
* $Id: FreeVector.java,v 1.12 2005/08/11 00:44:50 mokhov Exp $
*
* @author Serguei Mokhov
* @version $Revision: 1.12 $
* @since 0.3.0.1
*/

public class FreeVector extends Vector { 

 /**
  * For serialization versioning.
  * When adding new members or make other structural
  * changes regenerate this number with the
  * serialver tool that comes with JDK.
  * @since 0.3.0.4
  */
 private static final long serialVersionUID = 8706834105778495182L;
 /**
  * A free vector with default capacity as specified by java.util.Vector.
  */
 public FreeVector()
 {
   super();
 }
 /**
  * Constructs this vector given capacity other than default.
  * Inherited from java.util.Vector.
  * @param piInitialCapacity initial element capacity (number of object placeholders)
  */
 public FreeVector(int piInitialCapacity)
 {
   super(piInitialCapacity);
 }
 /**
  * Constructs this vector given capacity and its increment.
  * Inherited from java.util.Vector.
  * @param piInitialCapacity initial element capacity (number of object placeholders)
  * @param piCapacityIncrement when current capacity reached, until how much capacity should be extened
  */
 public FreeVector(int piInitialCapacity, int piCapacityIncrement)
 {
   super(piInitialCapacity, piCapacityIncrement);
 }
 
 /**
  * Constructs this vector out of a collection.
  * Inherited from java.util.Vector.
  * @param poCollection collection for the vector elements.
  */
 public FreeVector(Collection poCollection)
 {
   super(poCollection);
 }
 
 /**
  * Access an element of the vector given index. 
  * Overridden from java.util.Vector.
  * @param piIndex vector element index to retrieve
  * @return object cotained at specified index, null if beyond boundary
  */
 public Object elementAt(int piIndex)
 {
   if(piIndex > size() - 1)
     return null;
   return super.elementAt(piIndex);
 }
 /**
  * Set an element of the vector given index.
  * Capacity is always ensured to be able to accomodate
  * any positive inidex (barring out of memory problems). 
  * Overridden from java.util.Vector.
  * 
  * @param poElement element to set at the index
  * @param piIndex the index
  */
 public void setElementAt(Object poElement, int piIndex)
 {
   ensureIndexCapacity(piIndex);
   super.setElementAt(poElement, piIndex);
 }
 /**
  * Inserts an element of the vector after given index.
  * Capacity is always ensured to be able to accomodate
  * any positive inidex (barring out of memory problems). 
  * Overridden from java.util.Vector.
  * 
  * @param poElement element to set after the index
  * @param piIndex the index
  */
 public void insertElementAt(Object poElement, int piIndex)
 {
   ensureIndexCapacity(piIndex);
   super.insertElementAt(poElement, piIndex);
 }
 /**
  * Make sure the capacity of the vector is enough
  * to hold an element with the specified index.
  * Has effect only if the index is greater than
  * the current vector"s size.
  * 
  * @param piIndex the index to accomodate
  */
 public void ensureIndexCapacity(int piIndex)
 {
   if(piIndex > size() - 1)
   {
     ensureCapacity(piIndex + 1);
     setSize(piIndex + 1);
   }
 }
 /**
  * Access an element of the vector given index. 
  * Overridden from java.util.Vector. Calls the overridden elementAt().
  * 
  * @param piIndex vector element index to retrieve
  * @return object cotained at specified index, null if beyond boundary
  */
 public synchronized Object get(int piIndex)
 {
   return elementAt(piIndex);
 }
 /**
  * Set an element of the vector given index.
  * Capacity is always ensured to be able to accomodate
  * any positive inidex (barring out of memory problems).
  * Overridden from java.util.Vector.
  * 
  * @param poElement element to set at the index
  * @param piIndex the index
  * @return object that was previously at that index.
  */
 public synchronized Object set(int piIndex, Object poElement)
 {
   Object oOldElement = elementAt(piIndex);
   setElementAt(poElement, piIndex);
   return oOldElement;
 }
 /**
  * Adds an element of the vector at the specified index. 
  * Overridden from java.util.Vector. Calls the overridden insertElementAt().
  * @param piIndex the index
  * @param poElement element to set after the index
  */
 public synchronized void add(int piIndex, Object poElement)
 {
   insertElementAt(poElement, piIndex);
 }
 /**
  * Removes an element at index.
  * If the index is beyond the upper boundary, returns null.  
  * Overrides java.util.Vector.
  * @param piIndex index of the element to be removed
  * @return object reference of the element just removed; null if index exceeds the upper bound
  */
 public synchronized Object remove(int piIndex)
 {
   if(piIndex >= size())
   {
     //???
     // 1 less than the index
     //ensureIndexCapacity(piIndex - 1);
     return null;
   }
   return super.remove(piIndex);
 }
 /**
  * Adds a collection of elements to this vector starting at given index.
  * Makes sure the capacity of the current vector reaches the piIndex. 
  * Overrides java.util.Vector.
  * 
  * @param piIndex starting index to add elements from
  * @param poCollection collection of elements to add
  * 
  * @return true if the vector has changed
  */
 public synchronized boolean addAll(int piIndex, Collection poCollection)
 {
   ensureIndexCapacity(piIndex);
   return super.addAll(piIndex, poCollection);
 }
 /**
  * Retrieves a sublist subset of vector elements given index boundaries.
  * Makes sure the capacity of the current vector reaches the piToIndex. 
  * Overrides java.util.Vector.
  * 
  * @param piFromIndex starting index to fetch elements from
  * @param piToIndex last index to fetch elements to
  * 
  * @return a corresponding List reference.
  */
 public synchronized List subList(int piFromIndex, int piToIndex)
 {
   ensureIndexCapacity(piToIndex);
   return super.subList(piFromIndex, piToIndex);
 }
 /**
  * Not implemented.
  * Meant to remove a set of elements between two specified indices.
  * @param piFromIndex starting index to remove elements from
  * @param piToIndex last index to remove elements to
  * @throws NotImplementedException
  */
 public synchronized void removeRange(int piFromIndex, int piToIndex)
 {
   // TODO: implement
   throw new RuntimeException( "removeRange()");
 }
 /**
  * Retrieves class" revision.
  * @return revision string
  * @since 0.3.0.2
  */
 public static String getMARFSourceCodeRevision()
 {
   return "$Revision: 1.12 $";
 }

} // EOF 


 </source>



Append all elements of other Collection to Java Vector

   <source lang="java">

import java.util.Vector; import java.util.ArrayList; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   ArrayList<String> arrayList = new ArrayList<String>();
   arrayList.add("4");
   arrayList.add("5");
   v.addAll(arrayList);
   for (int i = 0; i < v.size(); i++){
     System.out.println(v.get(i));
   }
 }

} 


 </source>



Copy all elements of Java Vector to an Object Array

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   Object[] objArray = new Object[5];
   v.copyInto(objArray);
   for (Object obj: objArray){
     System.out.println(obj);
   }
 }

} 


 </source>



Copy Elements of One Java Vector to Another Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v1 = new Vector<String>();
   v1.add("1");
   v1.add("2");
   v1.add("3");
   Vector<String> v2 = new Vector<String>();
   v2.add("One");
   v2.add("Two");
   v2.add("Three");
   v2.add("Four");
   v2.add("Five");
   System.out.println(v2);
   Collections.copy(v2, v1);
   System.out.println(v2);
 }

} /*[One, Two, Three, Four, Five] [1, 2, 3, Four, Five]

  • /


 </source>



Copy Elements of Vector to Java ArrayList

   <source lang="java">

import java.util.ArrayList; import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   ArrayList<String> arrayList = new ArrayList<String>();
   arrayList.add("One");
   arrayList.add("Two");
   arrayList.add("Three");
   arrayList.add("Four");
   arrayList.add("Five");
   System.out.println(arrayList);
   Collections.copy(arrayList, v);
   System.out.println(arrayList);
 }

} /* [One, Two, Three, Four, Five] [1, 2, 3, Four, Five]

  • /


 </source>



Count distinct elements in a Vector

   <source lang="java">

import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; public class Main { 

 public static void main(String[] argv) {
   List<String> list = new ArrayList<String>();
   list.add("A");
   list.add("2");
   list.add("c2");
   
   System.out.println(countDistinctElements(list, 0, list.size()));
 }
 static int countDistinctElements(List source, int position, int count){
   List list = source.subList(position, position + count);
   Set set = new HashSet();
   set.addAll(list);
   return set.size();
 }

} 


 </source>



Create Java ArrayList From Enumeration

   <source lang="java">

import java.util.ArrayList; import java.util.Collections; import java.util.Enumeration; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("A");
   v.add("B");
   v.add("D");
   v.add("E");
   v.add("F");
   System.out.println(v);
   Enumeration e = v.elements();
   ArrayList<String> aList = Collections.list(e);
   System.out.println(aList);
 }

} /* [A, B, D, E, F] [A, B, D, E, F]

  • /


 </source>



Create Vector test

   <source lang="java">

import java.util.Vector; public class CreateVector { 

 public static void main(String args[]) {
   {
     Vector v = new Vector(0);
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
   }
   {
     Vector v = new Vector();
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
     v.addElement("Hello");
     System.out.println(v.capacity());
   }
 }

} 



 </source>



Enumerate through a Vector using Java Enumeration

   <source lang="java">

import java.util.Enumeration; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("One");
   v.add("Two");
   v.add("Three");
   v.add("Four");
   Enumeration e = v.elements();
   while (e.hasMoreElements())
     System.out.println(e.nextElement());
 }

} 


 </source>



Finding elements in a vector

   <source lang="java">

import java.util.Vector; public class FindVector { 

 public static void main(String args[]) {
   String data[] = { "Java", "Source", "and", "Support", "."};
   
   Vector v = new Vector();
   for (int i = 0, n = data.length; i < n; i++) {
     v.add(data[i]);
   }
   System.out.println(v);
   System.out.println("Contains Java?: " + v.contains("Java"));
   System.out.println("Contains jexp?: " + v.contains("jexp"));
   System.out.println("Where"s and?: " + v.indexOf("and"));
   System.out.println("Where"s Source?: " + v.indexOf("Source"));
   System.out.println("Where"s Java from end?: "
       + v.lastIndexOf("Java"));
 }

} 


 </source>



Find maximum element of Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<Double> v = new Vector<Double>();
   v.add(new Double("3.4324"));
   v.add(new Double("3.3532"));
   v.add(new Double("3.342"));
   v.add(new Double("3.349"));
   v.add(new Double("2.3"));
   Object obj = Collections.max(v);
   System.out.println(obj);
 }

} //3.4324 


 </source>



Find Minimum element of Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<Double> v = new Vector<Double>();
   v.add(new Double("3.4"));
   v.add(new Double("3.3"));
   v.add(new Double("4.4"));
   v.add(new Double("5.3"));
   v.add(new Double("3.3"));
   Object obj = Collections.min(v);
   System.out.println(obj);
 }

} 


 </source>



Find Vector

   <source lang="java">

import java.util.Vector; public class FindVector2 { 

 static String members[] = { "Ralph", "Waldo", "Emerson", "Henry", "David",
     "Thoreau", "Walden", "Pond", "Thoreau", "Institute" };
 public static void main(String args[]) {
   Vector v = new Vector();
   for (int i = 0, n = members.length; i < n; i++) {
     v.add(members[i]);
   }
   System.out.println(v);
   System.out.println("Contains Society?: " + v.contains("Society"));
   System.out.println("Contains Waldo?: " + v.contains("Waldo"));
   System.out.println("Where"s Waldo?: " + v.indexOf("Waldo"));
   System.out.println("Where"s Thoreau?: " + v.indexOf("Thoreau"));
   System.out.println("Where"s Thoreau from end?: "
       + v.lastIndexOf("Thoreau"));
   int index = 0;
   int length = v.size();
   while ((index < length) && (index >= 0)) {
     index = v.indexOf("Thoreau", index);
     if (index != -1) {
       System.out.println(v.get(index));
       index++;
     }
   }
 }

} 


 </source>



Generic Vector with String

   <source lang="java">

import java.util.Vector; public class MainClass { 

 static void addCode(String code) {
   if (!list.contains(code)) {
     list.add(code);
   }
 }
 static Vector<String> list;
 public static void main(String[] arguments) {
   String[] codes = { "alpha", "lambda", "gamma", "delta", "zeta" };
   list = new Vector<String>();
   for (int i = 0; i < codes.length; i++) {
     addCode(codes[i]);
   }
   for (int j = 0; j < codes.length; j++) {
     addCode(codes[j]);
   }
   for (String code : list) {
     System.out.println(code);
   }
 }

} 


 </source>



Get Enumeration over Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Enumeration; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("A");
   v.add("B");
   v.add("D");
   v.add("E");
   v.add("F");
   Enumeration e = Collections.enumeration(v);
   while (e.hasMoreElements())
     System.out.println(e.nextElement());
 }

} 


 </source>



Get Size of Java Vector and loop through the elements

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   System.out.println( v.size());
   for (String str: v){
     System.out.println(str);
   }
 }

} 


 </source>



Get Sub List of Java Vector Example

   <source lang="java">

import java.util.List; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   List lst = v.subList(1, 3);
   for (String str : v) {
     System.out.println(str);
   }
   Object obj = lst.remove(0);
   for (String str : v) {
     System.out.println(str);
   }
 }

} 


 </source>



Insert all elements of other Collection to Specified Index of Java Vector

   <source lang="java">

import java.util.ArrayList; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   ArrayList<String> arrayList = new ArrayList<String>();
   arrayList.add("4");
   arrayList.add("5");
   
   v.addAll(1, arrayList);
   for (String str: v)
     System.out.println(str);
 }

} 


 </source>



Iterate through elements Java Vector using Iterator

   <source lang="java">

import java.util.Iterator; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   Iterator itr = v.iterator();
   while (itr.hasNext()){
     System.out.println(itr.next());
   }
 }

} 


 </source>



Iterate through elements Java Vector using ListIterator

   <source lang="java">

import java.util.ListIterator; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   ListIterator itr = v.listIterator();
   while (itr.hasNext()){
     System.out.println(itr.next());
   }
   while (itr.hasPrevious()){
     System.out.println(itr.previous());
   }
 }

} 


 </source>



Iterator out of Vector

   <source lang="java">

import java.util.Iterator; import java.util.Vector; public class Main { 

 public static void main(String[] arguments) {
   String[] codes = { "alpha", "lambda", "gamma", "delta", "zeta" };
   Vector list = new Vector();
   for (int i = 0; i < codes.length; i++) {
     if (!list.contains(codes[i])) {
       list.add(codes[i]);
     }
   }
   for (Iterator ite = list.iterator(); ite.hasNext();) {
     String output = (String) ite.next();
     System.out.println(output);
   }
 }

} 


 </source>



Perform Binary Search on Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("Z");
   v.add("B");
   v.add("D");
   v.add("E");
   v.add("F");
   Collections.sort(v);
   System.out.println(v);
   int index = Collections.binarySearch(v, "D");
   System.out.println("Element found at : " + index);
 }

} /*[B, D, E, F, Z] Element found at : 1

  • /


 </source>



Remove all elements from Java Vector

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   System.out.println(v.size());
   v.clear();
   // OR v.removeAllElements();
   System.out.println(v.size());
 }

} 


 </source>



Remove an element from specified index of Java Vector

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   Object obj = v.remove(1);
   System.out.println(obj + " is removed from Vector");
   for (String str: v)
     System.out.println(str);
   v.removeElementAt(2);
   for (String str: v)
     System.out.println(str);
 }

} 


 </source>



Remove Element in Vector

   <source lang="java">

import java.util.Vector; public class RemoveVector { 

 static boolean removeAll(Vector v, Object e) {
   Vector v1 = new Vector();
   v1.add(e);
   return v.removeAll(v1);
 }
 public static void main (String args[]) {
   Vector v = new Vector();
   for (int i=0, n=args.length; i<n; i++) {
     v.add(args[i]);
   }
   System.out.println(removeAll(v, args[0]));
   System.out.println(v);
 }

} 



 </source>



Remove specified element from Java Vector

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   System.out.println(v.remove("2"));
   for (String str: v){
     System.out.println(str);
   }
   System.out.println(v.removeElement("3"));
   for (String str: v){
     System.out.println(str);
   }
 }

} 


 </source>



Replace All Elements Of Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("A");
   v.add("B");
   v.add("D");
   System.out.println(v);
   Collections.fill(v, "REPLACED");
   System.out.println(v);
 }

} /* [A, B, D] [REPLACED, REPLACED, REPLACED]

  • /


 </source>



Replace all occurrences of specified element of Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("A");
   v.add("B");
   v.add("A");
   v.add("C");
   v.add("D");
   System.out.println(v);
   Collections.replaceAll(v, "A", "Replace All");
   System.out.println(v);
 }

} 


 </source>



Replace an element at specified index of Java Vector

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   
   v.set(1, "REPLACED ELEMENT");
   for (String str : v) {
     System.out.println(str);
   }
 }

} 


 </source>



Reverse order of all elements of Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("A");
   v.add("B");
   v.add("C");
   v.add("D");
   v.add("E");
   System.out.println(v);
   Collections.reverse(v);
   System.out.println(v);
 }

} /* [A, B, C, D, E] [E, D, C, B, A]

  • /


 </source>



Save Vector to file

   <source lang="java">

import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.Arrays; import java.util.Enumeration; import java.util.Vector; public class SaveVector1 { 

 public static void main(String args[]) throws Exception {
   Vector v = new Vector(Arrays.asList(args));
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   ObjectOutputStream oos = new ObjectOutputStream(baos);
   oos.writeObject(v);
   oos.close();
   ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
   ObjectInputStream ois = new ObjectInputStream(bais);
   Vector v2 = (Vector) ois.readObject();
   Enumeration e = v.elements();
   while (e.hasMoreElements()) {
     System.out.println(e.nextElement());
   }
 }

} 



 </source>



Search an element of Java Vector

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   v.add("1");
   v.add("2");
   System.out.println(v.contains("3"));
   System.out.println(v.indexOf("5"));
   System.out.println(v.lastIndexOf("2"));
 }

} 


 </source>



Search an element of Java Vector from specific index

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   v.add("1");
   v.add("2");
   System.out.println(v.indexOf("1", 4));
   System.out.println(v.lastIndexOf("2", 5));
 }

} 


 </source>



Sequence

   <source lang="java">

import java.io.BufferedReader; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; import java.io.SequenceInputStream; import java.util.Enumeration; import java.util.Vector; public class Sequence { 

 public static void main(String args[]) throws IOException {
   Vector v = new Vector(3);
   v.add(new FileInputStream("/etc/motd"));
   v.add(new FileInputStream("foo.bar"));
   v.add(new FileInputStream("/temp/john.txt"));
   Enumeration e = v.elements();
   SequenceInputStream sis = new SequenceInputStream(e);
   InputStreamReader isr = new InputStreamReader(sis);
   BufferedReader br = new BufferedReader(isr);
   String line;
   while ((line = br.readLine()) != null) {
     System.out.println(line);
   }
   br.close();
 }

} 


 </source>



Serializing a vector

   <source lang="java">

import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.Arrays; import java.util.Enumeration; import java.util.Vector; public class SaveVector { 

 public static void main(String args[]) throws Exception {
   String data[] = { "Java", "Source", "and", "Support", "."};
   Vector v = new Vector(Arrays.asList(data));
   ByteArrayOutputStream b = new ByteArrayOutputStream();
   ObjectOutputStream o = new ObjectOutputStream(b);
   o.writeObject(v);
   o.close();
   ByteArrayInputStream bb = new ByteArrayInputStream(b.toByteArray());
   ObjectInputStream oo = new ObjectInputStream(bb);
   Vector v2 = (Vector) oo.readObject();
   Enumeration e = v.elements();
   while (e.hasMoreElements()) {
     System.out.println(e.nextElement());
   }
 }

} 


 </source>



Set size of Java Vector Example

   <source lang="java">

import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   v.setSize(3);
   for (String str : v) {
     System.out.println(str);
   }
   v.setSize(5);
   for (String str : v) {
     System.out.println(str);
   }
 }

} 


 </source>



Shuffle elements of Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   System.out.println(v);
   Collections.shuffle(v);
   System.out.println(v);
 }

} /*[1, 2, 3, 4, 5] [5, 4, 1, 3, 2]

  • /


 </source>



Sort elements of Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("3");
   v.add("5");
   v.add("2");
   v.add("4");
   Collections.sort(v);
   for (String str : v){
     System.out.println(str);
   }      
 }

} 


 </source>



Sort Java Vector in descending order using comparator

   <source lang="java">

import java.util.Collections; import java.util.ruparator; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   Comparator comparator = Collections.reverseOrder();
   System.out.println(v);
   Collections.sort(v, comparator);
   System.out.println(v);
 }

} 


 </source>



Swap elements of Java Vector

   <source lang="java">

import java.util.Collections; import java.util.Vector; public class Main { 

 public static void main(String[] args) {
   Vector<String> v = new Vector<String>();
   v.add("1");
   v.add("2");
   v.add("3");
   v.add("4");
   v.add("5");
   System.out.println(v);
   Collections.swap(v, 0, 4);
   System.out.println(v);
 }

} 


 </source>



Unmodifiable Vector Adapter

   <source lang="java">

/* 

* $Id: UnmodifiableVectorAdapter.java,v 1.1.1.1 2005/04/07 18:36:25 pocho Exp $
*/

import java.util.Collection; import java.util.List; import java.util.Vector; /** 

* Adapter that adapts any {@link java.util.List} to {@link java.util.Vector} class.
* 
* @version $Name:  $ - $Revision: 1.1.1.1 $ - $Date: 2005/04/07 18:36:25 $
*/

public class UnmodifiableVectorAdapter extends Vector { 

 private List adaptedList;
 
 public UnmodifiableVectorAdapter(List list) {
   setAdaptedList(list);
 }
 
 public void setAdaptedList(List list) {
   this.adaptedList = list;
 }
 
 public boolean contains(Object elem) {
   return adaptedList.contains(elem);
 }
 
 public boolean containsAll(Collection c) {
   return adaptedList.containsAll(c);
 }
 
 public Object elementAt(int index) {
   return adaptedList.get(index);
 }
 
 public Object get(int index) {
   return adaptedList.get(index);
 }
 
 public int indexOf(Object elem) {
   return adaptedList.indexOf(elem);
 }
 
 public int indexOf(Object elem, int index) {
   return subList(index, size()).indexOf(elem);
 }
 public boolean isEmpty() {
   return adaptedList.isEmpty();    
 }
 
 public Object lastElement() {
   return adaptedList.get(size() - 1);
 }
 
 public int lastIndexOf(Object elem) {
   return adaptedList.lastIndexOf(elem);
 }
 
 public int lastIndexOf(Object elem, int index) {
   return subList(0, index).indexOf(elem);
 }
 
 public int size() {
   return adaptedList.size();
 }
 
 public List subList(int fromIndex, int toIndex) {
   return adaptedList.subList(fromIndex, toIndex);
 }
 public Object[] toArray() {
   return adaptedList.toArray();
 }
 
 public Object[] toArray(Object[] a) {
   return adaptedList.toArray(a);
 }
 public String toString() {
   return adaptedList.toString();
 }
 
 public void add(int index, Object element) { 
   throw new UnsupportedOperationException();
 }
 
 
 public boolean add(Object o) {
   throw new UnsupportedOperationException();
 }
 
 public boolean addAll(Collection c) {
   throw new UnsupportedOperationException();
 }
 
 public boolean addAll(int index, Collection c) {
   throw new UnsupportedOperationException(); 
 }
 
 public void addElement(Object obj) {
   throw new UnsupportedOperationException();
 }
 
 public void clear() { 
   throw new UnsupportedOperationException();
 }
 
 public Object clone() {
   throw new UnsupportedOperationException();
 }
 public void insertElementAt(Object obj, int index) {
   throw new UnsupportedOperationException();
 }
 public Object remove(int index) {
   throw new UnsupportedOperationException();
 }
 
 public boolean remove(Object o) {
   throw new UnsupportedOperationException();
 }
 
 public boolean removeAll(Collection c) {
   throw new UnsupportedOperationException();
 }
 
 public void removeAllElements() {
   throw new UnsupportedOperationException();
 }
 
 public boolean removeElement(Object obj) {
   throw new UnsupportedOperationException();
 }
 public void removeElementAt(int index) {
   throw new UnsupportedOperationException();
 }
 public boolean retainAll(Collection c) {
   throw new UnsupportedOperationException();
 }
 
 public Object set(int index, Object element) {
   throw new UnsupportedOperationException();
 }
 
 public void setElementAt(Object obj, int index) {
   throw new UnsupportedOperationException();
 }
 
 
 public void setSize(int newSize) {
   throw new UnsupportedOperationException();
 }

} 


 </source>



Use Vector in java.util

   <source lang="java">

import java.util.Vector; public class VectorBenchmark1 { 

 public static final int MaxSize = 100000;
 public static final int NTRIES = 10;
 public static void main(String[] args) {
   Vector v = new Vector();
   long start = System.currentTimeMillis();
   for (int i = 0; i < MaxSize; i++)
     v.add(new Integer(i));
   long end = System.currentTimeMillis();
   System.out.println("Allocating vector elements: " + (end - start)
       + " milliseconds");
   Integer[] integerArray = new Integer[1];
   start = System.currentTimeMillis();
   for (int i = 0; i < MaxSize; i++) {
     if (i >= integerArray.length) {
       Integer[] b = new Integer[i * 2];
       System.arraycopy(integerArray, 0, b, 0, integerArray.length);
       integerArray = b;
     }
     integerArray[i] = new Integer(i);
   }
   end = System.currentTimeMillis();
   System.out.println("Allocating array elements:  " + (end - start)
       + " milliseconds");
   start = System.currentTimeMillis();
   for (int j = 0; j < NTRIES; j++)
     for (int i = 0; i < MaxSize; i++) {
       Integer r = (Integer) v.get(i);
       v.set(i, new Integer(r.intValue() + 1));
     }
   end = System.currentTimeMillis();
   System.out.println("Accessing vector elements:  " + (end - start)
       + " milliseconds");
   start = System.currentTimeMillis();
   for (int j = 0; j < NTRIES; j++)
     for (int i = 0; i < MaxSize; i++) {
       Integer r = integerArray[i];
       integerArray[i] = new Integer(r.intValue() + 1);
     }
   end = System.currentTimeMillis();
   System.out.println("Accessing array elements:   " + (end - start)
       + " milliseconds");
 }

} 


 </source>



Vector Util

   <source lang="java">

/* Software Architecture Design Patterns in Java by Partha Kuchana Auerbach Publications

  • /

import java.util.Vector; public class MiscUtil { 

 public static boolean hasDuplicates(Vector v) {
   int i = 0;
   int j = 0;
   boolean duplicates = false;
   for (i = 0; i < v.size() - 1; i++) {
     for (j = (i + 1); j < v.size(); j++) {
       if (v.elementAt(i).toString().equalsIgnoreCase(
           v.elementAt(j).toString())) {
         duplicates = true;
       }
     }
   }
   return duplicates;
 }
 public static Vector removeDuplicates(Vector s) {
   int i = 0;
   int j = 0;
   boolean duplicates = false;
   Vector v = new Vector();
   for (i = 0; i < s.size(); i++) {
     duplicates = false;
     for (j = (i + 1); j < s.size(); j++) {
       if (s.elementAt(i).toString().equalsIgnoreCase(
           s.elementAt(j).toString())) {
         duplicates = true;
       }
     }
     if (duplicates == false) {
       v.addElement(s.elementAt(i).toString().trim());
     }
   }
   return v;
 }
 public static Vector removeDuplicateDomains(Vector s) {
   int i = 0;
   int j = 0;
   boolean duplicates = false;
   String str1 = "";
   String str2 = "";
   Vector v = new Vector();
   for (i = 0; i < s.size(); i++) {
     duplicates = false;
     for (j = (i + 1); j < s.size(); j++) {
       str1 = "";
       str2 = "";
       str1 = s.elementAt(i).toString().trim();
       str2 = s.elementAt(j).toString().trim();
       if (str1.indexOf("@") > -1) {
         str1 = str1.substring(str1.indexOf("@"));
       }
       if (str2.indexOf("@") > -1) {
         str2 = str2.substring(str2.indexOf("@"));
       }
       if (str1.equalsIgnoreCase(str2)) {
         duplicates = true;
       }
     }
     if (duplicates == false) {
       v.addElement(s.elementAt(i).toString().trim());
     }
   }
   return v;
 }
 public static boolean areVectorsEqual(Vector a, Vector b) {
   if (a.size() != b.size()) {
     return false;
   }
   int i = 0;
   int vectorSize = a.size();
   boolean identical = true;
   for (i = 0; i < vectorSize; i++) {
     if (!(a.elementAt(i).toString().equalsIgnoreCase(b.elementAt(i)
         .toString()))) {
       identical = false;
     }
   }
   return identical;
 }
 public static Vector removeDuplicates(Vector a, Vector b) {
   int i = 0;
   int j = 0;
   boolean present = true;
   Vector v = new Vector();
   for (i = 0; i < a.size(); i++) {
     present = false;
     for (j = 0; j < b.size(); j++) {
       if (a.elementAt(i).toString().equalsIgnoreCase(
           b.elementAt(j).toString())) {
         present = true;
       }
     }
     if (!(present)) {
       v.addElement(a.elementAt(i));
     }
   }
   return v;
 }

}// end of class 



 </source>
Источник — «http://jexp.ru/index.php?title=Java/Collections_Data_Structure/Vector&oldid=9079»