Arrays en Java

Una array en Java es un grupo de variables del mismo tipo a las que se hace referencia con un nombre común. Las arrays en Java funcionan de manera diferente a como lo hacen en C/C++. Los siguientes son algunos puntos importantes sobre las arrays de Java. 

• En Java, todas las arrays se asignan dinámicamente. (se discute más adelante)
• Las arrays se almacenan en la memoria contagiosa [ubicaciones de memoria consecutivas].
• Dado que los arreglos son objetos en Java, podemos encontrar su longitud usando la propiedad de objeto length . Esto es diferente de C/C++, donde encontramos la longitud usando sizeof.
• Una variable de array de Java también se puede declarar como otras variables con [] después del tipo de datos.
• Las variables en la array están ordenadas y cada una tiene un índice que comienza en 0.
• La array de 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 una array debe especificarse por valor int o corto y no largo.
• La superclase directa de un tipo de array es Object .
• Cada tipo de array implementa las interfaces Cloneable y java.io.Serializable . 
• Este almacenamiento de arrays nos ayuda a acceder aleatoriamente a los elementos de una array [Admite acceso aleatorio].
• El tamaño de la array no se puede modificar (una vez inicializado). Sin embargo, se puede hacer que una referencia de array apunte a otra array.

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

Creación, inicialización y acceso a una array

Arrays unidimensionales: 

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

type var-name[];
OR
type[] var-name;

Una declaración de array tiene dos componentes: el tipo y el nombre. type declara el tipo de elemento de la array. El tipo de elemento determina el tipo de datos de cada elemento que comprende la array. Al igual que una array de enteros, también podemos crear una array 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 array determina qué tipo de datos contendrá la array. 

Ejemplo: 

// both are valid declarations
int intArray[]; 
or int[] intArray; 

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

// an array of references to objects of
// the class MyClass (a class created by
// user)
MyClass myClassArray[]; 

Object[]  ao,        // array of Object
Collection[] ca;  // array of Collection
                     // of unknown type

Aunque la primera declaración establece que intArray es una variable de array, no existe una array real . Simplemente le dice al compilador que esta variable (intArray) contendrá una array del tipo entero. Para vincular intArray con una array física real de números enteros, debe asignar uno usando new y asignarlo a intArray. 

Instanciando una array en Java

Cuando se declara una array, solo se crea una referencia de una array. Para crear o dar memoria a la array, cree una array como esta: La forma general de new , tal como se aplica a las arrays unidimensionales, aparece de la siguiente manera: 

var-name = new type [size];

Aquí, el tipo especifica el tipo de datos que se asignan, el tamaño determina la cantidad de elementos en la array y var-name es el nombre de la variable de la array que está vinculada a la array. Para usar new para asignar una array, debe especificar el tipo y la cantidad de elementos para asignar.

Ejemplo: 

int intArray[];    //declaring array
intArray = new int[20];  // allocating memory to array

O 

int[] intArray = new int[20]; // combining both statements in one

Nota : 

1. Los elementos de la array asignados por new se inicializarán automáticamente en cero (para tipos numéricos), falso (para booleanos) o nulo (para tipos de referencia). Consulte los valores de array predeterminados en Java .
2. La obtención de una array es un proceso de dos pasos. Primero, debe declarar una variable del tipo de array deseado. En segundo lugar, debe asignar la memoria para contener la array, utilizando new, y asignarla a la variable de array. Por lo tanto, en Java , todas las arrays se asignan dinámicamente.

Literal de array

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

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

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

Acceder a los elementos de array de Java usando for Loop

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

 // accessing the elements of the specified array
for (int i = 0; i < arr.length; i++)
  System.out.println("Element at index " + i + 
                                " : "+ arr[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 temporal: O(n)
Espacio auxiliar: O(1)

También puede acceder a las arrays de Java usando for each loops . 

Arrays de objetos

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

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

StudentArray contiene siete espacios de memoria, cada uno del tamaño de la clase de estudiante, en los que se pueden almacenar las direcciones de siete objetos de Estudiante. Los objetos Student deben instanciarse utilizando el constructor de la clase Student, y sus referencias deben asignarse a los elementos de la array de la siguiente manera. 

Student[] arr = new Student[5];

Ejemplo

// 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 integers.
        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 temporal: O(n)
Espacio auxiliar: O(1)

Ejemplo

Una array de objetos también se crea como una array de elementos de datos de tipo primitivo. 

Student[] studentArray; // No array created

Student[] studentArray = new Student[5]; // Array of 5 students created but No students are there in the array

StudentArray contiene cinco espacios de memoria, cada uno del tamaño de la clase de estudiante, en los que se pueden almacenar las direcciones de siete objetos de Estudiante. Los objetos Student deben instanciarse utilizando el constructor de la clase Student, y sus referencias deben asignarse a los elementos de la array de la siguiente manera. 

// 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")}; // Array of 5 students created but No students are there in the array
    
        // 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 array?

JVM lanza ArrayIndexOutOfBoundsException para indicar que se ha accedido a la array con un índice ilegal. El índice es negativo o mayor o igual que el tamaño de una 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

Arrays multidimensionales:

Las arrays multidimensionales son arrays de arrays en las que cada elemento de la array contiene la referencia de otras arrays. Estos también se conocen como arreglos irregulares . Una array multidimensional se crea agregando un conjunto de corchetes ([]) por dimensión. 

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

Ejemplo

public class multiDimensional {
    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 arrays a métodos

Al igual que las variables, también podemos pasar arrays a métodos. Por ejemplo, el siguiente programa pasa la array al método sum para calcular la suma de los valores de la 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

Complejidad de tiempo: O(n)

Espacio Auxiliar : O(1)

Devolución de arrays desde métodos

Como de costumbre, un método también puede devolver una array. Por ejemplo, el siguiente programa devuelve una array 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 de tiempo: O(n), 
Espacio auxiliar: O(1)

Objetos de clase para arrays

Cada array tiene un objeto Clase asociado, compartido con todas las demás arrays 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: 

1. La string «[I» es la firma de tipo en tiempo de ejecución para el objeto de clase «array con tipo de componente int «.
2. La única superclase directa de un tipo de array es java.lang.Object .
3. La string «[B» es la firma de tipo en tiempo de ejecución para el objeto de clase «array con byte de tipo de componente «.
4. La string «[S» es la firma de tipo en tiempo de ejecución para el objeto de clase «array con tipo de componente corto «.
5. La string «[L» es la firma de tipo en tiempo de ejecución para el objeto de clase «array con tipo de componente de una clase». Luego se sigue el nombre de la clase.

Miembros de la array

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

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

Tipos de arreglos y sus tipos de elementos permitidos

Clonación de arreglos

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

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

 Sin embargo, un clon de una array multidimensional (como Object[][]) es una «copia superficial», lo que quiere decir que crea solo una nueva array con cada array de elementos como referencia a una array de elementos original, pero se comparten los subarreglos. 

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

Artículos relacionados: 

• Array irregular en Java
• Bucle for-each en Java
• Clase de arrays en Java

Este artículo es una contribución de Nitsdheerendra y Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.