En Java, matriz es un grupo de variables del mismo tipo a las que se hace referencia con un nombre común. Las matrices en Java funcionan de manera diferente que en C/C++. A continuación se presentan algunos puntos importantes sobre las matrices Java.

Matrices en Java

• En Java, todas las matrices se asignan dinámicamente. (se discute más adelante)
• Las matrices pueden almacenarse en memoria contigua [ubicaciones de memoria consecutivas].
• Dado que las matrices son objetos en Java, podemos encontrar su longitud usando la propiedad del objeto. longitud . Esto es diferente de C/C++, donde encontramos la longitud usando sizeof.
• Una variable de matriz Java también se puede declarar como otras variables con [] después del tipo de datos.
• Las variables de la matriz están ordenadas y cada una tiene un índice que comienza con 0.
• La matriz Java también se puede utilizar como campo estático, variable local o parámetro de método.

Una matriz puede contener referencias primitivas (int, char, etc.) y objetos (o no primitivos) de una clase, según la definición de la matriz. En el caso de tipos de datos primitivos, los valores reales pueden almacenarse en ubicaciones de memoria contiguas (JVM no garantiza este comportamiento). En el caso de objetos de clase, los objetos reales se almacenan en un segmento de montón .

formas normales

Nota: Este almacenamiento de matrices nos ayuda a acceder aleatoriamente a los elementos de una matriz [Support Random Access].

Creación, inicialización y acceso a matrices

Matrices unidimensionales

La forma general de una declaración de matriz unidimensional es

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

Una declaración de matriz tiene dos componentes: el tipo y el nombre. tipo declara el tipo de elemento de la matriz. El tipo de elemento determina el tipo de datos de cada elemento que compone la matriz. Al igual que una matriz de números enteros, también podemos crear una matriz de otros tipos de datos primitivos como char, float, double, etc., o tipos de datos definidos por el usuario (objetos de una clase). Por lo tanto, el tipo de elemento de la matriz determina qué tipo de datos contendrá la matriz.

Ejemplo:

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

Aunque la primera declaración establece que int Array es una variable de matriz, no existe ninguna matriz real . Simplemente le dice al compilador que esta variable (int Array) contendrá una matriz de tipo entero. Para vincular int Array con una matriz física real de números enteros, debe asignar uno usando nuevo y asígnelo a int Array.

Creación de instancias de una matriz en Java

Cuando se declara una matriz, solo se crea una referencia de una matriz. Para crear o darle memoria a la matriz, crea una matriz como esta: La forma general de nuevo lo que se aplica a matrices unidimensionales aparece de la siguiente manera:

var-name = new type [size];>

Aquí, tipo especifica el tipo de datos que se asignan, tamaño determina el número de elementos en la matriz, y nombre-var es el nombre de la variable de matriz que está vinculada a la matriz. Usar nuevo para asignar una matriz, debe especificar el tipo y número de elementos a asignar.

Ejemplo:

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

Nota: Los elementos de la matriz asignados por nuevo se inicializará automáticamente a cero (para tipos numéricos), FALSO (para booleano), o nulo (para tipos de referencia). Consulte valores de matriz predeterminados en Java .

Obtener una matriz es un proceso de dos pasos. Primero, debes declarar una variable del tipo de matriz deseado. En segundo lugar, debe asignar la memoria para contener la matriz, usando new, y asignarla a la variable de la matriz. De este modo, en Java , todas las matrices se asignan dinámicamente.

Matriz literal en Java

En una situación en la que ya se conocen el tamaño de la matriz y las variables de la matriz, se pueden utilizar literales de matriz.

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

• La longitud de esta matriz determina la longitud de la matriz creada.
• No es necesario escribir la nueva parte int[] en las últimas versiones de Java.

Accediendo a elementos de matriz Java usando for Loop

Se accede a cada elemento de la matriz a través de su índice. El índice comienza con 0 y termina en (tamaño total de la matriz) -1. Se puede acceder a todos los elementos de la matriz utilizando Java for Loop.

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

Implementación:

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

Complejidad del método anterior:

Complejidad del tiempo: O(n)
Espacio auxiliar: O(1)

También puede acceder a matrices Java usando para cada bucle .

tipos de red

Matrices de objetos en Java

Una matriz de objetos se crea como una matriz de elementos de datos de tipo primitivo de la siguiente manera.

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

Sintaxis:

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

Ejemplo de matrices de objetos

Ejemplo 1:

A continuación se muestra la implementación del tema mencionado anteriormente:

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 matriz de estudiantes contiene cinco espacios de memoria, cada uno del tamaño de la clase de estudiante, en los que se puede almacenar la dirección de cinco objetos de estudiante. Se deben crear instancias de los objetos Student utilizando el constructor de la clase Student, y sus referencias deben asignarse a los elementos de la matriz de la siguiente manera.

Ejemplo 2:

A continuación se muestra la implementación del tema mencionado anteriormente:

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

Complejidad del método anterior:

Complejidad del tiempo: O(n)
Espacio auxiliar: O(1)

Ejemplo 3

También se crea una matriz de objetos como:

// 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é sucede si intentamos acceder a elementos fuera del tamaño de la matriz?

lanzamientos de JVM ArrayIndexOutOfBoundsExcepción para indicar que se ha accedido a la matriz con un índice ilegal. El índice es negativo o mayor o igual que el tamaño de una matriz.

El siguiente código muestra lo que sucede si intentamos acceder a elementos fuera del tamaño de la matriz:

cuantas ciudades hay en estados unidos

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

Producción

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

Ejemplo (iterando la matriz):

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>

Complejidad del método anterior:

Complejidad del tiempo: O (n), aquí n es el tamaño de la matriz.
Espacio auxiliar: O(1) , ya que no se requiere espacio adicional.

Matrices multidimensionales en Java

Los arreglos multidimensionales son matrices de matrices con cada elemento de la matriz que contiene la referencia de otras matrices. Estos también se conocen como Matrices irregulares . Una matriz multidimensional se crea agregando un conjunto de corchetes ([]) por dimensión.

Sintaxis de la matriz multidimensional de Java

Existen 2 métodos para declarar matrices multidimensionales de Java como se menciona a continuación:

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

Ejemplo:

// 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ón de matriz multidimensional

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

Ejemplo de matriz dimensional múltiple en Java

Ejemplo 1:

A continuación se muestra la implementación del método anterior:

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

Pasar matrices a métodos

Al igual que las variables, también podemos pasar matrices a métodos. Por ejemplo, el siguiente programa pasa la matriz al método suma para calcular la suma de los valores de la matriz.

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

Complejidad del método anterior:

Complejidad del tiempo: En)
Espacio Auxiliar: O(1)

Devolver matrices de métodos

Como es habitual, un método también puede devolver una matriz. Por ejemplo, el siguiente programa devuelve una matriz del método 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>

Complejidad del método anterior:

Complejidad del tiempo: O(n)
Espacio auxiliar: O(1)

Objetos de clase para matrices

Cada matriz tiene un objeto Clase asociado, compartido con todas las demás matrices con el mismo tipo de 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;>

Explicación del método anterior:

1. La cadena [I es la firma del tipo en tiempo de ejecución para la matriz de objetos de clase con el tipo de componente En t .
2. La única superclase directa de un tipo de matriz es java.lang.Objeto .
3. La cadena [B es la firma del tipo en tiempo de ejecución para la matriz de objetos de clase con el tipo de componente byte .
4. La cadena [S es la firma del tipo en tiempo de ejecución para la matriz de objetos de clase con el tipo de componente corto .
5. La cadena [L es la firma de tipo en tiempo de ejecución para la matriz de objetos de clase con el tipo de componente de una Clase. Luego sigue el nombre de la clase.

Miembros de la matriz Java

Ahora, como usted sabe, las matrices son objetos de una clase y una superclase directa de matrices es una clase Objeto. Los miembros de un tipo de matriz son todos los siguientes:

• El campo final público longitud contiene el número de componentes de la matriz. La longitud puede ser positiva o cero.
• Todos los miembros se heredan de la clase Objeto; El único método de Object que no se hereda es su clon método.
• El método público clon() anula el método de clonación en la clase Objeto y no arroja ningún excepciones comprobadas .

Tipos de matrices y sus tipos de elementos permitidos

Clonación de matriz unidimensional en Java

Cuando clonas una matriz unidimensional, como Object[], se realiza una copia profunda con la nueva matriz que contiene copias de los elementos de la matriz original en lugar de referencias.

java es igual

A continuación se muestra la implementación del método 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ón de matriz multidimensional en Java

Sin embargo, un clon de una matriz multidimensional (como Objeto[][]) es una copia superficial, es decir, crea solo una nueva matriz en la que cada matriz de elementos es una referencia a una matriz de elementos original, pero los subarreglos son compartido.

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

Preguntas frecuentes sobre matrices Java

1. ¿Podemos especificar el tamaño de la matriz siempre?

No, no podemos especificar el tamaño de la matriz como long, pero podemos especificarlo como int o short.

2. ¿Cuál es la superclase directa de un array en Java?

Un Objeto es una superclase directa de una matriz en Java.

3. ¿Qué interfaces implementan los arreglos en Java?

Cada tipo de matriz implementa las interfaces Cloneable y java.io.Serializable .

4. ¿Podemos alterar el tamaño de Array?

El tamaño de la matriz no se puede modificar (una vez inicializada). Sin embargo, se puede hacer que una referencia a una matriz apunte a otra matriz.

Artículos relacionados con el tema

• Matriz irregular en Java
• Para cada bucle en Java
• Clase de matrices en Java