• Tags         
  • 2018-08-05  15:46:54        
  • 73 °C    

    Vector类实现了一个可增长的对象数组。向量基本上属于遗留类,但现在它与集合完全兼容。

    • Vector实现了一个动态数组,这意味着它可以根据需要增长或缩小。像数组一样,它包含可以使用整数索引访问的组件
    • 它们与ArrayList非常相似,但Vector是同步的,并且有一些遗留方法,其中包含集合框架。
    • 它扩展了AbstractList并实现了List接口。

    Vector类构造函数

    • Vector():创建初始容量的默认向量为10。
    • Vector(int size):创建一个初始容量由size指定的向量。
    • Vector(int size,int incr):创建一个向量,其初始容量由大小指定,增量由incr指定。它指定每次向上调整向量大小时要分配的元素数。
    • Vector(Collection c):创建一个包含集合c元素的向量。

    关于Vector类容量递增的要点

    如果指定了递增,则Vector将在每个分配周期中根据它进行扩展,但如果未指定递增,则向量的容量在每个分配周期中加倍。Vector定义了三个受保护数据成员:

    • int capacityIncreament:包含增量值。
    • int elementCount:当前存储在其中的向量中的元素数。
    • Object elementData []: 包含向量的数组存储在其中。

    Java中的Java.util.Vector类方法

    下面几个方法都是Java.util.Vector类常用的方法:

    boolean add(Object obj)

    此方法将指定的元素追加到此向量的末尾。

    语法: public boolean add(Object obj)
     返回:如果添加了指定的元素,则返回 true
    成功进入Vector,否则返回false。
    异常: NA。
    
    // Java code illustrating add() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector
            Vector v = new Vector();
           
            
            v.add(1);
            v.add(2);
            v.add("geeks");
            v.add("forGeeks");
            v.add(3);
           
            System.out.println("Vector is " + v);
                  
        }
    }
    

    输出:

    [1, 2, geeks, forGeeks, 3]

    void add(int index,Object obj)

    此方法将指定元素插入此Vector中的指定位置。

    语法: public void add(int index,Object obj)
     返回: NA。
    异常: IndexOutOfBoundsException,方法抛出此异常
    如果我们试图访问的索引(obj位置)超出范围 
    (索引大小())。
    
    // Java code illustrating add() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector
            Vector v = new Vector();
           
            
            v.add(0, 1);
            v.add(1, 2);
            v.add(2, "geeks");
            v.add(3, "forGeeks");
            v.add(4, 3);
           
            System.out.println("Vector is " + v);
                  
        }
    }
    

    输出:

    Vector is: [1, 2, geeks, forGeeks, 3]

    boolean addAll(Collection c)

    此方法将
    指定Collection中的所有元素追加到此Vector的末尾。

    语法: public boolean addAll(Collection c)
     返回:如果操作成功则返回true,否则返回false。
    异常:如果collection为null,则抛出NullPointerException。
    
    // Java code illustrating addAll()
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           ArrayList arr = new ArrayList();
           arr.add(3);
           arr.add("geeks");
           arr.add("forgeeks");
           arr.add(4);
           
          
            // createn default vector
            Vector v = new Vector();
            
           
            // copying all element of array list int0 vector
            v.addAll(arr);
            
            // checking vector v
            System.out.println("vector v:" + v);
        }
    }
    

    输出:

    vector v:[3, geeks, forgeeks, 4]

    boolean addAll(int index,Collection c)

    此方法将指定Collection中的所有元素插入到指定的Vector中。
    位置。

    语法: public boolean addAll(int index,Collection c)
     返回:如果此列表因调用而更改,则返回 true。
    异常: IndexOutOfBoundsException  - 如果索引超出范围,
    NullPointerException  - 如果指定的集合为null。                           
    
    // Java code illustrating addAll()
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           ArrayList arr = new ArrayList();
           arr.add(3);
           arr.add("geeks");
           arr.add("forgeeks");
           arr.add(4);
           
          
            // createn default vector
            Vector v = new Vector();
            
            v.add(2);
            // copying all element of array list int0 vector
            v.addAll(1, arr);
            
            // checking vector v
            System.out.println("vector v:" + v);
         } 
    }
    

    输出:

    vector v:[2, 3, geeks, forgeeks, 4]

    void clear()

    此方法从此向量中删除所有元素。

    语法: public void clear()
     返回: NA。
    异常: NA。
    
    // Java code illustrating clear() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector
            Vector v = new Vector();
           
            
            v.add(0, 1);
            v.add(1, 2);
            v.add(2, "geeks");
            v.add(3, "forGeeks");
            v.add(4, 3);
           
            System.out.println("Vector is: " + v);
            
            //clearing the vector
            v.clear();
            
            // checking vector
            System.out.println("after clearing: " + v);
                  
        }
    }
    

    输出:

    Vector is: [1, 2, geeks, forGeeks, 3]
    after clearing: []

    Object clone()

    此方法返回此向量的副本。

    语法: public Object clone()
     返回:此ArrayList实例的克隆。
    异常: NA。
    
    // Java code illustrating clone()
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector
            Vector v = new Vector();
           
            Vector v_clone = new Vector();
            
            v.add(0, 1);
            v.add(1, 2);
            v.add(2, "geeks");
            v.add(3, "forGeeks");
            v.add(4, 3);
          
            v_clone = (Vector)v.clone();
            
            // checking vector
            System.out.println("Clone of v: " + v_clone);
                  
        }
    }
    

    输出:

    Clone of v: [1, 2, geeks, forGeeks, 3]

    boolean contains(Object o)

    如果此向量包含指定的元素,则此方法返回true。

    语法: public boolean contains(object o)
     返回:如果操作成功则返回 true,否则返回false。
    异常: NA。
    
    // Java code illustrating contains() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector
            Vector v = new Vector();
           
            
            v.add(1);
            v.add(2);
            v.add("geeks");
            v.add("forGeeks");
            v.add(3);
          
            // check whether vector contains "forGeeks"
            if(v.contains("forGeeks"))
            System.out.println("forGeeks exists");
            
           
        }
    }
    

    输出:

    forGeeks exists
    

    void ensureCapacity(int minCapacity)

    如果需要,此方法会增加此向量的容量,以确保它至少可以保存最小容量参数指定的组件数。

    语法: public void ensureCapacity(int minCapacity)
     返回: NA。
    异常: NA。
    
    // Java code illustrating ensureCapacity() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            // ensuring capacity
            v.ensureCapacity(22);
            
            // cheking capacity
            System.out.println("Minimum capacity: " + v.capacity());
           
        }
    }
    

    输出:

    Minimum capacity: 22

    Object get(int index)

    此方法返回此Vector中指定位置的元素。

    语法: public void ensureCapacity(int minCapacity)
     返回:返回指定位置的元素。
    异常: IndexOutOfBoundsException  - 如果索引超出范围。
    
    // Java code illustrating get() methods
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
            // get the element at index 2
            System.out.println("element at indexx 2 is: " + v.get(2));
           
        }
    }
    

    输出:

    element at indexx 2 is: Geeks

    int indexOf(Object o)

    此方法返回此向量中第一次出现的指定元素的索引,如果此向量不包含该元素,则返回-1。

    语法: public int indexOf(Object o)
     返回:指定的第一个匹配项的索引
    此列表中的元素,如果此列表不包含该元素,则返回-1。
    异常: NA。
    
    // Java code illustrating indexOf() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
            // get the element at index of Geeks
            System.out.println("index of Geeks is: " + v.indexOf("Geeks"));
           
        }
    }
    

    输出:

    index of Geeks is: 2

    boolean isEmpty()

    此方法测试此向量是否没有组件。

    语法: public boolean isEmpty()
     返回:如果vector为空则返回 true,否则返回 false。
    异常: NA。
    
    // Java code illustrating isEmpty() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
            v.clear();
            
            // check whether vector is empty or not
            if(v.isEmpty())
            System.out.println("Vector is clear");
           
        }
    }
    

    输出:

    Vector is clear

    int lastIndexOf(Object o)

    此方法返回此向量中指定元素最后一次出现的索引,如果此向量不包含该元素,则返回-1。

    语法: public int lastIndexOf(Object o)
     返回:返回最后一次出现的索引
    此列表中的指定元素,如果此列表不包含该元素,则返回-1。
    异常: NA。
    
    // Java code illustrating lastIndexof()
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
            // checking last occurance of 2
            System.out.println("last occurance of 2 is: " + v.lastIndexOf(2));
           
        }
    }
    

    输出:

    last occurance of 2 is: 1

    boolean remove(Object o)

    此方法删除此Vector中指定元素的第一个匹配项如果Vector不包含该元素,则该方法保持不变。

    语法: public boolean remove(Object o)
     返回:返回元素的第一个匹配项。
    异常: NA。
    
    // Java code illustrating remove method()
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
           // removing first occurance element at 1
           v.remove(1);
           
           // checking vector 
           System.out.println("after removal: " + v);
           
        }
    }
    

    输出:

    after removal: [1, Geeks, forGeeks, 4]

    boolean equals(Object o)

    此方法将指定的Object与此Vector进行比较以获得相等性。

    语法: public boolean equal(Object o)
     返回:如果操作成功则返回 true,否则返回 false。
    异常: NA。
    
    // Java code illustrating equals() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
           // second vector
           Vector v_2nd = new Vector();
           
            v_2nd.add(1);
            v_2nd.add(2);
            v_2nd.add("Geeks");
            v_2nd.add("forGeeks");
            v_2nd.add(4);
           
         if(v.equals(v_2nd))
             System.out.println("both vectors are equal");
        }
    }
    

    输出:

    both vectors are equal
    

    Object firstElemen()

    此方法返回此向量的第一个组件(索引为0的项)。

    语法: public Object firstElement()
     返回: NA。
    异常: NoSuchElementException  - 返回此异常
    如果此向量没有组件。
    
    // Java code illustrating firstElement() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
           
            // first element of vector
            System.out.println("first element of vector is: " + v.firstElement());
        }
    }
    

    输出:

    first element of vector is: 1

    void trimToSize() 

    此方法将此向量的容量修剪为向量的当前大小。

    语法: public void trimToSize()
     返回: NA。
    异常: NA。
    
    // Java code illustrating trimToSize() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
           
           // checking initial capacity
           System.out.println("Initial capacity: " + v.capacity());
           
           // trim capacity to size
           v.trimToSize();
           
           // checking capacity after triming
          System.out.println("capacity after triming: " + v.capacity());
        }
    }
    

    输出:

    Initial capacity: 10
    capacity after triming: 5

    String toString() 

    toString()方法用于返回此Vector的字符串表示形式,包含每个元素的String表示形式。

    语法: public String toString()
     返回:   此集合的字符串表示形式。
    异常: NA
    
    // Java code illustrating toString() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
            // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
           
         
           // string equivalent of vector
           System.out.println(" String equivalent of vector: " + v.toString());
        }
    }
    

    输出:

    String equivalent of vector: [1, 2, Geeks, forGeeks, 4]

    object [] toArray()

    此方法返回此Vector的数组表示形式,包含每个元素的String表示形式。

    语法: public object [] toArray()
     返回:包含此集合中所有元素的数组。
    例外: NA。
    
    // Java code illustrating toArray() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
           
             String elements[] = { "M", "N", "O", "P", "Q" };
             Set set = new HashSet(Arrays.asList(elements));
    
             String[] strObj = new String[set.size()];
    
             strObj = (String[]) set.toArray(strObj);
    
             for (int i = 0; i < strObj.length; i++) 
            {
             System.out.println(strObj[i]);
            }
             System.out.println(set);
        }    
    }
    

    输出:

    P
    Q
    M
    N
    O
    [P, Q, M, N, O]

    int size()

    此方法返回此向量中的组件数。

    语法: public int size()
     返回:返回此向量中的组件数。
    异常: NA
    
    // Java code illustrating size() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
         // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
            // size of vector
            System.out.println(" size of vector: " + v.size());
       }    
    }
    

    输出:

    size of vector: 5
    

    void setSize(int newSize)

    此方法设置大小。

    语法: public void setSize(int newSize)
     返回: NA。
    异常: ArrayIndexOutOfBoundsException  - 抛出此异常
    如果新的大小是负面的。
    
    // Java code illustrating setSize() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
         // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
            // setting new size of vector
            v.setSize(13);
            
            // size of vector
            System.out.println("size of vector: " + v.size());
       }    
    }
    

    输出:

    size of vector: 13
    

    void setElementAt(Object obj,int index)

    此方法将此向量的指定索引处的组件设置为指定对象。

    语法: public void setElementAt(E obj,int index)
     返回: NA。
    异常: ArrayIndexOutOfBoundsException  - 抛出此异常
    如果访问的索引超出范围。
    
    // Java code illustrating setElementAt() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
         // create default vector of capacity 10
            Vector v = new Vector();
           
            v.add(1);
            v.add(2);
            v.add("Geeks");
            v.add("forGeeks");
            v.add(4);
            
           // set 4 at the place of 2
           v.setElementAt(4, 1);
           
           System.out.println("vector: " + v);
       }    
    }
    

    输出:

    vector: [1, 4, Geeks, forGeeks, 4]

    retainAll(Collection c)

    此方法仅保留此Vector中包含在指定Collection中的元素。

    语法: public boolean retainAll(Collection c)
     返回:如果由于调用而更改此Vector,则返回 true。
    异常: NullPointerException  - 如果是,则抛出此异常
    指定的集合为null。
    
    // Java code illustrating retainAll() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
            Vector vec = new Vector(7);
            Vector vecretain = new Vector(4);
    
            // use add() method to add elements in the vector
            vec.add(1);
            vec.add(2);
            vec.add(3);
            vec.add(4);
            vec.add(5);
            vec.add(6);
            vec.add(7);
          
            // this elements will be retained
            vecretain.add(5);
            vecretain.add(3);
            vecretain.add(2);
    
            System.out.println("Calling retainAll()");
            vec.retainAll(vecretain);
          
            // let us print all the elements available in vector
            System.out.println("Numbers after removal :- "); 
       
            Iterator itr = vec.iterator();
       
            while(itr.hasNext())
            {
             System.out.println(itr.next());
                   
            }
       }     
    }
    

    输出:

    Calling retainAll()
    Numbers after removal :- 
    2
    3
    5

    void removeAllElements()

    此方法从此向量中删除所有组件并将其大小设置为零。

    语法: public void removeAllElements()
     返回: NA。
    异常: NA。
    
    // Java code illustrating removeAllElements() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
             Vector vec = new Vector(7);
       
    
            // use add() method to add elements in the vector
            vec.add(1);
            vec.add(2);
            vec.add(3);
            vec.add(4);
            vec.add(5);
            vec.add(6);
            vec.add(7);
    
            // remove all elements
            vec.removeAllElements();
       
            //checking vector's size
            System.out.println("Size: " + vec.size());
       
            //checking vector's componenets
            System.out.println("vector's componenets: " + vec);
        }    
    }
    

    输出:

    Size: 0
    vector's componenets: []

    Object lastElement()

    此方法返回向量的最后一个组件。

    语法: public Object lastElement()
     返回:返回向量的最后一个组件,
    即索引大小为() -  1的组件。
    异常: NoSuchElementException  - 抛出此异常
    如果此向量为空
    
    // Java code illustrating lastElement() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
            Vector vec = new Vector(7);
       
    
            // use add() method to add elements in the vector
            vec.add(1);
            vec.add(2);
            vec.add(3);
            vec.add(4);
            vec.add(5);
            vec.add(6);
            vec.add(7);
       
            // checking last element of vector
            System.out.println("vector's last componenets: " + vec.lastElement());
        }    
    }
    

    输出:

    vector's last componenets: 7

    int hashCode()

    此方法返回此Vector的哈希码值。

    语法: public int hashCode()
     返回:返回此列表的哈希码值(int)。
    异常: NA。
    
    // Java code illustrating hashCode() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
            Vector vec = new Vector(7);
       
    
            // use add() method to add elements in the vector
            vec.add(1);
            vec.add(2);
            vec.add(3);
            vec.add(4);
            vec.add(5);
            vec.add(6);
            vec.add(7);
       
            // checking hash code
            System.out.println("Hash code: " + vec.hashCode());
        }    
    }
    

    输出:

    Hash code:-1604500253
    

    boolean removeElement(Object obj)

    此方法从此向量中删除第一次出现的参数。

    语法: public boolean removeElement(Object obj)
     返回:如果操作成功则返回 true,否则返回 false。
    异常:
    
    // Java code illustrating removeElement()
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
            Vector vec = new Vector(7);
       
    
            // use add() method to add elements in the vector
            vec.add(1);
            vec.add(2);
            vec.add(3);
            vec.add(4);
            vec.add(5);
            vec.add(6);
            vec.add(7);
       
            // remove an element
            vec.removeElement(5);
       
            // checking vector
            System.out.println("Vector after removal: " + vec);
        }    
    }
    

    输出:

    Vector after removal:[1,2,3,4,6,7]
    

    void copyInto(Object [] anArray)

    此方法将此向量的组件复制到指定的数组中。

    语法: public void copyInto(Object [] anArray)
     返回: NA。
    异常: NullPointerException  - 如果给定的数组为null。
    
    // Java code illustrating copyInto() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
            Vector vec = new Vector(7);
       
    
            // use add() method to add elements in the vector
            vec.add(1);
            vec.add(2);
            vec.add(3);
            vec.add(4);
            vec.add(5);
            vec.add(6);
            vec.add(7);
       
            Integer[] arr=new Integer[7];
       
            // copy componnent of vector int array arr
            vec.copyInto(arr);
      
            System.out.println("elements in array arr: ");
            for(Integer num : arr)
            {
              System.out.println(num);
            }
        }    
    }
    

    输出:

    elements in array arr: 
    1
    2
    3
    4
    5
    6
    7

    int capacity()

    此方法返回此向量的当前容量。

    语法: public int capacity()
     返回:返回当前容量
    矢量作为整数值。这里的容量意味着长度
    其内部数据数组,保存在此向量的字段elementData中。
     异常 NA。
    
    // Java code illustrating capacity() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
            Vector vec = new Vector(7);
       
    
            // use add() method to add elements in the vector
            vec.add(1);
            vec.add(2);
            vec.add(3);
            vec.add(4);
            vec.add(5);
            vec.add(6);
            vec.add(7);
      
            // checking capacity
            System.out.println("Capacity of vector: " + vec.capacity());
        }    
    }
    

    输出:

    Capacity of vector: 7
    

    void insertElementAt(Object obj,int index)

    此方法将指定的对象作为此向量中的组件插入指定的索引处。

    语法: public void insertElementAt(E obj,int index)
     返回: NA。
    异常: ArrayIndexOutOfBoundsException  - 抛出此异常
     如果索引无效。
    
    // Java code illustrating insertElementAt() method
    import java.util.*;
    class Vector_demo    
    {
        public static void main(String[] arg)
        {
            Vector vec = new Vector(7);
       
    
            // use add() method to add elements in the vector
            vec.add(1);
            vec.add(2);
            vec.add(3);
            vec.add(4);
            vec.add(5);
            vec.add(6);
            vec.add(7);
      
             // insert 10 at the index 7
            vec.insertElementAt(10, 7);
       
            // checking vector
            System.out.println(" Vector: " + vec);
        }    
    }
    

    输出:

     Vector: [1, 2, 3, 4, 5, 6, 7, 10]

     
    转载请保留页面地址:https://www.breakyizhan.com/java/5317.html