Arrays en Java (Con ejemplos)

Arrays Intermedio POO

Un array o matriz es simplemente una variable que puede contener valores múltiples, a diferencia de una variable regular que solo puede contener un único valor.

Los siguientes son algunos puntos importantes acerca de las matrices, arreglos o arrays de Java.

  • En Java, todas las matrices se asignan dinámicamente. (Se analiza a continuación)
  • Como las matrices/arrays son objetos en Java, cada array tiene asociado una variable de instancia de longitud (length) que contiene la cantidad de elementos que la matriz puede contener. (En otras palabras, length contiene el tamaño de la matriz.)
  • Una variable array en Java se declara como otras variables con corchetes [] después del tipo de datos.
  • Las variables en el array están ordenadas y cada una tiene un índice que comienza desde 0.
  • El array Java también se puede usar como un campo estático, una variable local o un parámetro de método.
  • El tamaño de un array debe especificarse mediante un valor int y no, long o short.
  • La superclase directa de un tipo de array es Object.
  • Cada tipo de array implementa las interfaces Cloneable y java.io.Serializable.
  • El array puede contener tipos de datos primitivos así como también objetos de una clase según la definición del array. En el caso de los tipos de datos primitivos, los valores reales se almacenan en ubicaciones de memoria contigua. En el caso de los objetos de una clase, los objetos reales se almacenan en heap.
Nota: En matemáticas, un array de una dimensión se llama vector. En este curso no
utilizaremos este término para no confundirlo con la clase Vector de Java.

1. Qué es un Array en Java

Una array o arreglo es una colección de variables del mismo tipo, a la que se hace referencia por un nombre común. En Java, los arrays pueden tener una o más dimensiones, aunque el array unidimensional es el más común.

Los arrays se usan para una variedad de propósitos porque ofrecen un medio conveniente de agrupar variables relacionadas. Por ejemplo, puede usar una matriz para mantener un registro de la temperatura alta diaria durante un mes, una lista de promedios de precios de acciones o una lista de tu colección de libros de programación.

La ventaja principal de un array es que organiza los datos de tal manera que puede ser manipulado fácilmente. Por ejemplo, si tiene un array que contiene los ingresos de un grupo seleccionado de hogares, es fácil calcular el ingreso promedio haciendo un ciclo a través del array. Además, los arrays organizan los datos de tal manera que se pueden ordenar fácilmente.

Aunque los arrays en Java se pueden usar como matrices en otros lenguajes de programación, tienen un atributo especial: se implementan como objetos. Este hecho es una de las razones por las que la discusión de los arrays se pospuso hasta que se introdujeron los objetos. Al implementar arrays como objetos, se obtienen varias ventajas importantes, una de las cuales es que los arrays no utilizados pueden ser recolectados.

 

2. Arrays unidimensionales

Un array unidimensional es una lista de variables relacionadas. Tales listas son comunes en la programación. Por ejemplo, puede usar un array unidimensional para almacenar los números de cuenta de los usuarios activos en una red. Otro array podría usarse para almacenar los promedios de bateo actuales para un equipo de béisbol.

La forma general de declarar un arreglo unidimensional es:

tipo nombre-array[];

o

tipo [] nombre-array;

La declaración de un array tiene dos componentes: el tipo y el nombre.

  • tipo declara el tipo de elemento del array. El tipo de elemento determina el tipo de datos de cada elemento que comprende la matriz. Al igual que la matriz de tipo int, también podemos crear una matriz de otros tipos de datos primitivos como char, float, double..etc o tipo de datos definido por el usuario (objetos de una clase). Por lo tanto, el tipo de elemento para la matriz determina el tipo de datos que la matriz contendrá.

Ejemplo:

// ambas son declaraciones válidas
int intArray[]; 
int[] intArray;

//Tipo de datos primitivos

byte byteArray[];
short shortArray[];
boolean booleanArray[];
long longArray[];
float floatArray[];
double doubleArray[];
char charArray[];

//Tipos de datos definidos por el usuario

// una serie de referencias a objetos de
// la clase MyClass (una clase creada por
// el usuario)

MyClass myClassArray[]; 

Object[]  ao,        // array de Object
Collection[] ca;  // array de Collection

Aunque la primera declaración anterior establece el hecho de que intArray es una variable de matriz, en realidad no existe una matriz. Simplemente le dice al compilador que esta variable (intArray) contendrá una matriz del tipo entero. Para vincular intArray con una matriz física real de enteros, debe asignar una usando new y asignarlo a intArray. Ya veremos…

2.1. Instanciando un array en Java

Cuando un array se declara, solo se crea una referencia del array. Para realmente crear o dar memoria al array (a partir de aquí solo mencionaré a array, y no matriz o arreglo), puede crear un array de la siguiente manera:

nombre-array = new tipo [tamaño];
  • tipo especifica el tipo de datos que se asignará
  • tamaño especifica el número de elementos en el array
  • nombre-array es el nombre de la variable del array vinculado al mismo.
  • Es decir, para usar new para asignar un array, debe especificar el tipo y la cantidad de elementos a asignar.

Ejemplo:

int intArray[]; //declarando un array
intArray = new int[20]; // asignando memoria al array

o

int[] intArray = new int[20]; // combinando ambas declaraciones en una

Nota:

  • Los elementos en la matriz asignada por new se inicializarán automáticamente a cero (para tipos numéricos), false (para booleano) o null (para tipos de referencia).
  • Obtener un array es un proceso de dos pasos. Primero, debe declarar una variable del tipo de array deseado. En segundo lugar, debe asignar la memoria que mantendrá el array, usar new y asignarla a la variable del array. Por lo tanto, en Java, todos los arrays se asignan dinámicamente.

2.2. Array Literal

En una situación en la que ya se conoce el tamaño y los elementos del array, se pueden usar literales del array.

 int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; 
 // Declarando un array literal
  • La longitud de este array determina la longitud del array creado.
  • No es necesario escribir new int[] en las últimas versiones de Java

2.3. Accediendo a los elementos del Array usando el bucle for

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

//acceder a los elementos del array
 for (int i = 0; i < arr.length; i++)
 System.out.println("Elemento en el índice " + i + " : "+ arr[i]);

Ejemplo:

// Programa Java para ilustrar la creación de un array de enteros,
// coloca algunos valores en la matriz, e imprime cada valor
 
class DemoArray
{
    public static void main (String[] args) 
    {         
      // declara un array de enteros.
      int[] arr;
         
      // asignando memoria para 5 enteros.
      arr = new int[5];
         
      // inicializa el primer elemento del array
      arr[0] = 10;
         
      // inicializa el segundo elemento del array
      arr[1] = 20;
         
      // y así...
      arr[2] = 30;
      arr[3] = 40;
      arr[4] = 50;
         
      // accediendo a los elementos del array
      for (int i = 0; i < arr.length; i++)
         System.out.println("Elemento en el índice " + i + 
                                      " : "+ arr[i]);          
    }
}

Salida:

Elemento en el índice 0 : 10
Elemento en el índice 1 : 20
Elemento en el índice 2 : 30
Elemento en el índice 3 : 40
Elemento en el índice 4 : 50
Nota: También puede acceder a los arrays de Java utilizando el bucle for-each 

2.4. Arrays de objetos

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

Student[] arr = new Student[7]; //student es una clase definida por el usuario

El array Student contiene siete espacios de memoria, cada uno del tamaño de la clase Student, en los que se puede almacenar la dirección de siete objetos de Student. Los objetos de Student deben crearse con el constructor de la clase Student.

Ejemplo:

// Programa Java para ilustrar la creación de
// un array de objetos
 
class Student
{
    public int roll_no;
    public String name;
    Student(int roll_no, String name)
    {
        this.roll_no = roll_no;
        this.name = name;
    }
}
 
// Los elementos del array son objetos de la clase Student
public class DemoArray2
{
    public static void main (String[] args)
    {
        // declara una array de enteros.
        Student[] arr;
 
        // asigna memoria para 5 objetos del tipo Student.
        arr = new Student[5];
 
        // inicializa el primer elemento del array
        arr[0] = new Student(1,"uno");
 
        // inicializa el segundo elemento del array
        arr[1] = new Student(2,"dos");
 
        // y así...
        arr[2] = new Student(3,"tres");
        arr[3] = new Student(4,"cuatro");
        arr[4] = new Student(5,"cinco");
 
        // accediendo a los elementos del array
        for (int i = 0; i < arr.length; i++)
            System.out.println("Elemento en " + i + " : " +
                        arr[i].roll_no +" "+ arr[i].name);
    }
}

Salida:

Elemento en 0 : 1 uno
Elemento en 1 : 2 dos
Elemento en 2 : 3 tres
Elemento en 3 : 4 cuatro
Elemento en 4 : 5 cinco

¿Qué sucede si tratamos de acceder al elemento fuera del tamaño del array?

El compilador arroja ArrayIndexOutOfBoundsException para indicar que se ha accedido al array con un índice ilegal. El índice es negativo, mayor o igual que el tamaño del array.

3. Arrays multidimensionales

Las matrices multidimensionales son matrices de matrices o arrays de arrays, donde cada elemento del array contiene la referencia de otro array. Se crea una matriz multidimensional al agregar un conjunto de corchetes ([]) por dimensión. Ejemplos:

int[][] intArray = new int[10][20]; //un array 2D o matrix
int[][][] intArray = new int[10][20][10]; //una array 3D

Ejemplo:

class multiDimensional
{
    public static void main(String args[])
    {
        // declarar e inicializar array 2D
        int arr[][] = { {2,7,9},{3,6,1},{7,4,2} };
 
        // imprimir array 2D
        for (int i=0; i< 3 ; i++)
        {
            for (int j=0; j < 3 ; j++)
                System.out.print(arr[i][j] + " ");
 
            System.out.println();
        }
    }
}

Salida:

2 7 9 
3 6 1 
7 4 2

3.1. Pasar arrays a métodos

Al igual que las variables, también podemos pasar arrays a los métodos. Por ejemplo, en el programa siguiente se pasa un array al método sum para calcular la suma de los valores del array

Ejemplo:

// Programa Java para demostrar
// el uso de array como parámetro
 
class Test
{   
    // Método principal
    public static void main(String args[]) 
    {
        int arr[] = {3, 1, 2, 5, 4};
         
        // pasar array al método sum
        sum(arr);
     
    }
 
    public static void sum(int[] arr) 
    {
        // obtener suma de valores del array
        int sum = 0;
         
        for (int i = 0; i < arr.length; i++)
            sum+=arr[i];
         
        System.out.println("Suma de valores del array: " + sum);
    }
}

Salida:

Suma de valores del array: 15

3.2. Retornando arrays de métodos

Como de costumbre, un método también puede devolver un array. Por ejemplo, en el siguiente programa se devuelve (return) un array desde el método m1.

Ejemplos:

// Programa Java para demostrar
// el retorno del array de un método
 
class Test
{   
    // Método principal
    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() 
    {
        // retornando  array
        return new int[]{1,2,3};
    }
}

Salida:

1 2 3

3.3. Objectos Class para arrays

Cada array tiene un objeto Class asociado, compartido con todos los demás arrays con el mismo tipo de componente.

Ejemplo:

// Programa Java para demostrar
// Objetos de clase para 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 de 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());
    }
}

Salida:

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

Explicación:

  • La cadena “[I” es la firma de tipo de tiempo de ejecución para el objeto class “array with component type int”.
  • La única superclase directa de cualquier tipo de array es java.lang.Object.
  • La cadena “[B” es la firma de tipo de tiempo de ejecución para el objeto class “array with component type byte”.
  • La cadena “[S” es la firma de tipo de tiempo de ejecución para el objeto class “array with component type short”.
  • La cadena “[L” es la firma de tipo de tiempo de ejecución para el objeto class “array with component type of a Class”. El nombre de la clase es seguido.

3.4. Miembros del Array

Ahora, como ya sabe, los arrays son objetos de una clase y la superclase directa de los arrays es la clase Object. Los miembros de un tipo de array son todos los siguientes:

  • length, que contiene la cantidad de componentes del array, puede ser positiva o cero.
  • Todos los miembros son heredados de la clase Object; el único método de Object que no se hereda es su método de clone.
  • El método público clone(), anula el método de clonación en la clase Object y no arroja excepciones.

4. Arrays irregulares

Cuando asigna memoria para un array multidimensional, necesita especificar solo la memoria para la primera dimensión (más a la izquierda). Puede asignar las dimensiones restantes por separado. Por ejemplo, el siguiente código asigna memoria para la primera dimensión de la tabla cuando se declara. Asigna la segunda dimensión de forma manual.

int tabla[][]= new int [3][]
tabla[0] = new int [4]
tabla[1] = new int [4]
tabla[2] = new int [4]

Aunque no hay ninguna ventaja en la asignación individual de los arrays de segunda dimensión en esta situación, puede haber otras. Por ejemplo, cuando asigna por separado, no necesita asignar la misma cantidad de elementos para cada índice. Como las matrices multidimensionales se implementan como arrays de arrays, la longitud de cada array está bajo su control.

Por ejemplo, suponga que está escribiendo un programa que almacena el número de cursos en una universidad. Suponga que existen 10 cursos al día durante la semana y dos cursos al día los sábados y domingos, puede usar el array Cursos que se muestra en el siguiente programa para almacenar la información.

Observe que la longitud de la segunda dimensión para los primeros cinco índices es 10 y la longitud de la segunda dimensión para los dos últimos índices es 2.
// Asignar manualmente diferentes tamaños a arrays de dimensión dos

class DemoArrayIrregular
{
    public static void main(String args[])
    {
        int cursos[][]=new int[7][];
        cursos[0] = new int[10];
        cursos[1] = new int[10];
        cursos[2] = new int[10];
        cursos[3] = new int[10];
        cursos[4] = new int[10];
        cursos[5] = new int[2];
        cursos[6] = new int[2];

        int i,j;

        for(i=0;i<5;i++)
            for (j=0;j<10;j++)
                cursos[i][j]=j+1;
        for (i=5; i<7;i++)
            for (j=0;j<2;j++)
                cursos[i][j]=j+1;

        System.out.println("Entre Semana");
        System.out.println("------------");
        for(i=0;i<5;i++) {
            System.out.print("Dia "+(i+1)+"°: ");
            for (j = 0; j < 10; j++)
                System.out.print(cursos[i][j] + " ");
            System.out.println();
        }

        System.out.println("\nFin de Semana");
        System.out.println("--------------");
        for (i=5; i<7;i++) {
            System.out.print("Dia "+(i+1)+"°: ");
            for (j=0 ; j<2 ; j++)
                System.out.print(cursos[i][j] + " ");
            System.out.println();
        }
    }
}

Salida:

Entre Semana
------------
Dia 1°: 1 2 3 4 5 6 7 8 9 10 
Dia 2°: 1 2 3 4 5 6 7 8 9 10 
Dia 3°: 1 2 3 4 5 6 7 8 9 10 
Dia 4°: 1 2 3 4 5 6 7 8 9 10 
Dia 5°: 1 2 3 4 5 6 7 8 9 10

Fin de Semana
--------------
Dia 6°: 1 2 
Dia 7°: 1 2

El uso de matrices multidimensionales irregulares (o desiguales) no se recomienda para la mayoría de las aplicaciones, ya que funciona de manera contraria a lo que la gente espera encontrar cuando se encuentra una matriz multidimensional. Sin embargo, las matrices irregulares se pueden usar eficazmente en algunas situaciones.

  Por ejemplo, si necesita una matriz bidimensional muy grande que está escasamente poblada (es decir, una en la que no se usarán todos los elementos), una matriz irregular podría ser una solución perfecta. 

5. Asignación de referencias en Arrays

Al igual que con otros objetos, cuando asigna una variable de referencia de un array a otra, simplemente está cambiando a qué objeto se refiere dicha variable. No está causando que se realice una copia del array, ni hace que el contenido de un array se copie en la otra. Por ejemplo, considere este programa:

// Asignación de variables de referencias en array

class AsignacionArray
{
    public static void main(String args[])
    {
        int i;

        int num1[] = new int[10];
        int num2[] = new int[10];

        for (i=0; i<10 ; i++)
            num1[i]=i;

        for (i=0; i<10 ; i++)
            num2[i]=-i;

        System.out.print("num1: ");
        for (i=0; i<10 ; i++)
            System.out.print(num1[i]  + " ");
        System.out.println();

        System.out.print("num2: ");
        for (i=0; i<10 ; i++)
            System.out.print(num2[i]  + " ");
        System.out.println();

        num2=num1;

        System.out.print("num2 después de la asignación: ");
        for (i=0; i<10 ; i++)
            System.out.print(num2[i]  + " ");
        System.out.println();

        //ahora opera el array num1 a través de num2
        num2[3]=99;

        System.out.print("num1 después de cambiar valor a través de num2: ");
        for (i=0; i<10 ; i++)
            System.out.print(num1[i]  + " ");
        System.out.println();
    }
}



Salida:

num1: 0 1 2 3 4 5 6 7 8 9 
num2: 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 
num2 después de la asignación: 0 1 2 3 4 5 6 7 8 9 
num1 después de cambiar valor a través de num2: 0 1 2 99 4 5 6 7 8 9

Como muestra en el resultado, después de la asignación de nums1 a nums2, ambas variables de referencia del array se refieren al mismo objeto.

6. Clonación de arrays

Cuando clona un array dimensional único, como Object[], se realiza una “copia profunda” con el nuevo array que contiene copias de los elementos del array original en lugar de referencias.

Ejemplo:

// Programa Java para demostrar
// clonación de arrays unidimensionales
 
class Test
{   
    public static void main(String args[]) 
    {
        int intArray[] = {1,2,3};
         
        int cloneArray[] = intArray.clone();
         
        // imprimirá false a medida que se crea una copia profunda
        // para un array unidimensional
        System.out.println(intArray == cloneArray);
         
        for (int i = 0; i < cloneArray.length; i++) {
            System.out.print(cloneArray[i]+" ");
        }
    }
}

Salida:

false
1 2 3

Sin embargo, un clon de una matriz multidimensional (como Object [] []) es una “copia superficial”, lo que quiere decir que crea solo un nuevo array con cada array de elementos como referencia a un array de elementos original, pero los subcampos se comparten.

Ejemplo:

// Programa Java para demostrar
// clonación de matrices multidimensionales
 
class Test
{   
    public static void main(String args[]) 
    {
        int intArray[][] = {{1,2,3},{4,5}};
         
        int cloneArray[][] = intArray.clone();
         
        // imprimirá false
        System.out.println(intArray == cloneArray);
         
        // se imprimirá true a medida que se crea una copia poco profunda
        // es decir, sub-arrays son compartidos
        System.out.println(intArray[0] == cloneArray[0]);
        System.out.println(intArray[1] == cloneArray[1]);
         
    }
}

Salida:

false
true
true

7. Uso de length en Arrays

Debido a que los arreglos se implementan como objetos, cada array tiene asociado una variable de instancia de longitud (length) que contiene la cantidad de elementos que el array puede contener. (En otras palabras, length contiene el tamaño del array.) Aquí hay un programa que demuestra esta propiedad:

// Demostrando el uso de length en Arrays
class DemoArray
{
    public static void main(String args[])
    {
        int lista[]= new int [10];
        int num[]={1,2,3};
        int tabla[][]={
                {1,2,3},
                {4,5},
                {6,7,8,9}
        };

        System.out.println("Longitud de lista: "+lista.length);
        System.out.println("Longitud de num: " +num.length);
        System.out.println("Longitud de tabla: "+tabla.length);
        System.out.println("Longitud de tabla[0]: " +tabla[0].length);
        System.out.println("Longitud de tabla[1]: " +tabla[1].length);
        System.out.println("Longitud de tabla[2]: " +tabla[2].length);

        //Usando length para inicializar lista
        for (int i=0; i < lista.length; i++)
            lista[i]=i*i;

        System.out.print("La lista es: ");
        //Ahora usamos length para mostrar lista

        for (int i=0; i < lista.length; i++)
            System.out.print(lista[i]+ " ");
        System.out.println();


    }
}


Salida:

Longitud de lista: 10
Longitud de num: 3
Longitud de tabla: 3
Longitud de tabla[0]: 3
Longitud de tabla[1]: 2
Longitud de tabla[2]: 4
La lista es: 0 1 4 9 16 25 36 49 64 81
Arrays en Java
  • Matrices unidemensionales
  • Matrices multidimensionales

Sobre el Autor:

Hey hola! Yo soy Alex Walton y tengo el placer de compartir conocimientos hacía ti sobre el tema de Programación en Java, desde cero, Online y Gratis.

1 comentario

  1. jose daniel

    hola tengo una pregunta como hago para nombrar cuando en la posición de matriz o arrays [0] y que aparezca por ejemplo enero y que imprima [0]enero=1
    [1]febrero=2

    y asi sucesivamente

Deja una Respuesta

*

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.