La classe Vector implementa una matriu d'objectes augmentable. Els vectors cauen en classes heretades, però ara és totalment compatible amb les col·leccions. Es troba a paquet java.util i implementar el Llista interfície, de manera que podem utilitzar tots els mètodes de la interfície Llista tal com es mostra a continuació de la següent manera:

• Vector implementa una matriu dinàmica que significa que pot créixer o reduir-se segons sigui necessari. Com una matriu, conté components als quals es pot accedir mitjançant un índex sencer.
• Són molt semblants a ArrayList , però Vector està sincronitzat i té alguns mètodes heretats que el marc de col·lecció no conté.
• També manté un ordre d'inserció com un ArrayList. Tot i així, poques vegades s'utilitza en un entorn sense fils tal com és sincronitzat , i a causa d'això, dóna un rendiment pobre en afegir, cercar, suprimir i actualitzar els seus elements.
• Els iteradors retornats per la classe Vector són ràpids de fallar. En el cas de modificació simultània, falla i llança el ConcurrentModificationException.

Sintaxi:

public class Vector extends AbstractList implements List, RandomAccess, Cloneable, Serializable>

Aquí, I és el tipus d'element.

• S'estén Llista abstracta i implements Llista interfícies.
• Implementa interfícies Serialitzables, Clonables, Iterables, Col·lecció, Llista i RandomAccess.
• La subclasse coneguda directament és Pila .

Els punts importants pel que fa a l'increment de la capacitat vectorial són els següents:

Si s'especifica l'increment, Vector s'ampliarà segons ell en cada cicle d'assignació. Tot i així, si no s'especifica l'increment, la capacitat del vector es duplica en cada cicle d'assignació. Vector defineix tres membres de dades protegits:

• int capacitatIncrement: Conté el valor d'increment.
• int elementCount: Nombre d'elements que hi ha actualment al vector emmagatzemats.
• Object elementData[]: S'hi emmagatzema una matriu que conté el vector.

Els errors comuns en la declaració de Vectors són as segueix :

• Vector llança un IllegalArgumentException si la InitialSize del vector definit és negativa.
• Si la col·lecció especificada és nul·la, es llança NullPointerException .

Constructors

1. Vector(): Crea un vector per defecte de la capacitat inicial és 10.

Vector v = new Vector();>

2. Vector (mida int): Crea un vector la capacitat inicial del qual s'especifica per la mida.

Vector v = new Vector(int size);>

3. Vector (mida int, int incr): Crea un vector la capacitat inicial del qual s'especifica per mida i l'increment s'especifica per incr. Especifica el nombre d'elements a assignar cada vegada que un vector es redimensiona cap amunt.

l'actor ranbir kapoor edat

Vector v = new Vector(int size, int incr);>

4. Vector (Col·lecció c): Crea un vector que conté els elements de la col·lecció c.

Vector v = new Vector(Collection c);>

Mètodes en classe vectorial

Primer parlem i implementem com crear i utilitzar un vector abans d'aterrar als mètodes d'aquesta classe.

Exemple:

// Java Program to Demonstrate Working of Vector // Via Creating and Using It // Importing required classes import java.io.*; import java.util.*; // Main class class GFG { // Main driver method public static void main(String[] args) { // Size of the Vector int n = 5; // Declaring the Vector with // initial size n Vector v = vector nou (n); // Afegeix nous elements al // final del vector per a (int i = 1; i<= n; i++) v.add(i); // Printing elements System.out.println(v); // Remove element at index 3 v.remove(3); // Displaying the vector // after deletion System.out.println(v); // iterating over vector elements // using for loop for (int i = 0; i < v.size(); i++) // Printing elements one by one System.out.print(v.get(i) + ' '); } }>

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

Nota:

• Si no s'especifica l'increment del vector, la seva capacitat es duplicarà en cada cicle d'increment.
• La capacitat d'un vector no pot estar per sota de la mida, pot ser igual a ella.

Realització de diverses operacions sobre la classe Vector a Java

Parlem de diverses operacions a la classe Vector que s'enumeren de la següent manera:

flotar a la corda

1. Afegint elements
2. Elements d'actualització
3. Eliminació d'elements
4. Iteració sobre elements

Operació 1: Afegir Elements

Per afegir els elements al Vector, fem servir el afegir() mètode. Aquest mètode està sobrecarregat per realitzar múltiples operacions basades en diferents paràmetres. S'enumeren a continuació de la següent manera:

• afegir (Objecte): Aquest mètode s'utilitza per afegir un element al final del vector.
• afegir (índex int, objecte): Aquest mètode s'utilitza per afegir un element a un índex específic del Vector.

Exemple:

// Java Program to Add Elements in Vector Class // Importing required classes import java.io.*; import java.util.*; // Main class // AddElementsToVector class GFG { // Main driver method public static void main(String[] arg) { // Case 1 // Creating a default vector Vector v1 = new Vector(); // Adding custom elements // using add() method v1.add(1); v1.add(2); v1.add('geeks'); v1.add('forGeeks'); v1.add(3); // Printing the vector elements to the console System.out.println('Vector v1 is ' + v1); // Case 2 // Creating generic vector Vector v2 = vector nou (); // Afegint elements personalitzats // utilitzant el mètode add() v2.add(1); v2.add(2); v2.add(3); // Imprimint els elements vectorials a la consola System.out.println('Vector v2 és ' + v2); } }>>> 
     Sortida:    
 
 
 
  
 
 
Vector v1 is [1, 2, geeks, forGeeks, 3] Vector v2 is [1, 2, 3]>
 
    Operació 2:         Actualització d'elements    
 
Després d'afegir els elements, si volem canviar l'element, es pot fer amb el conjunt() mètode. Com que un vector està indexat, l'element que volem canviar es fa referència a l'índex de l'element. Per tant, aquest mètode pren un índex i l'element actualitzat que s'insereix en aquest índex.
 
    Exemple    
Java 
// Java code to change the // elements in vector class import java.util.*; // Driver Class public class UpdatingVector { // Main Function public static void main(String args[]) { // Creating an empty Vector Vector vector_tor = vector nou (); // Utilitzeu el mètode add() per afegir elements al vector vec_tor.add(12); vector_tor.add(23); vector_tor.add(22); vector_tor.add(10); vector_tor.add(20); // Mostra el Vector System.out.println('Vector: ' + vec_tor); // Utilitzant el mètode set() per substituir 12 per 21 System.out.println('L'objecte que es substitueix és: ' + vec_tor.set(0, 21)); // Utilitzant el mètode set() per substituir 20 per 50 System.out.println('L'objecte que es substitueix és: ' + vec_tor.set(4, 50)); // Mostra el vector modificat System.out.println('El nou Vector és:' + vec_tor); } }>>>  
  Sortida      Operació 3:         Eliminació d'elements    
 
Per eliminar un element d'un Vector, podem utilitzar el eliminar () mètode. Aquest mètode està sobrecarregat per realitzar múltiples operacions basades en diferents paràmetres. Ells són:
 
    eliminar (Objecte):    Aquest mètode s'utilitza per eliminar un objecte del Vector. Si hi ha diversos objectes d'aquest tipus, s'elimina la primera ocurrència de l'objecte.
    eliminar (índex int):    Com que un vector està indexat, aquest mètode pren un valor enter que simplement elimina l'element present en aquest índex específic del vector. Després d'eliminar l'element, tots els elements es mouen cap a l'esquerra per omplir l'espai i s'actualitzen els índexs dels objectes.
    Exemple    
Java 
// Java code illustrating the removal // of elements from vector import java.util.*; import java.io.*; class RemovingElementsFromVector { public static void main(String[] arg) { // Create default vector of capacity 10 Vector v = new Vector(); // Add elements using add() method v.add(1); v.add(2); v.add('Geeks'); v.add('forGeeks'); v.add(4); // Removing first occurrence element at 1 v.remove(1); // Checking vector System.out.println('after removal: ' + v); } }>
  
     Sortida:    
     Operació 4: Iteració del vector    
esborra el fitxer en java
 
Hi ha diverses maneres d'iterar a través del Vector. Les maneres més famoses són utilitzant el bucle for bàsic en combinació amb a aconseguir() mètode per obtenir l'element en un índex específic i el  avançat per un bucle  .
 
    Exemple    
Java 
// Java program to iterate the elements // in a Vector import java.util.*; public class IteratingVector { public static void main(String args[]) { // create an instance of vector Vectorv = vector nou (); // Afegeix elements mitjançant el mètode add() v.add('Geeks'); v.add('Geeks'); v.add(1, 'Per'); // Utilitzant el mètode Get i el // bucle for for (int i = 0; i< v.size(); i++) { System.out.print(v.get(i) + ' '); } System.out.println(); // Using the for each loop for (String str : v) System.out.print(str + ' '); } }>
   
  Sortida  
Geeks For Geeks Geeks For Geeks>
  
    Nota:    Doneu una lectura al Classe ArrayList vs Vector a Java per entendre-ho millor.
 
A Java, la classe Vector forma part del Java Collections Framework i proporciona una implementació de matriu dinàmica de la interfície List. Es va afegir a la versió original de Java (Java 1.0) i proporciona una sèrie de mètodes per manipular els elements d'un vector, com ara afegir, inserir i eliminar elements.
 
Aquí teniu un exemple senzill que demostra com utilitzar un vector a Java:
Java 
import java.util.Vector; public class VectorExample { public static void main(String[] args) { // Create a new vector Vector v = vector nou (3, 2); // Afegeix elements al vector v.addElement(1); v.addElement(2); v.addElement(3); // Insereix un element a l'índex 1 v.insertElementAt(0, 1); // Elimina l'element a l'índex 2 v.removeElementAt(2); // Imprimeix els elements del vector per a (int i : v) { System.out.println(i); } } }>>
   
  Sortida  
1 0 3>
 
Tingueu en compte que la classe Vector està sincronitzada, el que significa que diversos fils poden accedir al mateix vector sense causar problemes. Tanmateix, aquesta sincronització té un cost de rendiment, de manera que si no necessiteu compartir un vector entre diversos fils, generalment és millor utilitzar una classe alternativa com ArrayList que no estigui sincronitzada.
 
Avantatges d'utilitzar Vector a Java:
Sincronització: Com s'ha esmentat abans, Vector està sincronitzat, de manera que és segur utilitzar-lo en un entorn multiprocés.
Mida dinàmica: la mida d'un vector pot créixer o reduir-se dinàmicament a mesura que s'afegeixen o s'eliminen elements, de manera que no us haureu de preocupar per establir una mida inicial que s'adapti a tots els elements.
Suport heretat: Vector ha format part de Java des dels seus inicis i encara és compatible, per la qual cosa és una bona opció si necessiteu treballar amb codi Java més antic que utilitzi Vector.
Desavantatges d'utilitzar Vector a Java:
Rendiment: la sincronització a Vector pot provocar un rendiment més lent en comparació amb altres classes de col·lecció, com ara ArrayList.
Codi heretat: tot i que Vector encara és compatible, el codi Java més recent s'escriu sovint utilitzant les classes de col·lecció més modernes, de manera que pot ser més difícil trobar exemples i suport per a Vector.
Descàrrega innecessària: si no necessiteu les funcions de sincronització de Vector, utilitzar-la afegirà sobrecàrrega innecessària al vostre codi.
Llibre de referència
Un bon llibre de referència per aprendre sobre el Java Collections Framework i Vector és Java Collections de Naftalin i Wadler. Aquest llibre ofereix una visió completa del marc de col·leccions de Java, inclòs Vector, i inclou molts exemples i exercicis per ajudar-vos a entendre com utilitzar aquestes classes de manera eficaç.