Come inizializzare un array in java

Un array in Java è una struttura di dati che ha elementi consecutivi dello stesso tipo. Gli elementi sono indicizzati, a partire da zero. In Java, un array è un oggetto ottenuto dalla classe oggetto. Esistono tre modi per creare un array: un array può essere dichiarato (creato) senza la lunghezza definita. In questo caso, la lunghezza dell'array deve ancora essere definita. È possibile creare un array, con la lunghezza definita e inizializzata automaticamente con i valori predefiniti del tipo di array. Un array può essere creato con i valori pratici assegnati agli elementi dell'array. In questo caso, la lunghezza dell'array è indirettamente definita dal numero di valori pratici.

Questo articolo illustra tre modi per inizializzare un array, utilizzando il tipo primitivo, il tipo di stringa e il tipo definito dall'utente. Il tipo di stringa e i tipi definiti dall'utente sono tipi di riferimento. L'articolo inizia con l'inizializzazione dell'array con un tipo primitivo.

Array di inizializzazione con tipo primitivo

Il tipo di carattere verrà utilizzato qui. Char significa carattere. Altri tipi primitivi vengono eseguiti allo stesso modo. Tutto il codice in questa sezione si svolge nel metodo principale (). La dichiarazione,

char [] arr;

dichiara un array senza alcun valore iniziale e senza il numero di caratteri indicati. Il numero di caratteri per l'array è la lunghezza dell'array. Una volta che la lunghezza è stata decisa, rimane così fino alla fine del programma. Un'altra affermazione è necessaria, insieme a questo, per dare lunghezza a questo array, come segue:

char [] arr;
arr = new char [5];

Ora, il numero di caratteri (lunghezza) dell'array è 5. Una certa inizializzazione ha avuto luogo con la seconda affermazione. Tuttavia, questa non è un'inizializzazione pratica. È inizializzazione con 5 valori predefiniti per char. Il valore predefinito per char è il carattere vuoto, i.e. ", Non ha spazio.

Il segmento di codice successivo assegna un valore pratico (carattere) a ciascuna delle posizioni di memoria, delle 5 variabili di caratteri dell'array:

arr [0] = 'f';
arr [1] = 'g';
arr [2] = 'H';
arr [3] = 'i';
arr [4] = 'j';

Questo è un incarico o una sostituzione. Non è inizializzazione. L'inizializzazione è stata eseguita con i valori predefiniti. Le due dichiarazioni di dichiarazione di cui sopra possono essere fatte in una dichiarazione, come segue:

char [] arr = new char [5];

Il nome dell'array è arr. Char è la parola riservata per char, che appare su entrambi i lati dell'operatore di assegnazione. Nuovo è un altro operatore. Crea l'oggetto con valori predefiniti. La seconda staffa quadrata nell'intera affermazione ha la lunghezza dell'array. A questo punto, ogni elemento dell'array deve ancora essere dato un valore pratico. Questo è il secondo modo per dichiarare un array.

Il terzo modo per dichiarare un array comporta l'inizializzazione con valori pratici. È in due forme, come segue:

char [] arr = 'f', 'g', 'h', 'i', 'j';

O

char [] arr = new char [] 'f', 'g', 'h', 'i', 'j';

La prima forma ha l'array letterale, che si chiama iniziale dell'array. È in parentesi graffe. Ogni personaggio è in una singola citazione. L'inizializzatore dell'array determina indirettamente la lunghezza dell'array (numero di elementi). Il primo modulo non ha il nuovo operatore. La seconda forma ha il nuovo operatore. Tuttavia, qui, le seconde parentesi quadrate non hanno la lunghezza dell'array, poiché la lunghezza è implicita nell'inizializzatore dell'array, codificata accanto ad esso.

Array di inizializzazione di stringhe

L'oggetto stringa è un ottimo esempio del tipo di riferimento in Java. Esistono due tipi di tipi in Java: primitivi e tipi di riferimento. I tipi primitivi sono: booleano, byte, char, corto, int, lungo, doppio, galleggiante. La seguente affermazione dichiara un array di stringhe senza alcuna lunghezza definita e valore iniziale (sia esso predefinito o pratico).

String [] arr;

Un'altra affermazione è necessaria, insieme a questo, per dare lunghezza a questo array, come segue:

String [] arr;
arr = new String [4];

Ora il numero di stringhe (riferimenti) dell'array è 4. Una certa inizializzazione ha avuto luogo con la seconda affermazione. Tuttavia, questa non è un'inizializzazione pratica. È inizializzazione con 4 valori predefiniti per la stringa. Il valore predefinito per la stringa è nullo, senza preventivi. Il seguente codice nel metodo principale () illustra questo:

String [] arr;
arr = new String [4];
per (int i = 0; i<4; i++)
Sistema.fuori.print (arr [i]); Sistema.fuori.stampa(");

Sistema.fuori.println ();

L'output è:

NULL NULL NULL NULL

Il seguente segmento di codice assegna un valore pratico (riferimento stringa) a ciascuna delle posizioni di memoria, delle 4 variabili di stringa dell'array:

arr [0] = "one";
arr [1] = "due";
arr [2] = "tre";
arr [3] = "quattro";

Questo è un incarico o una sostituzione. Non è inizializzazione. L'inizializzazione è stata eseguita con i valori predefiniti. Le due dichiarazioni di dichiarazione di cui sopra possono essere fatte in una dichiarazione, come segue:

String [] arr = new String [4];

Il nome dell'array è arr. Una stringa è una parola riservata per la stringa, che appare su entrambi i lati dell'operatore di assegnazione. Nuovo è un altro operatore. Crea l'array di oggetti con valori predefiniti. In tutta la dichiarazione, la seconda fascia quadrata ha la lunghezza dell'array. A questo punto, ogni elemento dell'array deve ancora essere dato un valore pratico. Quello era il secondo modo per dichiarare un array.

Il terzo modo per dichiarare un array comporta l'inizializzazione con valori pratici. È in due forme, come segue:

String [] arr = "one", "due", "tre", "quattro";

O

String [] arr = new String [] "one", "due", "tre", "quattro";

La prima forma ha l'array letterale, che si chiama iniziale dell'array. È in parentesi graffe. Ogni personaggio è in una singola citazione. L'inizializzatore dell'array determina indirettamente la lunghezza dell'array (numero di elementi). Il primo modulo non ha il nuovo operatore. La seconda forma ha il nuovo operatore. Tuttavia, qui, la seconda fascia quadrata non ha la lunghezza dell'array, poiché la lunghezza è implicita nell'inizializzatore dell'array, codificata accanto ad esso.

Nota: per utilizzare la stringa o l'array in Java, né la classe di stringa né la classe di array devono essere importate.

Oggetti definiti dall'utente

Di seguito è riportato un esempio di classe definita dall'utente:

classe aclass
int prop;
int mthd ()
restituzione prop;

Aclass è il nome della classe da cui verranno creati i suoi oggetti.

Nella funzione principale (), è possibile utilizzare i seguenti segmenti di codice:

Aclass obj1 = new aclass ();
obj1.Prop = 1;
int ret1 = obj1.mthd ();
Sistema.fuori.println (ret1);
Aclass obj2 = new aclass ();
obj2.Prop = 2;
int ret2 = obj2.mthd ();
Sistema.fuori.println (ret2);
Aclass obj3 = new aclass ();
obj3.prop = 3;
int ret3 = obj3.mthd ();
Sistema.fuori.println (ret3);

Ogni segmento di codice crea un oggetto di tipo, aclass. Ognuno è un oggetto definito dall'utente. Ogni segmento di codice assegna un numero intero alla proprietà (campo) di ciascun oggetto. Ci sono tre oggetti diversi della stessa classe. Ogni segmento di codice chiama il suo metodo per il suo oggetto. L'output per i tre segmenti di codice dovrebbe essere: 1 2 3, con ogni numero in una riga separata.

La dichiarazione di un array di un tipo di classe definito dall'utente viene eseguita allo stesso modo dei casi sopra. Per esempio,

Aclass [] arr = new aclass [3];

Dichiara una serie di tre oggetti di tipo, aclass. Questa istruzione ha creato un array inizializzato con il valore del tipo predefinito. Per qualsiasi tipo di riferimento, incluso il tipo di stringa, il valore predefinito è null. Ciò significa che ci sono tre valori di null nell'array, arr, ora. Il seguente codice in Main () dovrebbe dimostrare questo:

Aclass [] arr = new aclass [3];
per (int i = 0; i<3; i++)
Sistema.fuori.print (arr [i]); Sistema.fuori.stampa(");

Sistema.fuori.println ();

L'output è:

NULL NULL NULL

La seguente affermazione inizializza l'array con oggetti pratici del tipo ACLASS:

Aclass [] arr = obj1, obj2, obj3;
Questa affermazione è molto corretta. Sfortunatamente, il seguente segmento di codice, stampa codici, anziché OBJ1, OBJ2 e OBJ3:
Aclass [] arr = obj1, obj2, obj3;
per (int i = 0; i<3; i++)
Sistema.fuori.print (arr [i]); Sistema.fuori.stampa(");

Sistema.fuori.println ();

L'output è:

ACLASS@6FF3C5B5 ACLASS@3764951D ACLASS@4B1210EE

Tre codici diversi. La ragione di ciò è che l'array si aspetta letterali oggetti, ma sono stati dati riferimenti a oggetti.

Nella procedura di cui sopra, sono stati creati i nomi degli oggetti, OBJ1, OBJ2 e OBJ3. Per aggirare questo problema, istanziare gli oggetti come elementi di array, senza i loro nomi, come segue:

Aclass [] arr = new aclass (), new aclass (), new aclass ();

Da qui, invece di usare i nomi degli oggetti, OBJ1, OBJ2 OBJ3 per accedere alle proprietà e ai metodi, utilizzare gli indici dell'array come segue:

arr [0].Prop e arr [0].mthd (); arr [1].Prop e arr [1].mthd (); arr [2].Prop e arr [2].mthd ();

Risolve il problema. E quindi i tre segmenti di codice sopra possono essere riscritti come:

Aclass [] arr = new aclass (), new aclass (), new aclass ();
arr [0].Prop = 1;
int ret1 = arr [0].mthd ();
Sistema.fuori.println (ret1);
arr [1].Prop = 2;
int ret2 = arr [1].mthd ();
Sistema.fuori.println (ret2);
arr [2].prop = 3;
int ret3 = arr [2].mthd ();
Sistema.fuori.println (ret3);

E l'output finale previsto, è come prima, cioè: 1 2 3, con ogni numero nella propria linea.

Conclusione

Esistono due tipi di tipi in Java: tipi primitivi e tipi di riferimento. Un array può essere dichiarato senza alcun valore e lunghezza. Un array può essere dichiarato con la sua lunghezza ma inizializzato ai suoi valori predefiniti dal compilatore. Un array può essere dichiarato, inizializzato con i valori pratici. Se i valori sono riferimenti e i letterali non possono essere usati come valori, i valori dell'array dovrebbero essere le istanziazioni della classe.