En Java, Array és un grup de variables de tipus semblant a les quals es fa referència amb un nom comú. Les matrius a Java funcionen de manera diferent que a C/C++. A continuació es mostren alguns punts importants sobre les matrius Java.

Arrays en Java

• A Java, totes les matrius s'assignen dinàmicament. (que es parla a continuació)
• Les matrius es poden emmagatzemar en memòria contigua [ubicacions de memòria consecutives].
• Com que les matrius són objectes a Java, podem trobar la seva longitud mitjançant la propietat object llargada . Això és diferent de C/C++, on trobem longitud mitjançant sizeof.
• Una variable de matriu Java també es pot declarar com altres variables amb [] després del tipus de dades.
• Les variables de la matriu estan ordenades i cadascuna té un índex que comença per 0.
• La matriu Java també es pot utilitzar com a camp estàtic, una variable local o un paràmetre de mètode.

Una matriu pot contenir referències primitives (int, char, etc.) i objectes (o no primitives) d'una classe, depenent de la definició de la matriu. En el cas dels tipus de dades primitius, els valors reals es podrien emmagatzemar en ubicacions de memòria contigües (JVM no garanteix aquest comportament). En el cas dels objectes de classe, els objectes reals s'emmagatzemen en un segment de pila .

apila java

Nota: Aquest emmagatzematge de matrius ens ajuda a accedir de manera aleatòria als elements d'una matriu [Support Random Access].

Creació, inicialització i accés a una matriu

Matrius unidimensionals

La forma general d'una declaració de matriu unidimensional és

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

Una declaració de matriu té dos components: el tipus i el nom. tipus declara el tipus d'element de la matriu. El tipus d'element determina el tipus de dades de cada element que comprèn la matriu. Com una matriu d'enters, també podem crear una matriu d'altres tipus de dades primitives com char, float, double, etc., o tipus de dades definides per l'usuari (objectes d'una classe). Així, el tipus d'element de la matriu determina quin tipus de dades conté la matriu.

Exemple:

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

Tot i que la primera declaració estableix que int Array és una variable de matriu, no existeix cap matriu real . Simplement diu al compilador que aquesta variable (int Array) conté una matriu del tipus enter. Per enllaçar int Array amb una matriu física real de nombres enters, n'heu d'assignar-ne un nou i assigneu-lo a int Array.

Instanciació d'una matriu en Java

Quan es declara una matriu, només es crea una referència d'una matriu. Per crear o donar memòria a la matriu, creeu una matriu com aquesta: La forma general de nou com s'aplica a matrius unidimensionals, apareix de la següent manera:

var-name = new type [size];>

Aquí, tipus especifica el tipus de dades que s'assignen, mida determina el nombre d'elements de la matriu, i nom-var és el nom de la variable de matriu que està enllaçada a la matriu. Usar nou per assignar una matriu, heu d'especificar el tipus i el nombre d'elements a assignar.

Exemple:

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

Nota: Els elements de la matriu assignats per nou s'inicializarà automàticament a zero (per a tipus numèrics), fals (per a booleà), o nul (per a tipus de referència). Fes referència valors de matriu predeterminats a Java .

L'obtenció d'una matriu és un procés de dos passos. En primer lloc, heu de declarar una variable del tipus de matriu desitjat. En segon lloc, heu d'assignar la memòria per contenir la matriu, utilitzant new, i assignar-la a la variable de matriu. Així, en Java , totes les matrius s'assignen dinàmicament.

Matriu Literal en Java

En una situació en què la mida de la matriu i les variables de la matriu ja es coneixen, es poden utilitzar literals de matriu.

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

• La longitud d'aquesta matriu determina la longitud de la matriu creada.
• No cal escriure la nova part int[] a les últimes versions de Java.

Accés als elements de la matriu Java amb for Loop

S'accedeix a cada element de la matriu mitjançant el seu índex. L'índex comença amb 0 i acaba a (mida total de la matriu) -1. Es pot accedir a tots els elements de la matriu mitjançant Java for Loop.

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

Implementació:

// 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>

Complexitat del mètode anterior:

Complexitat temporal: O(n)
Espai auxiliar: O(1)

També podeu accedir a matrius de Java mitjançant per a cada bucle .

ordenar una llista de matrius java

Matrius d'objectes en Java

Una matriu d'objectes es crea com una matriu d'elements de dades de tipus primitiu de la manera següent.

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

Sintaxi:

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

Exemple de matrius d'objectes

Exemple 1:

A continuació es mostra la implementació del tema esmentat anteriorment:

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>

La matriu d'estudiants conté cinc espais de memòria cadascun de la mida de la classe de l'estudiant en els quals es pot emmagatzemar l'adreça de cinc objectes Student. Els objectes Student s'han d'instanciar mitjançant el constructor de la classe Student i les seves referències s'han d'assignar als elements de la matriu de la manera següent.

Exemple 2:

A continuació es mostra la implementació del tema esmentat anteriorment:

// 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>

Complexitat del mètode anterior:

Complexitat temporal: O(n)
Espai auxiliar: O(1)

Exemple 3

També es crea una matriu d'objectes com:

// 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>

Què passa si intentem accedir a elements fora de la mida de la matriu?

JVM llança ArrayIndexOutOfBoundsException per indicar que s'ha accedit a la matriu amb un índex il·legal. L'índex és negatiu o superior o igual a la mida d'una matriu.

El codi següent mostra què passa si intentem accedir a elements fora de la mida de la matriu:

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

Sortida

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)>

Exemple (iteració de la matriu):

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>

Complexitat del mètode anterior:

Complexitat temporal: O(n), aquí n és la mida de la matriu.
Espai auxiliar: O(1) , ja que no cal espai addicional.

Matrius multidimensionals en Java

Les matrius multidimensionals són matrius de matrius amb cada element de la matriu que conté la referència d'altres matrius. Aquests també es coneixen com Arrays dentats . Es crea una matriu multidimensional afegint un conjunt de claudàtors ([]) per dimensió.

Sintaxi de la matriu multidimensional de Java

Hi ha 2 mètodes per declarar les matrius multidimensionals de Java tal com s'esmenta a continuació:

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

Exemple:

// 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>

Declaració de matriu multidimensional

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

Exemple de matriu multidimensional a Java

Exemple 1:

A continuació es mostra la implementació del mètode anterior:

modulació d'amplitud

// 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>

Passant matrius a mètodes

Igual que les variables, també podem passar matrius als mètodes. Per exemple, el programa següent passa la matriu al mètode suma per calcular la suma dels valors de la matriu.

// 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>

Complexitat del mètode anterior:

Complexitat temporal: O(n)
Espai auxiliar: O(1)

Devolució de matrius de mètodes

Com és habitual, un mètode també pot retornar una matriu. Per exemple, el programa següent retorna una matriu del mètode 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>

Complexitat del mètode anterior:

Complexitat temporal: O(n)
Espai auxiliar: O(1)

Objectes de classe per a matrius

Cada matriu té un objecte Class associat, compartit amb totes les altres matrius amb el mateix tipus de component.

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

Explicació del mètode anterior:

1. La cadena [I és la signatura de tipus en temps d'execució per a la matriu d'objectes de classe amb el tipus de component int .
2. L'única superclasse directa d'un tipus de matriu és java.lang.Object .
3. La cadena [B és la signatura de tipus en temps d'execució per a la matriu d'objectes de classe amb el tipus de component byte .
4. La cadena [S és la signatura de tipus en temps d'execució per a la matriu d'objectes de classe amb el tipus de component curt .
5. La cadena [L és la signatura de tipus en temps d'execució per a la matriu d'objectes de classe amb el tipus de component d'una classe. Després se segueix el nom de la classe.

Membres de la matriu Java

Ara, com sabeu, les matrius són objectes d'una classe i una superclasse directa de matrius és un Object de classe. Els membres d'un tipus de matriu són tots els següents:

• El camp final públic llargada conté el nombre de components de la matriu. La longitud pot ser positiva o zero.
• Tots els membres s'hereten de la classe Object; l'únic mètode d'Objecte que no s'hereta és el seu clonar mètode.
• El mètode públic clonar () anul·la el mètode de clonació de la classe Object i llança no excepcions marcades .

Tipus de matrius i els seus tipus d'elements permesos

Clonació de matrius unidimensionals a Java

Quan cloneu una matriu unidimensional, com ara Object[], es realitza una còpia profunda amb la nova matriu que conté còpies dels elements de la matriu original en lloc de les referències.

mètodes de cadena en java

A continuació es mostra la implementació del mètode anterior:

// 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>

Clonació de matrius multidimensionals en Java

Un clon d'una matriu multidimensional (com Object[][]) és una còpia superficial, però, és a dir que només crea una única matriu nova amb cada matriu d'elements una referència a una matriu d'elements original, però els subarrays són compartit.

// 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>

Preguntes freqüents a les matrius Java

1. Podem especificar la mida de la matriu tan llarga?

No, no podem especificar la mida de la matriu tan llarga, però podem especificar-la com a int o com a curta.

2. Quina és la superclasse directa d'una matriu a Java?

An Objecte és la superclasse directa d'una matriu en Java.

3. Quines interfícies implementen Arrays a Java?

Cada tipus de matriu implementa les interfícies Cloneable i java.io.Serialitzable .

4. Podem modificar la mida de Array?

La mida de la matriu no es pot modificar (un cop inicialitzada). Tanmateix, es pot fer una referència a una matriu per apuntar a una altra matriu.

Articles relacionats amb el tema

• Jagged Array a Java
• Per a cada bucle a Java
• Classe de matrius en Java