Qu'est-ce qu'un vecteur en java?

Un vecteur en java, c'est comme un tableau. Cependant, contrairement à un tableau, il peut rétrécir ou augmenter la longueur. Les éléments peuvent être ajoutés ou insérés sur le vecteur, ce qui augmente sa longueur. Les éléments peuvent également être retirés, ce qui réduit (rétrécit) la longueur du vecteur.

En Java, il y a la classe et il y a des objets de la classe. Les objets correspondants d'une classe sont instanciés de la classe. Le vecteur est une classe à partir de laquelle les objets vectoriels sont instanciés. La classe vectorielle se trouve dans le java.user.* package, qui doit être importé. Cet article explique ce qu'est un vecteur et ses méthodes couramment utilisées.

Contenu de l'article

• Construction d'un vecteur
• Ajout d'éléments à un vecteur
• Appuyer sur un vecteur
• La longueur d'un vecteur
• Accéder à un élément
• Insérer des éléments
• Élimination des éléments
• Conclusion

Construction d'un vecteur

Un vecteur peut être construit comme un vecteur vide ou avec des éléments. Un vecteur est une collection. Cela signifie qu'un vecteur peut être composé de tous les entiers, ou tous les caractères, ou tous les doubles, ou toutes les chaînes, etc. À la construction, le type est indiqué dans les supports d'angle. Les supports d'angle prennent une référence, et non un type primitif. Donc, ça devrait être et non; et pas ; et pas ; etc. Avec des classes de référence, il n'y a pas de problème. Par exemple, la chaîne est juste et il n'y a pas d'autre alternative. Tous les éléments du vecteur sont du même type.

Construire un vecteur vide

La façon de construire un vecteur vide de caractères est:

Vecteur vtr = nouveau vecteur();

où vtr est le nom du vecteur, donné par le programmeur. Notez les positions des deux supports d'angle. Notez la présence des parenthèses vides, à la fin de la déclaration. Vector est une classe en Java, il doit donc commencer par un personnage majuscule. Le programme suivant a la création d'un vecteur:

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
Vecteur vtr = nouveau vecteur();

Construire un vecteur avec des éléments

Un vecteur non vide peut être construit. La façon de le faire est similaire à ce qui précède. C'est:

Vecteur vtr = nouveau vecteur(Al);

Étaient al ici, est une arraylist, une autre collection. Le contenu des parenthèses doit être le nom d'une collection. Dans ce cas, l'arrayList doit avoir été défini comme suit:

Liste des tableaux Al = Nouveau ArrayList();
Al.ajouter un'); Al.ajouter ('b'); Al.ajouter ('e'); Al.ajouter ('f');

Le programme suivant montre comment un vecteur non vide peut être construit avec ce schéma:

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
Liste des tableaux Al = Nouveau ArrayList();
Al.ajouter un'); Al.ajouter ('b'); Al.ajouter ('e'); Al.ajouter ('f');
Vecteur vtr = nouveau vecteur(Al);

Remarque: ArrayList est également dans le Java.user.* emballer.

Ajout d'éléments à un vecteur

Une fois qu'un vecteur a été créé, qu'il soit vide ou non, des éléments peuvent être ajoutés.

Ajout d'éléments un par un

La syntaxe pour ajouter des éléments un par un est:

Public Boolean Add (E E)

Il revient vrai, si un changement a eu lieu, et faux sinon. Le code suivant dans la méthode principale () montre comment les éléments sont ajoutés à un vecteur.

Vecteur vtr = nouveau vecteur();
vtr.ajouter un');
vtr.ajouter ('b');
vtr.ajouter ('e');
vtr.ajouter ('f');

Le vecteur se compose désormais des personnages, «a», «b», «e» et «f».

Ajout d'une liste d'éléments

Plus d'un élément peut être ajouté en même temps, à partir d'un autre vecteur. La syntaxe pour la méthode vectorielle pour cela est:

Addall booléen public (collection c)

Il revient vrai, si un changement a eu lieu.

Le code suivant dans la méthode principale () illustre ceci:

Vecteur vtr = nouveau vecteur();
vtr.ajouter un'); vtr.ajouter ('b'); vtr.ajouter ('e'); vtr.ajouter ('f');
Vecteur C = nouveau vecteur();
c.ajouter ('g'); c.ajouter ('h');
vtr.addall (c);

L'autre vecteur ici est C.

Appuyer sur un vecteur

Les deux façons d'ajouter à un vecteur ci-dessus consultent: ajouter des éléments à la fin.

La longueur d'un vecteur

La longueur d'un vecteur est la taille du vecteur: le nombre d'éléments du vecteur. La classe vectorielle a une méthode pour obtenir la longueur d'un vecteur. La syntaxe complète est:

public int size ()

La taille retournée est un entier. Considérez le code suivant dans la méthode principale ():

Vecteur vtr1 = nouveau vecteur();
Vecteur vtr2 = nouveau vecteur();
vtr2.ajouter un'); vtr2.ajouter ('b'); vtr2.ajouter ('e'); vtr2.ajouter ('f');
int len1 = vtr1.taille();
int len2 = vtr2.taille();
Système.dehors.println ("Len1 est:" + Len1);
Système.dehors.println ("Len2 est:" + Len2);

La sortie est:

Len1 est: 0
Len2 est: 4

Accéder à un élément

Accéder à un élément signifie obtenir (lire) ou définir (modifier) ​​la valeur d'un élément dans le vecteur.

Obtenir un élément

La syntaxe complète pour obtenir un élément est:

public e get (int index)

Une copie de l'élément est retournée. Le comptage d'index commence à partir de 0. Le code suivant obtient tous les éléments du vecteur à l'aide d'une boucle:

Vecteur vtr = nouveau vecteur();
vtr.ajouter un'); vtr.ajouter ('b'); vtr.ajouter ('e'); vtr.ajouter ('f');
pour (int i = 0; ichar ch = vtr.obtenir (i);
Système.dehors.imprimer (ch); Système.dehors.imprimer(", ");

Système.dehors.println ();

La sortie est:

A, b, e, f,

Élément de réglage

La syntaxe complète pour définir (modifier) ​​un élément est:

public e set (int index, e élément)

Il renvoie l'ancien élément à la position d'index. Le code suivant définit (modifie) tous les éléments du vecteur:

Vecteur vtr = nouveau vecteur();
vtr.ajouter un'); vtr.ajouter ('b'); vtr.ajouter ('e'); vtr.ajouter ('f');
vtr.set (0, 'w'); vtr.set (1, 'x'); vtr.set (2, «y»); vtr.set (3, «z»);
pour (int i = 0; iSystème.dehors.imprimer (vtr.obtenir (i)); Système.dehors.imprimer(", ");

Système.dehors.println ();

La sortie est maintenant:

W, x, y, z,

Avec tous les éléments changés.

Insérer des éléments

Les éléments peuvent être insérés dans un vecteur. Cela nécessite deux autres types de méthode Add ().

La méthode Add (int index, e élément)

Cette méthode insère un élément à une position d'index. L'élément qui était à cette position est déplacé un endroit vers la droite. La syntaxe complète de cette méthode est:

public void add (int index, e élément)

Dans le code suivant, un caractère est inséré en position d'index 2:

Vecteur vtr = nouveau vecteur();
vtr.ajouter un'); vtr.ajouter ('b'); vtr.ajouter ('e'); vtr.ajouter ('f');
vtr.Ajouter (2, «D»);
pour (int i = 0; iSystème.dehors.imprimer (vtr.obtenir (i)); Système.dehors.imprimer(", ");

Système.dehors.println ();

La commande d'origine du tableau est:

A, b, e, f

La sortie est:

A, b, d, e, f,

'D' a été inséré à l'index 2.

Addall (INT INDEX, Collection c)

Cela peut insérer une liste en position d'index, poussant le reste des éléments, qui étaient à droite de cette position (y compris l'élément en position), plus à droite, par le nombre de caractères dans la liste insérée. La liste à insérer peut être un autre vecteur (collection). La syntaxe complète de cette méthode est:

Public Boolean Addall (INT INDEX, Collection c)

Il revient vrai, si un changement a eu lieu; Faux autrement. Le code suivant illustre son utilisation:

Vecteur vtr = nouveau vecteur();
vtr.ajouter un'); vtr.ajouter ('b'); vtr.ajouter ('e'); vtr.ajouter ('f');
Vecteur C = nouveau vecteur();
c.ajouter ('c'); c.ajouter ('d');
vtr.addall (2, c);
pour (int i = 0; iSystème.dehors.imprimer (vtr.obtenir (i)); Système.dehors.imprimer(", ");

Système.dehors.println ();

La commande d'origine du tableau est:

A, b, e, f

La sortie est:

A B C D E F,

La liste ['C', 'D'] a été insérée à l'index 2.

Élimination des éléments

Il existe de nombreuses façons de supprimer les éléments. Seules deux approches sont abordées ici.

supprimer (int index)

Cette méthode supprime l'élément à l'index particulier. Les autres éléments à droite sont déplacés vers la gauche par un seul endroit. La syntaxe complète de cette méthode est:

Public E Suppor (INT INDEX)

Il renvoie l'élément qui a été supprimé. Le code suivant illustre son utilisation:

Vecteur vtr = nouveau vecteur();
vtr.ajouter un'); vtr.ajouter ('b'); vtr.ajouter ('c'); vtr.ajouter ('d'); vtr.ajouter ('e'); vtr.ajouter ('f');
vtr.retirer (3);
pour (int i = 0; iSystème.dehors.imprimer (vtr.obtenir (i)); Système.dehors.imprimer(", ");

Système.dehors.println ();

La commande d'origine du tableau est:

A B C D E F

La sortie est:

A, b, c, e, f,

'D' à l'index 3, a été supprimé.

vtr.sublist (int FromIndex, int toindex).clair()

Cette approche supprime une gamme d'éléments de From Index inclusif, à Toindex exclusif. Dans le code suivant, FromIndex est 2 et ToIndex est 4. Ainsi, seuls les éléments à l'indice 2 et 3 sont supprimés. Le code est:

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
Vecteur vtr = nouveau vecteur();
vtr.ajouter un'); vtr.ajouter ('b'); vtr.ajouter ('c'); vtr.ajouter ('d'); vtr.ajouter ('e'); vtr.ajouter ('f');
vtr.subliste (2, 4).clair();
pour (int i = 0; iSystème.dehors.imprimer (vtr.obtenir (i)); Système.dehors.imprimer(", ");

Système.dehors.println ();

La commande d'origine du tableau est:

A B C D E F

La sortie est:

A, b, e, f,

La liste des caractères consécutifs ['C', 'D'], a été supprimé.

Conclusion

Un vecteur en java, c'est comme un tableau. Cependant, contrairement à un tableau, il peut rétrécir ou augmenter la longueur. Les éléments peuvent être ajoutés ou insérés sur le vecteur, ce qui augmente sa longueur. Les éléments peuvent également être retirés, ce qui réduit la longueur. Cet article a expliqué ce qu'est un vecteur et ses méthodes couramment utilisées.