La classe Vector implémente un tableau d'objets extensible. Les vecteurs appartiennent aux classes héritées, mais ils sont désormais entièrement compatibles avec les collections. On le trouve dans paquet java.util et mettre en œuvre le Liste interface, nous pouvons donc utiliser toutes les méthodes de l'interface List comme indiqué ci-dessous comme suit :

• Vector implémente un tableau dynamique, ce qui signifie qu'il peut s'agrandir ou se réduire selon les besoins. Comme un tableau, il contient des composants accessibles à l’aide d’un index entier.
• Ils ressemblent beaucoup à Liste des tableaux , mais Vector est synchronisé et possède des méthodes héritées que le framework de collection ne contient pas.
• Il maintient également un ordre d'insertion comme un ArrayList. Pourtant, il est rarement utilisé dans un environnement sans thread tel qu'il est synchronisé , et de ce fait, il donne de mauvaises performances lors de l'ajout, de la recherche, de la suppression et de la mise à jour de ses éléments.
• Les itérateurs renvoyés par la classe Vector sont rapides. Dans le cas d'une modification simultanée, il échoue et renvoie le ConcurrentModificationException.

Syntaxe:

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

Ici, ET est le type d'élément.

• Il s'étend Liste abstraite et met en œuvre Liste interfaces.
• Il implémente les interfaces Serialisable, Cloneable, Iterable, Collection, List, RandomAccess.
• La sous-classe directement connue est Empiler .

Les points importants concernant l'incrément de capacité vectorielle sont les suivants :

Si l'incrément est spécifié, Vector se développera en fonction de celui-ci à chaque cycle d'allocation. Néanmoins, si l’incrément n’est pas spécifié, la capacité du vecteur est alors doublée à chaque cycle d’allocation. Vector définit trois données membres protégées :

• int capacitéIncrément : Contient la valeur de l'incrément.
• int elementCount : Nombre d'éléments actuellement stockés dans le vecteur.
• Objet elementData[] : Le tableau contenant le vecteur y est stocké.

Les erreurs courantes dans la déclaration des vecteurs sont les suivantes suit :

• Le vecteur lance un Exception d'argument illégal si la TailleInitiale du vecteur défini est négative.
• Si la collection spécifiée est nulle, elle lance NullPointerException .

Constructeurs

1. Vecteur() : Crée un vecteur par défaut de la capacité initiale est 10.

Vector v = new Vector();>

2. Vecteur (taille entière) : Crée un vecteur dont la capacité initiale est spécifiée par taille.

Vector v = new Vector(int size);>

3. Vecteur (taille int, int incr) : Crée un vecteur dont la capacité initiale est spécifiée par taille et l'incrément est spécifié par incr. Il spécifie le nombre d'éléments à allouer à chaque fois qu'un vecteur est redimensionné vers le haut.

dactylographié pour chacun

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

4. Vecteur (Collection c) : Crée un vecteur qui contient les éléments de la collection c.

Vector v = new Vector(Collection c);>

Méthodes en classe vectorielle

Voyons d'abord et implémentons comment créer et utiliser un vecteur avant d'aborder les méthodes de cette 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 = nouveau vecteur (n); // Ajout de nouveaux éléments à // la fin du vecteur pour (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>

Note:

• Si l’incrément vectoriel n’est pas spécifié, sa capacité sera doublée à chaque cycle d’incrément.
• La capacité d'un vecteur ne peut pas être inférieure à la taille, elle peut lui être égale.

Effectuer diverses opérations sur la classe Vector en Java

Discutons de diverses opérations sur la classe Vector répertoriées comme suit :

1. Ajout d'éléments
2. Mise à jour des éléments
3. Suppression d'éléments
4. Itérer sur les éléments

Opération 1 : Ajout d'éléments

Afin d'ajouter les éléments au vecteur, nous utilisons le ajouter() méthode. Cette méthode est surchargée pour effectuer plusieurs opérations basées sur différents paramètres. Ils sont répertoriés ci-dessous comme suit :

• ajouter (Objet): Cette méthode est utilisée pour ajouter un élément à la fin du vecteur.
• ajouter (index int, objet): Cette méthode est utilisée pour ajouter un élément à un index spécifique dans le vecteur.

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 = nouveau vecteur (); // Ajout d'éléments personnalisés // en utilisant la méthode add() v2.add(1); v2.add(2); v2.add(3); // Impression des éléments vectoriels sur la console System.out.println('Vector v2 is ' + v2); } }>

Sortir:

octets dans la chaîne python

Vector v1 is [1, 2, geeks, forGeeks, 3] Vector v2 is [1, 2, 3]>

Opération 2 : Mise à jour des éléments

Après avoir ajouté les éléments, si l'on souhaite changer l'élément, cela peut être fait en utilisant le ensemble() méthode. Puisqu'un Vecteur est indexé, l'élément que l'on souhaite modifier est référencé par l'index de l'élément. Par conséquent, cette méthode prend un index et l’élément mis à jour à insérer à cet index.

Exemple

// 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 vec_tor = nouveau vecteur (); // Utilisez la méthode add() pour ajouter des éléments dans le vecteur vec_tor.add(12); vec_tor.add(23); vec_tor.add(22); vec_tor.add(10); vec_tor.add(20); // Affichage du vecteur System.out.println('Vector: ' + vec_tor); // Utilisation de la méthode set() pour remplacer 12 par 21 System.out.println('L'objet remplacé est : ' + vec_tor.set(0, 21)); // Utilisation de la méthode set() pour remplacer 20 par 50 System.out.println('L'objet remplacé est : ' + vec_tor.set(4, 50)); // Affichage du vecteur modifié System.out.println('Le nouveau Vecteur est :' + vec_tor); } }>

Vector: [12, 23, 22, 10, 20] The Object that is replaced is: 12 The Object that is replaced is: 20 The new Vector is:[21, 23, 22, 10, 50]>

Opération 3 : Suppression d'éléments

Afin de supprimer un élément d'un vecteur, nous pouvons utiliser le retirer() méthode. Cette méthode est surchargée pour effectuer plusieurs opérations basées sur différents paramètres. Ils sont:

• supprimer (Objet): Cette méthode est utilisée pour supprimer un objet du vecteur. S'il existe plusieurs objets de ce type, la première occurrence de l'objet est supprimée.
• supprimer (index int): Puisqu'un vecteur est indexé, cette méthode prend une valeur entière qui supprime simplement l'élément présent à cet index spécifique dans le vecteur. Après avoir supprimé l'élément, tous les éléments sont déplacés vers la gauche pour remplir l'espace et les index des objets sont mis à jour.

Exemple

// 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); } }>

Sortir:

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

Opération 4 : Itérer le vecteur

Il existe plusieurs façons de parcourir le vecteur. Les méthodes les plus connues consistent à utiliser la boucle for de base en combinaison avec un obtenir() méthode pour obtenir l'élément à un index spécifique et le avancé pour une boucle .

Exemple

planification du tournoi à la ronde

// 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 = nouveau vecteur (); // Ajoutez des éléments en utilisant la méthode add() v.add('Geeks'); v.add('Geeks'); v.add(1, 'Pour'); // Utilisation de la méthode Get et de la boucle // 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 + ' '); } }>

Geeks For Geeks Geeks For Geeks>

Note: Donnez une lecture au ArrayList vs classe Vector en Java pour mieux le saisir.

En Java, la classe Vector fait partie du Java Collections Framework et fournit une implémentation de tableau dynamique de l'interface List. Il a été ajouté dans la version originale de Java (Java 1.0) et fournit un certain nombre de méthodes pour manipuler les éléments d'un vecteur, notamment l'ajout, l'insertion et la suppression d'éléments.

Voici un exemple simple qui montre comment utiliser un vecteur en Java :

import java.util.Vector; public class VectorExample { public static void main(String[] args) { // Create a new vector Vector v = nouveau vecteur (3, 2); // Ajoute des éléments au vecteur v.addElement(1); v.addElement(2); v.addElement(3); // Insère un élément à l'index 1 v.insertElementAt(0, 1); // Supprime l'élément à l'index 2 v.removeElementAt(2); // Imprime les éléments du vecteur pour (int i : v) { System.out.println(i); } } }>

1 0 3>

Notez que la classe Vector est synchronisée, ce qui signifie que plusieurs threads peuvent accéder au même vecteur sans poser de problèmes. Cependant, cette synchronisation se fait au détriment des performances, donc si vous n'avez pas besoin de partager un vecteur entre plusieurs threads, il est généralement préférable d'utiliser une classe alternative comme ArrayList qui n'est pas synchronisée.

Avantages de l'utilisation de Vector en Java :

1. Synchronisation : Comme mentionné précédemment, Vector est synchronisé, ce qui rend son utilisation sûre dans un environnement multithread.
2. Taille dynamique : la taille d'un vecteur peut augmenter ou diminuer dynamiquement à mesure que des éléments sont ajoutés ou supprimés, vous n'avez donc pas à vous soucier de définir une taille initiale qui s'adaptera à tous les éléments.
3. Prise en charge héritée : Vector fait partie de Java depuis sa création et est toujours pris en charge, c'est donc une bonne option si vous devez travailler avec du code Java plus ancien qui utilise Vector.

Inconvénients de l’utilisation de Vector en Java :

1. Performances : la synchronisation dans Vector peut entraîner des performances plus lentes par rapport à d'autres classes de collection, telles que ArrayList.
2. Code hérité : bien que Vector soit toujours pris en charge, le code Java plus récent est souvent écrit à l'aide des classes de collection les plus modernes. Il peut donc être plus difficile de trouver des exemples et une prise en charge pour Vector.
3. Surcharge inutile : si vous n'avez pas besoin des fonctionnalités de synchronisation de Vector, son utilisation ajoutera une surcharge inutile à votre code.

Livre de référence

Un bon ouvrage de référence pour en savoir plus sur Java Collections Framework et Vector est Java Collections de Naftalin et Wadler. Ce livre fournit un aperçu complet du framework de collections Java, y compris Vector, et comprend de nombreux exemples et exercices pour vous aider à comprendre comment utiliser efficacement ces classes.