In Java, Array è un gruppo di variabili di tipo simile a cui fa riferimento un nome comune. Gli array in Java funzionano diversamente rispetto a C/C++. Di seguito sono riportati alcuni punti importanti sugli array Java.

Array in Java

• In Java, tutti gli array vengono allocati dinamicamente. (discusso di seguito)
• Gli array possono essere archiviati in memoria contigua [locazioni di memoria consecutive].
• Poiché gli array sono oggetti in Java, possiamo trovare la loro lunghezza utilizzando la proprietà object lunghezza . Questo è diverso da C/C++, dove troviamo la lunghezza utilizzando sizeof.
• Una variabile array Java può anche essere dichiarata come altre variabili con [] dopo il tipo di dati.
• Le variabili nell'array sono ordinate e ciascuna ha un indice che inizia con 0.
• L'array Java può essere utilizzato anche come campo statico, variabile locale o parametro di metodo.

Un array può contenere primitive (int, char, ecc.) e riferimenti a oggetti (o non primitivi) di una classe a seconda della definizione dell'array. Nel caso di tipi di dati primitivi, i valori effettivi potrebbero essere archiviati in posizioni di memoria contigue (JVM non garantisce questo comportamento). Nel caso degli oggetti di classe, gli oggetti effettivi vengono archiviati in un segmento heap .

mysql mostra gli utenti

Nota: Questa memorizzazione di array ci aiuta ad accedere in modo casuale agli elementi di un array [Support Random Access].

Creazione, inizializzazione e accesso a un array

Array unidimensionali

La forma generale di una dichiarazione di array unidimensionale è

-- type var-name[]; -- type[] var-name;>

Una dichiarazione di array ha due componenti: il tipo e il nome. tipo dichiara il tipo di elemento dell'array. Il tipo di elemento determina il tipo di dati di ciascun elemento che comprende l'array. Come un array di numeri interi, possiamo anche creare un array di altri tipi di dati primitivi come char, float, double, ecc., o tipi di dati definiti dall'utente (oggetti di una classe). Pertanto, il tipo di elemento dell'array determina il tipo di dati che l'array conterrà.

Esempio:

// both are valid declarations int intArray[]; int[] intArray; // similar to int we can declare // byte , short, boolean, long, float // double, char // an array of references to objects of // the class MyClass (a class created by user) MyClass myClassArray[]; // array of Object Object[] ao, // array of Collection // of unknown type Collection[] ca;>

Sebbene la prima dichiarazione stabilisca che int Array è una variabile di array, non esiste alcun array effettivo . Dice semplicemente al compilatore che questa variabile (int Array) conterrà un array di tipo intero. Per collegare int Array con un array fisico reale di numeri interi, è necessario allocarne uno utilizzando nuovo e assegnarlo a int Array.

Istanziare un array in Java

Quando viene dichiarato un array, viene creato solo un riferimento di un array. Per creare o fornire memoria all'array, crea un array come questo: La forma generale di nuovo come si applica agli array unidimensionali appare come segue:

var-name = new type [size];>

Qui, tipo specifica il tipo di dati da allocare, misurare determina il numero di elementi nell'array e nome-var è il nome della variabile di array collegata all'array. Usare nuovo per allocare un array, è necessario specificare il tipo e il numero di elementi da allocare.

Esempio:

//declaring array int intArray[]; // allocating memory to array intArray = new int[20]; // combining both statements in one int[] intArray = new int[20];>

Nota: Gli elementi nell'array allocati da nuovo verrà automaticamente inizializzato su zero (per tipi numerici), falso (per booleano), o nullo (per i tipi di riferimento). Fare riferimento a valori di array predefiniti in Java .

Ottenere un array è un processo in due passaggi. Innanzitutto è necessario dichiarare una variabile del tipo di array desiderato. In secondo luogo, è necessario allocare la memoria per contenere l'array, utilizzando new, e assegnarla alla variabile dell'array. Così, a Giava , tutti gli array vengono allocati dinamicamente.

Array letterale in Java

In una situazione in cui la dimensione dell'array e le variabili dell'array sono già note, è possibile utilizzare i valori letterali dell'array.

// Declaring array literal int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 };>

• La lunghezza di questo array determina la lunghezza dell'array creato.
• Non è necessario scrivere la nuova parte int[] nelle ultime versioni di Java.

Accesso agli elementi dell'array Java utilizzando for Loop

Ogni elemento dell'array è accessibile tramite il suo indice. L'indice inizia con 0 e termina con (dimensione totale dell'array)-1. È possibile accedere a tutti gli elementi dell'array utilizzando Java for Loop.

 // accessing the elements of the specified array for (int i = 0; i>

Implementazione:

// Java program to illustrate creating an array // of integers, puts some values in the array, // and prints each value to standard output. class GFG { public static void main(String[] args) { // declares an Array of integers. int[] arr; // allocating memory for 5 integers. arr = new int[5]; // initialize the first elements of the array arr[0] = 10; // initialize the second elements of the array arr[1] = 20; // so on... arr[2] = 30; arr[3] = 40; arr[4] = 50; // accessing the elements of the specified array for (int i = 0; i < arr.length; i++) System.out.println('Element at index ' + i + ' : ' + arr[i]); } }>

Element at index 0 : 10 Element at index 1 : 20 Element at index 2 : 30 Element at index 3 : 40 Element at index 4 : 50>

Complessità del metodo sopra:

Complessità temporale: O(n)
Spazio ausiliario: O(1)

Puoi anche accedere agli array Java utilizzando per ogni ciclo .

ordinamento di un arraylist java

Matrici di oggetti in Java

Un array di oggetti viene creato come un array di elementi di dati di tipo primitivo nel modo seguente.

Student[] arr = new Student[5]; //student is a user-defined class>

Sintassi:

-- data type[] arrName; -- datatype arrName[]; -- datatype [] arrName;>

Esempio di array di oggetti

Esempio 1:

Di seguito è riportata l'implementazione dell'argomento sopra menzionato:

import java.io.*; class GFG { public static void main (String[] args) { int [] arr=new int [4]; // 4 is the size of arr System.out.println('Array Size:'+arr.length); } }>

Array Size:4>

L'array studente contiene cinque spazi di memoria, ciascuno della dimensione di una classe studente, in cui è possibile memorizzare l'indirizzo di cinque oggetti Student. Gli oggetti Student devono essere istanziati utilizzando il costruttore della classe Student, e i loro riferimenti devono essere assegnati agli elementi dell'array nel modo seguente.

Esempio 2:

Di seguito è riportata l'implementazione dell'argomento sopra menzionato:

// Java program to illustrate creating // an array of objects class Student { public int roll_no; public String name; Student(int roll_no, String name) { this.roll_no = roll_no; this.name = name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main(String[] args) { // declares an Array of Students Student[] arr; // allocating memory for 5 objects of type Student. arr = new Student[5]; // initialize the first elements of the array arr[0] = new Student(1, 'aman'); // initialize the second elements of the array arr[1] = new Student(2, 'vaibhav'); // so on... arr[2] = new Student(3, 'shikar'); arr[3] = new Student(4, 'dharmesh'); arr[4] = new Student(5, 'mohit'); // accessing the elements of the specified array for (int i = 0; i < arr.length; i++) System.out.println('Element at ' + i + ' : ' + arr[i].roll_no + ' ' + arr[i].name); } }>

Element at 0 : 1 aman Element at 1 : 2 vaibhav Element at 2 : 3 shikar Element at 3 : 4 dharmesh Element at 4 : 5 mohit>

Complessità del metodo sopra:

Complessità temporale: O(n)
Spazio ausiliario: O(1)

Esempio 3

Viene inoltre creata una serie di oggetti come:

// Java program to illustrate creating // an array of objects class Student { public String name; Student(String name) { this.name = name; } @Override public String toString(){ return name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main (String[] args) { // declares an Array and initializing the elements of the array Student[] myStudents = new Student[]{new Student('Dharma'),new Student('sanvi'),new Student('Rupa'),new Student('Ajay')}; // accessing the elements of the specified array for(Student m:myStudents){ System.out.println(m); } } }>

Dharma sanvi Rupa Ajay>

Cosa succede se proviamo ad accedere a elementi al di fuori della dimensione dell'array?

JVM lancia Indice della Matrice Fuori Dai Limiti d'Eccezione per indicare che è stato effettuato l'accesso all'array con un indice non valido. L'indice è negativo oppure maggiore o uguale alla dimensione di un array.

Il codice seguente mostra cosa succede se proviamo ad accedere a elementi al di fuori della dimensione dell'array:

// Code for showing error 'ArrayIndexOutOfBoundsException' public class GFG { public static void main(String[] args) { int[] arr = new int[4]; arr[0] = 10; arr[1] = 20; arr[2] = 30; arr[3] = 40; System.out.println( 'Trying to access element outside the size of array'); System.out.println(arr[5]); } }>

Produzione

Trying to access element outside the size of array Exception in thread 'main' java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 4 at GFG.main(GFG.java:13)>

Esempio (iterazione dell'array):

public class GFG { public static void main(String[] args) { int[] arr = new int[2]; arr[0] = 10; arr[1] = 20; for (int i = 0; i < arr.length; i++) System.out.println(arr[i]); } }>

10 20>

Complessità del metodo sopra:

Complessità temporale: O(n), qui n è la dimensione dell'array.
Spazio ausiliario: O(1) , poiché non è richiesto spazio aggiuntivo.

Array multidimensionali in Java

Gli array multidimensionali lo sono matrici di matrici con ogni elemento dell'array che contiene il riferimento di altri array. Questi sono anche conosciuti come Array frastagliati . Un array multidimensionale viene creato aggiungendo un set di parentesi quadre ([]) per dimensione.

Sintassi dell'array multidimensionale Java

Esistono 2 metodi per dichiarare gli array multidimensionali Java come indicato di seguito:

l'attrice indiana rani mukerji

-- datatype [][] arrayrefvariable; -- datatype arrayrefvariable[][];>

Esempio:

// Java Program to demonstrate // Java Multidimensional Array import java.io.*; // Driver class class GFG { public static void main(String[] args) { // Syntax int[][] arr = new int[3][3]; // 3 row and 3 column // Number of Rows System.out.println('Number of Rows:'+ arr.length); // Number of Columns System.out.println('Number of Columns:'+ arr[0].length); } }>

Number of Rows:3 Number of Columns:3>

Dichiarazione di array multidimensionale

int[][] intArray = new int[10][20]; //a 2D array or matrix int[][][] intArray = new int[10][20][10]; //a 3D array>

Esempio di array dimensionale Muilti in Java

Esempio 1:

Di seguito è riportata l'implementazione del metodo sopra:

// Java Program to Multidimensional Array // Driver Class public class multiDimensional { // main function public static void main(String args[]) { // declaring and initializing 2D array int arr[][] = { { 2, 7, 9 }, { 3, 6, 1 }, { 7, 4, 2 } }; // printing 2D array for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) System.out.print(arr[i][j] + ' '); System.out.println(); } } }>

2 7 9 3 6 1 7 4 2>

Passaggio di array ai metodi

Come le variabili, possiamo anche passare gli array ai metodi. Ad esempio, il programma seguente passa l'array al metodo somma per calcolare la somma dei valori dell'array.

// Java program to demonstrate // passing of array to method public class Test { // Driver method public static void main(String args[]) { int arr[] = { 3, 1, 2, 5, 4 }; // passing array to method m1 sum(arr); } public static void sum(int[] arr) { // getting sum of array values int sum = 0; for (int i = 0; i < arr.length; i++) sum += arr[i]; System.out.println('sum of array values : ' + sum); } }>

sum of array values : 15>

Complessità del metodo sopra:

Complessità temporale: SU)
Spazio ausiliario: O(1)

Restituzione di array dai metodi

Come al solito, un metodo può anche restituire un array. Ad esempio, il programma seguente restituisce un array dal metodo m1 .

// Java program to demonstrate // return of array from method class Test { // Driver method public static void main(String args[]) { int arr[] = m1(); for (int i = 0; i < arr.length; i++) System.out.print(arr[i] + ' '); } public static int[] m1() { // returning array return new int[] { 1, 2, 3 }; } }>

1 2 3>

Complessità del metodo sopra:

Complessità temporale: O(n)
Spazio ausiliario: O(1)

Oggetti di classe per array

Ogni array ha un oggetto Class associato, condiviso con tutti gli altri array con lo stesso tipo di componente.

// Java program to demonstrate // Class Objects for Arrays class Test { public static void main(String args[]) { int intArray[] = new int[3]; byte byteArray[] = new byte[3]; short shortsArray[] = new short[3]; // array of Strings String[] strArray = new String[3]; System.out.println(intArray.getClass()); System.out.println( intArray.getClass().getSuperclass()); System.out.println(byteArray.getClass()); System.out.println(shortsArray.getClass()); System.out.println(strArray.getClass()); } }>

class [I class java.lang.Object class [B class [S class [Ljava.lang.String;>

Spiegazione del metodo sopra:

1. La stringa [I è la firma del tipo di runtime per l'array di oggetti classe con il tipo di componente int .
2. L'unica superclasse diretta di un tipo array è java.lang.Object .
3. La stringa [B è la firma del tipo di runtime per l'array di oggetti classe con il tipo di componente byte .
4. La stringa [S è la firma del tipo di runtime per l'array di oggetti della classe con il tipo di componente corto .
5. La stringa [L è la firma del tipo di runtime per l'array di oggetti classe con il tipo di componente di una classe. Viene quindi seguito il nome della classe.

Membri dell'array Java

Ora, come sai, gli array sono oggetti di una classe e una superclasse diretta di array è una classe Object. I membri di un tipo di array sono tutti i seguenti:

• Il campo finale pubblico lunghezza contiene il numero di componenti dell'array. La lunghezza può essere positiva o zero.
• Tutti i membri sono ereditati dalla classe Object; l'unico metodo di Object che non è ereditato è its clone metodo.
• Il metodo pubblico clone() sovrascrive il metodo clone nella classe Object e genera no controllato le eccezioni .

Tipi di array e tipi di elementi consentiti

Clonazione di array unidimensionali in Java

Quando cloni un array unidimensionale, come Object[], viene eseguita una copia profonda con il nuovo array contenente copie degli elementi dell'array originale invece dei riferimenti.

il miglior hentai

Di seguito è riportata l'implementazione del metodo sopra:

// Java program to demonstrate // cloning of one-dimensional arrays class Test { public static void main(String args[]) { int intArray[] = { 1, 2, 3 }; int cloneArray[] = intArray.clone(); // will print false as deep copy is created // for one-dimensional array System.out.println(intArray == cloneArray); for (int i = 0; i < cloneArray.length; i++) { System.out.print(cloneArray[i] + ' '); } } }>

false 1 2 3>

Clonazione di array multidimensionali in Java

Un clone di un array multidimensionale (come Object[][]) è tuttavia una copia superficiale, vale a dire che crea solo un singolo nuovo array con ogni array di elementi un riferimento a un array di elementi originale, ma i sottoarray sono condiviso.

// Java program to demonstrate // cloning of multi-dimensional arrays class Test { public static void main(String args[]) { int intArray[][] = { { 1, 2, 3 }, { 4, 5 } }; int cloneArray[][] = intArray.clone(); // will print false System.out.println(intArray == cloneArray); // will print true as shallow copy is created // i.e. sub-arrays are shared System.out.println(intArray[0] == cloneArray[0]); System.out.println(intArray[1] == cloneArray[1]); } }>

false true true>

Domande frequenti sugli array Java

1. Possiamo specificare la dimensione dell'array così lunga?

No, non possiamo specificare la dimensione dell'array come long ma possiamo specificarla come int o short.

2. Qual è la superclasse diretta di un array in Java?

UN Oggetto è la superclasse diretta di un array in Java.

3. Quali interfacce sono implementate dagli array in Java?

Ogni tipo di array implementa le interfacce Cloneable e java.io.Serializable .

4. Possiamo modificare la dimensione dell'Array?

La dimensione dell'array non può essere modificata (una volta inizializzata). Tuttavia, è possibile fare in modo che un riferimento ad un array punti a un altro array.

Articoli correlati all'argomento

• Array frastagliato in Java
• Per ogni ciclo in Java
• Classe Array in Java