Cos'è un vettore in Java?

Un vettore in Java, è come un array. Tuttavia, a differenza di un array, può ridursi o aumentare di lunghezza. Gli elementi possono essere aggiunti o inseriti al vettore, il che aumenta la sua lunghezza. Gli elementi possono anche essere rimossi, il che riduce (riduce) la lunghezza del vettore.

In Java c'è la classe e ci sono oggetti della classe. Gli oggetti corrispondenti di una classe sono istanziati dalla classe. Il vettore è una classe da cui vengono istanziati gli oggetti vettoriali. La classe vettoriale si trova nel Java.util.* pacchetto, che deve essere importato. Questo articolo spiega cosa è un vettore e i suoi metodi comunemente usati.

Contenuto dell'articolo

• Costruzione di un vettore
• Aggiunta di elementi a un vettore
• Aggiunta a un vettore
• La lunghezza di un vettore
• Accedere a un elemento
• Inserimento di elementi
• Rimozione di elementi
• Conclusione

Costruzione di un vettore

Un vettore può essere costruito come un vettore vuoto o con elementi. Un vettore è una collezione. Ciò significa che un vettore può essere costituito da tutti i numeri interi, o tutti i personaggi, o tutti i doppi, o tutte le stringhe, ecc. Alla costruzione, il tipo è indicato tra parentesi angolari. Le staffe angolo prendono un riferimento e non un tipo primitivo. Quindi, dovrebbe essere e no; e non ; e non ; eccetera. Con le classi di riferimento, non ci sono problemi. Ad esempio, la stringa è giusta e non c'è altra alternativa. Tutti gli elementi del vettore sono dello stesso tipo.

Costruire un vettore vuoto

Il modo per costruire un vettore vuoto di caratteri è:

Vettore vtr = nuovo vettore();

dove VTR è il nome del vettore, dato dal programmatore. Nota le posizioni delle due staffe ad angolo. Nota la presenza delle parentesi vuote, alla fine della dichiarazione. Vector è una classe in Java, quindi deve iniziare con un personaggio maiuscolo. Il seguente programma ha la creazione di un vettore:

Importa Java.util.*;
Classe pubblica TheClass
public static void main (string [] args)
Vettore vtr = nuovo vettore();

Costruire un vettore con elementi

È possibile costruire un vettore non vuoto. Il modo per farlo è simile a quello sopra. È:

Vettore vtr = nuovo vettore(al);

erano al qui, è un arraylist, un'altra collezione. Il contenuto delle parentesi deve essere il nome di una raccolta. In questo caso, l'ArrayList deve essere stato definito come segue:

Lista di array al = nuovo arraylist();
al.aggiungere un'); al.Aggiungi ('b'); al.Aggiungi ('E'); al.Aggiungi ('f');

Il seguente programma mostra come un vettore non vuoto può essere costruito con questo schema:

Importa Java.util.*;
Classe pubblica TheClass
public static void main (string [] args)
Lista di array al = nuovo arraylist();
al.aggiungere un'); al.Aggiungi ('b'); al.Aggiungi ('E'); al.Aggiungi ('f');
Vettore vtr = nuovo vettore(al);

Nota: ArrayList è anche nel Java.util.* pacchetto.

Aggiunta di elementi a un vettore

Dopo che è stato creato un vettore, che sia vuoto o meno, è possibile aggiungere elementi.

Aggiunta di elementi uno per uno

La sintassi per l'aggiunta di elementi uno per uno è:

Public Boolean Add (e e)

Restituisce vero, se si è verificata un cambiamento e falso altrimenti. Il seguente codice nel metodo principale () mostra come gli elementi vengono aggiunti a un vettore.

Vettore vtr = nuovo vettore();
VTR.aggiungere un');
VTR.Aggiungi ('b');
VTR.Aggiungi ('E');
VTR.Aggiungi ('f');

Il vettore ora è costituito dai personaggi, "a", "b", "e" e "f".

Aggiunta di un elenco di elementi

Più di un elemento può essere aggiunto contemporaneamente, da un altro vettore. La sintassi per il metodo vettoriale per questo è:

Addall booleano pubblico (collezione C)

Restituisce vero, se si è verificata un cambiamento.

Il seguente codice nel metodo principale () illustra questo:

Vettore vtr = nuovo vettore();
VTR.aggiungere un'); VTR.Aggiungi ('b'); VTR.Aggiungi ('E'); VTR.Aggiungi ('f');
Vettore c = nuovo vettore();
C.Aggiungi ('g'); C.Aggiungi ('H');
VTR.addall (c);

L'altro vettore qui è c.

Aggiunta a un vettore

I due modi precedenti per aggiungere un vettore sono aggiunti: aggiunta elementi alla fine.

La lunghezza di un vettore

La lunghezza di un vettore è la dimensione del vettore: il numero di elementi del vettore. La classe vettoriale ha un metodo per ottenere la lunghezza di un vettore. La sintassi completa è:

public int size ()

La dimensione restituita è un numero intero. Considera il seguente codice nel metodo principale ():

Vettore vtr1 = nuovo vettore();
Vettore VTR2 = nuovo vettore();
VTR2.aggiungere un'); VTR2.Aggiungi ('b'); VTR2.Aggiungi ('E'); VTR2.Aggiungi ('f');
int len1 = vtr1.misurare();
int len2 = vtr2.misurare();
Sistema.fuori.println ("Len1 è:" + len1);
Sistema.fuori.println ("Len2 è:" + len2);

L'output è:

Len1 è: 0
Len2 è: 4

Accedere a un elemento

L'accesso a un elemento significa ottenere (leggere) o impostare (modificare) il valore di un elemento nel vettore.

Ottenere elemento

La sintassi completa per ottenere un elemento è:

public e get (int indice)

Viene restituita una copia dell'elemento. Il conteggio dell'indice inizia da 0. Il seguente codice ottiene tutti gli elementi del vettore utilizzando un per loop:

Vettore vtr = nuovo vettore();
VTR.aggiungere un'); VTR.Aggiungi ('b'); VTR.Aggiungi ('E'); VTR.Aggiungi ('f');
per (int i = 0; ichar ch = vtr.ottenere (i);
Sistema.fuori.stampa (ch); Sistema.fuori.stampa(", ");

Sistema.fuori.println ();

L'output è:

A, b, e, f,

Elemento di impostazione

La sintassi completa per impostare (modificare) un elemento è:

public e set (IND INDICE, Element)

Restituisce il vecchio elemento nella posizione dell'indice. I seguenti set di codice (modifiche) tutti gli elementi del vettore:

Vettore vtr = nuovo vettore();
VTR.aggiungere un'); VTR.Aggiungi ('b'); VTR.Aggiungi ('E'); VTR.Aggiungi ('f');
VTR.set (0, 'w'); VTR.set (1, 'x'); VTR.set (2, 'y'); VTR.set (3, 'z');
per (int i = 0; iSistema.fuori.Stampa (VTR.ottenere (i)); Sistema.fuori.stampa(", ");

Sistema.fuori.println ();

L'output è ora:

W X Y Z,

Con tutti gli elementi cambiati.

Inserimento di elementi

Gli elementi possono essere inseriti in un vettore. Questo necessita di altri due tipi di metodo ADD ().

Il metodo ADD (INT INDEX, E Element)

Questo metodo inserisce un elemento in una posizione indice. L'elemento che era in quella posizione viene spostato a destra. La sintassi completa per questo metodo è:

public void aggiungi (indice int, elemento e)

Nel codice seguente, un carattere viene inserito nella posizione dell'indice 2:

Vettore vtr = nuovo vettore();
VTR.aggiungere un'); VTR.Aggiungi ('b'); VTR.Aggiungi ('E'); VTR.Aggiungi ('f');
VTR.Aggiungi (2, 'd');
per (int i = 0; iSistema.fuori.Stampa (VTR.ottenere (i)); Sistema.fuori.stampa(", ");

Sistema.fuori.println ();

L'ordine di array originale è:

A, b, e, f

L'output è:

A, b, d, e, f,

'D' è stato inserito all'indice 2.

Addall (Index int, raccolta C)

Questo può inserire un elenco nella posizione dell'indice, spingendo il resto degli elementi, che erano sulla destra di quella posizione (incluso l'elemento nella posizione), più a destra, dal numero di caratteri nell'elenco inserito. L'elenco da inserire può essere un altro vettore (raccolta). La sintassi completa di questo metodo è:

Public Boolean Addall (IND INDICE, collezione C)

Restituisce vero, se si è verificata un cambiamento; falso altrimenti. Il seguente codice illustra il suo uso:

Vettore vtr = nuovo vettore();
VTR.aggiungere un'); VTR.Aggiungi ('b'); VTR.Aggiungi ('E'); VTR.Aggiungi ('f');
Vettore c = nuovo vettore();
C.Aggiungi ('c'); C.Aggiungi ('d');
VTR.Addall (2, c);
per (int i = 0; iSistema.fuori.Stampa (VTR.ottenere (i)); Sistema.fuori.stampa(", ");

Sistema.fuori.println ();

L'ordine di array originale è:

A, b, e, f

L'output è:

A B C D E F,

L'elenco ['c', 'd'] è stato inserito all'indice 2.

Rimozione di elementi

Esistono molti modi per rimuovere gli elementi. Qui vengono affrontati solo due approcci.

Rimuovi (Index int)

Questo metodo rimuove l'elemento nel particolare indice. Il resto degli elementi a destra viene spostato a sinistra da un posto. La sintassi completa per questo metodo è:

public E Rimuovi (IND INDEX)

Restituisce l'elemento che è stato rimosso. Il seguente codice illustra il suo uso:

Vettore vtr = nuovo vettore();
VTR.aggiungere un'); VTR.Aggiungi ('b'); VTR.Aggiungi ('c'); VTR.Aggiungi ('d'); VTR.Aggiungi ('E'); VTR.Aggiungi ('f');
VTR.rimuovere (3);
per (int i = 0; iSistema.fuori.Stampa (VTR.ottenere (i)); Sistema.fuori.stampa(", ");

Sistema.fuori.println ();

L'ordine di array originale è:

A B C D E F

L'output è:

A, b, c, e, f,

'D' all'indice 3, è stato rimosso.

VTR.Sublist (int dall'indice, int toindex).chiaro()

Questo approccio rimuove una serie di elementi dall'inclusivo INDEX, a TOINDEX ESCLUSIVE. Nel seguente codice, dall'indice è 2 e TOINDEX è 4. Quindi, vengono rimossi solo gli elementi all'indice 2 e 3. Il codice è:

Importa Java.util.*;
Classe pubblica TheClass
public static void main (string [] args)
Vettore vtr = nuovo vettore();
VTR.aggiungere un'); VTR.Aggiungi ('b'); VTR.Aggiungi ('c'); VTR.Aggiungi ('d'); VTR.Aggiungi ('E'); VTR.Aggiungi ('f');
VTR.Sublist (2, 4).chiaro();
per (int i = 0; iSistema.fuori.Stampa (VTR.ottenere (i)); Sistema.fuori.stampa(", ");

Sistema.fuori.println ();

L'ordine di array originale è:

A B C D E F

L'output è:

A, b, e, f,

L'elenco di caratteri consecutivi ['c', 'd'], è stato rimosso.

Conclusione

Un vettore in Java, è come un array. Tuttavia, a differenza di un array, può ridursi o aumentare di lunghezza. Gli elementi possono essere aggiunti o inseriti al vettore, il che aumenta la sua lunghezza. Gli elementi possono anche essere rimossi, il che riduce la lunghezza. Questo articolo ha spiegato cos'è un vettore e i suoi metodi comunemente usati.