Résumé des exemples d'utilisation de classes vectorielles en Java

L'implémentation de Vector est fondamentalement similaire à ArrayList. Ils sont tous deux basés sur des tableaux dynamiques et doivent également être développés. Voici trois courts exemples pour vous aider à comprendre le vecteur :

Exemples d'opérations de base

.

VectorApp.java

import java.util.Vector; 
import java.lang.*; 
import java.util.Enumeration; 
public class VectorApp 
{ 
  public static void main(String args[]) 
  { 
   Vector v1 = new Vector(); 
   Integer integer1= new Integer(1); 
   //加入为字符串对象 
   v1.addElement("one"); 
   //加入的为integer的对象 
   v1.addElement(integer1); 
   v1.addElement(integer1); 
   v1.addElement("two"); 
   v1.addElement(new Integer(2)); 
   v1.addElement(integer1); 
   v1.addElement(integer1); 
   //转为字符串并打印 
   System.out.println("The Vector v1 is:\n\t"+v1); 
   //向指定位置插入新对象 
   v1.insertElement("three",2); 
   v1.insertElement(new Float(3.9),3); 
   System.out.println("The Vector v1(used method 
   insertElementAt()is:\n\t)"+v1); 
   //将指定位置的对象设置为新的对象 
   //指定位置后的对象依次往后顺延 
   v1.setElementAt("four",2); 
   System.out.println("The vector v1 cused method setElmentAt()is:\n\t"+v1); 
   v1.removeElement(integer1); 
   //从向量对象v1中删除对象integer1 
   //由于存在多个integer1,所以从头开始。 
    //找删除找到的第一个integer1. 
   Enumeration enum = v1.elements(); 
   System.out.println("The vector v1 (used method removeElememt()is"); 
   while(enum.hasMoreElements()) 
   System.out.println(enum.nextElement()+""); 
   System.out.println(); 
   //使用枚举类(Enumeration)的方法取得向量对象的每个元素。 
    System.out.println("The position of Object1(top-to-botton):"+v1.indexOf(integer1)); 
   System.out.println("The position of Object1(tottom-to-top):"+v1.lastIndexOf(integer1)); 
   //按不同的方向查找对象integer1所处的位置 
    v1.setSize(4); 
   System.out.println("The new Vector(resized the vector)is:"+v1); 
   //重新设置v1的大小，多余的元素被抛弃  
  } 
}

Résultats d'exploitation :

E:\java01>java VectorApp 
The vector v1 is:[one,1,1,two,2,1,1] 
The vector v1(used method insetElementAt()) is: 
[one,1,three,3.9,1,two,2,1,1] 
The vector v1(used method setElementAt()) is: 
[one,1,four,3.9,1,two,2,1,1] 
The vector v1(useed method removeElement()) is: 
one four 3.9 1 two 2 1 1 
The position of object1(top-to-botton):3 
The position of object1(botton-to-top):7 
The new Vector(resized the vector) is: 
[one,four,3.9,1]

1x extension de Vertor
Vous souvenez-vous qu'ArrayList est étendu à 0,5 fois la taille du méta-tableau chacun temps? Vector est légèrement différent d'ArrayList lors de l'exécution d'opérations d'expansion

protected int capacityIncrement;//用于指定每次扩容的容量
 
private void grow(int minCapacity) {
 // overflow-conscious code
 int oldCapacity = elementData.length;
 int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
          capacityIncrement : oldCapacity);//如不指定capacityIncrement，默认扩容的容量为原数组的容量
 if (newCapacity - minCapacity < 0)
  newCapacity = minCapacity;
 if (newCapacity - MAX_ARRAY_SIZE > 0)
  newCapacity = hugeCapacity(minCapacity);
 elementData = Arrays.copyOf(elementData, newCapacity);
}

Les amis prudents peuvent constater qu'il existe une variable capacitéIncrement supplémentaire dans Vector, qui est utilisée pour spécifier l'incrément de chaque extension si vous ne le spécifiez pas. Variables, vous pouvez constater dans Grow que Vector est étendu à 1 fois le tableau d'origine par défaut

Thread-safe
Vertor est thread-safe !
Une autre chose remarquable dans le code source de Vertor est que la plupart des méthodes ont le mot-clé synchronisé. Tout le monde sait que ce mot-clé est utilisé pour la synchronisation des threads, donc la classe Vector est thread-safe !
Mais même si toutes ses méthodes sont modifiées pour être synchronisées, cela ne signifie pas que la synchronisation ne sera jamais nécessaire lors de son appel :

private static Vector<Integer> vector=new Vector<Integer>();
public static void main(String[] args) { 
 while(true)
 {
 for(int i=0;i<10;i++)
 {
 vector.add(i);
 }
  
 Thread removeThread=new Thread(new Runnable(){
 @Override
 public void run()
 {
 for(int i=0;i<vector.size();i++)
 {
  vector.remove(i);
 }
 }
 });
  
 Thread printThread=new Thread(new Runnable(){
 @Override
 public void run()
 {
 for(int i=0;i<vector.size();i++)
 {
  System.out.println(vector.get(i));
 }
 }
 });
  
 removeThread.start();
 printThread.start();
  
 while(Thread.activeCount()>20);
  
 }
}

Tout le monde a couru un court laps de temps lors de l'exécution de ce code. Après un certain temps, vous trouverez une exception ArrayIndexOutOfBoundsException. Bien que les méthodes get, delete et size de Vector soient synchronisées, dans un environnement multithread, si aucune mesure de synchronisation supplémentaire n'est prise du côté de la méthode, ce code est toujours dangereux. Si a Après que le thread ait supprimé l'élément avec le numéro de série i, si un autre thread accède à ce i, une exception sera levée directement. Par conséquent, pour garantir la sécurité de ce code, vous devez ajouter une modification synchronisée

dans. Ce qui précède est le résumé des exemples d'utilisation de classes en Java. Veuillez faire attention au site Web chinois de PHP (www.php.cn) pour plus de contenu connexe !