Java Language
Arrays

Introducción

Sintaxis

• ArrayType[] myArray; // Declarando matrices
• ArrayType myArray[]; // Otra sintaxis válida (menos utilizada y desaconsejada)
• ArrayType[][][] myArray; // Declaración de matrices irregulares multidimensionales (repetición [] s)
• ArrayType myVar = myArray[index]; // Elemento de acceso (lectura) en el índice
• myArray[index] = value; // Asignar valor al index de posición de la matriz
• ArrayType[] myArray = new ArrayType[arrayLength]; // Sintaxis de inicialización de matriz
• int[] ints = {1, 2, 3}; // Sintaxis de inicialización de la matriz con los valores proporcionados, la longitud se deduce del número de valores proporcionados: {[valor1 [, valor2] *]}
• new int[]{4, -5, 6} // Can be used as argument, without a local variable
• int[] ints = new int[3]; // same as {0, 0, 0}
• int[][] ints = {{1, 2}, {3}, null}; // Inicialización de matriz multidimensional. int [] extiende Object (y también lo hace anyType []), por lo que null es un valor válido.

Parámetros

Creación e inicialización de matrices

Casos basicos

int[]   numbers1 = new int[3];                 // Array for 3 int values, default value is 0
int[]   numbers2 = { 1, 2, 3 };                // Array literal of 3 int values
int[]   numbers3 = new int[] { 1, 2, 3 };      // Array of 3 int values initialized
int[][] numbers4 = { { 1, 2 }, { 3, 4, 5 } };  // Jagged array literal
int[][] numbers5 = new int[5][];               // Jagged array, one dimension 5 long
int[][] numbers6 = new int[5][4];              // Multidimensional array: 5x4

Las matrices se pueden crear utilizando cualquier tipo de referencia o primitivo.

float[]  boats = new float[5];          // Array of five 32-bit floating point numbers.
double[] header = new double[] { 4.56, 332.267, 7.0, 0.3367, 10.0 };
                                       // Array of five 64-bit floating point numbers.
String[] theory = new String[] { "a", "b", "c" };
                                       // Array of three strings (reference type).
Object[] dArt = new Object[] { new Object(), "We love Stack Overflow.", new Integer(3) };
                                       // Array of three Objects (reference type).

Para el último ejemplo, tenga en cuenta que los subtipos del tipo de matriz declarada están permitidos en la matriz.

Las matrices para tipos definidos por el usuario también pueden construirse de manera similar a los tipos primitivos

UserDefinedClass[] udType = new UserDefinedClass[5];

Arrays, colecciones y corrientes

// Parameters require objects, not primitives

// Auto-boxing happening for int 127 here
Integer[]       initial        = { 127, Integer.valueOf( 42 ) };
List<Integer>   toList         = Arrays.asList( initial );  // Fixed size! 

// Note: Works with all collections
Integer[]       fromCollection = toList.toArray( new Integer[toList.size()] );

//Java doesn't allow you to create an array of a parameterized type
List<String>[]  list = new ArrayList<String>[2];  // Compilation error!

// Streams - JDK 8+
Stream<Integer> toStream       = Arrays.stream( initial );
Integer[]       fromStream     = toStream.toArray( Integer[]::new );

Introducción

Una matriz es una estructura de datos que contiene un número fijo de valores primitivos o referencias a instancias de objetos.

Cada elemento de una matriz se denomina elemento, y se accede a cada elemento por su índice numérico. La longitud de una matriz se establece cuando se crea la matriz:

int size = 42;
int[] array = new int[size];

El tamaño de una matriz se fija en el tiempo de ejecución cuando se inicializa. No se puede cambiar después de la inicialización. Si el tamaño debe ser mutable en el tiempo de ejecución, se debe usar una clase de Collection como ArrayList su lugar. ArrayList almacena elementos en una matriz y admite el cambio de tamaño asignando una nueva matriz y copiando elementos de la matriz antigua.

Si la matriz es de un tipo primitivo, es decir

int[] array1 = { 1,2,3 };
int[] array2 = new int[10];

Los valores se almacenan en la propia matriz. En ausencia de un inicializador (como en la array2 anterior), el valor predeterminado asignado a cada elemento es 0 (cero).

Si el tipo de matriz es una referencia de objeto, como en

SomeClassOrInterface[] array = new SomeClassOrInterface[10];

entonces la matriz contiene referencias a objetos de tipo SomeClassOrInterface . Esas referencias pueden referirse a una instancia de SomeClassOrInterface o cualquier subclase (para clases) o clase de implementación (para interfaces) de SomeClassOrInterface . Si la declaración de la matriz no tiene inicializador, el valor predeterminado de null se asigna a cada elemento.

Debido a que todas las matrices están int indexadas, el tamaño de una matriz debe ser especificado por una int . El tamaño de la matriz no se puede especificar como un long :

long size = 23L;
int[] array = new int[size]; // Compile-time error:
                             // incompatible types: possible lossy conversion from
                             // long to int

Las matrices utilizan un sistema de índice de base cero , lo que significa que la indexación comienza en 0 y termina en length - 1 .

Por ejemplo, la siguiente imagen representa una matriz con tamaño 10 . Aquí, el primer elemento está en el índice 0 y el último elemento está en el índice 9 , en lugar de que el primer elemento esté en el índice 1 y el último elemento en el índice 10 (consulte la figura a continuación).

Los accesos a elementos de matrices se realizan en tiempo constante . Eso significa que acceder al primer elemento de la matriz tiene el mismo costo (en el tiempo) de acceder al segundo elemento, al tercer elemento y así sucesivamente.

Java ofrece varias formas de definir e inicializar matrices, incluidas las notaciones literales y de constructor . Al declarar matrices utilizando el new Type[length] constructor new Type[length] , cada elemento se inicializará con los siguientes valores predeterminados:

• 0 para tipos numéricos primitivos : byte , short , int , long , float y double .
• '\u0000' (carácter nulo) para el tipo char .
• false para el tipo boolean .
• null para los tipos de referencia .

Creación e inicialización de matrices de tipos primitivos.

int[] array1 = new int[] { 1, 2, 3 }; // Create an array with new operator and 
                                      // array initializer.
int[] array2 = { 1, 2, 3 };           // Shortcut syntax with array initializer.
int[] array3 = new int[3];            // Equivalent to { 0, 0, 0 }
int[] array4 = null;                  // The array itself is an object, so it
                                      // can be set as null.

Al declarar una matriz, [] aparecerá como parte del tipo al comienzo de la declaración (después del nombre del tipo), o como parte del declarador para una variable en particular (después del nombre de la variable), o ambos:

int array5[];       /* equivalent to */  int[] array5;
int a, b[], c[][];  /* equivalent to */  int a; int[] b; int[][] c;
int[] a, b[];       /* equivalent to */  int[] a; int[][] b;
int a, []b, c[][];  /* Compilation Error, because [] is not part of the type at beginning
                       of the declaration, rather it is before 'b'. */    
// The same rules apply when declaring a method that returns an array:
int foo()[] { ... } /* equivalent to */  int[] foo() { ... }

En el siguiente ejemplo, ambas declaraciones son correctas y pueden compilarse y ejecutarse sin ningún problema. Sin embargo, tanto la Convención de codificación de Java como la Guía de estilo de Google Java desalientan el formulario entre corchetes después del nombre de la variable: los corchetes identifican el tipo de matriz y deben aparecer con la designación de tipo . Lo mismo se debe utilizar para las firmas de retorno de método.

float array[]; /* and */ int foo()[] { ... } /* are discouraged */
float[] array; /* and */ int[] foo() { ... } /* are encouraged */

El tipo desalentado está pensado para adaptarse a los usuarios de C en transición , que están familiarizados con la sintaxis de C que tiene los corchetes después del nombre de la variable.

En Java, es posible tener matrices de tamaño 0 :

int[] array = new int[0]; // Compiles and runs fine.
int[] array2 = {};        // Equivalent syntax.

Sin embargo, como se trata de una matriz vacía, no se pueden leer ni asignar elementos de ella:

array[0] = 1;     // Throws java.lang.ArrayIndexOutOfBoundsException.
int i = array2[0]; // Also throws ArrayIndexOutOfBoundsException.

Estas matrices vacías suelen ser útiles como valores de retorno, por lo que el código de llamada solo tiene que preocuparse de tratar con una matriz, en lugar de un valor null potencial que puede llevar a una NullPointerException .

La longitud de una matriz debe ser un entero no negativo:

int[] array = new int[-1]; // Throws java.lang.NegativeArraySizeException

El tamaño de la matriz se puede determinar utilizando un campo final público llamado length :

System.out.println(array.length); // Prints 0 in this case.

Nota : array.length devuelve el tamaño real de la matriz y no el número de elementos de la matriz a los que se asignó un valor, a diferencia de ArrayList.size() que devuelve la cantidad de elementos de la matriz a los que se asignó un valor.

Creando e inicializando arrays multidimensionales.

La forma más sencilla de crear una matriz multidimensional es la siguiente:

int[][] a = new int[2][3];

Creará dos matrices int tres longitudes: a[0] y a[1] . Esto es muy similar a la inicialización clásica de estilo C de matrices multidimensionales rectangulares.

Puedes crear e inicializar al mismo tiempo:

int[][] a = { {1, 2}, {3, 4}, {5, 6} };

A diferencia de C , donde solo se admiten matrices multidimensionales rectangulares, las matrices internas no tienen que ser de la misma longitud, ni siquiera definidas:

int[][] a = { {1}, {2, 3}, null };

Aquí, a[0] es una matriz int una longitud, mientras que a[1] es una matriz int dos longitudes y a[2] es null . Las matrices de este tipo se denominan matrices irregulares o matrices irregulares , es decir, son matrices de matrices. Las matrices multidimensionales en Java se implementan como matrices de matrices, es decir, array[i][j][k] es equivalente a ((array[i])[j])[k] . A diferencia de C # , la array[i,j] sintaxis array[i,j] no es compatible con Java.

Representación de matriz multidimensional en Java

Fuente - Live en Ideone

Creación e inicialización de matrices de tipos de referencia

String[] array6 = new String[] { "Laurel", "Hardy" }; // Create an array with new 
                                                      // operator and array initializer.
String[] array7 = { "Laurel", "Hardy" };              // Shortcut syntax with array 
                                                      // initializer.
String[] array8 = new String[3];                      // { null, null, null }
String[] array9 = null;                               // null

Vivir en Ideone

Además de los String literales y primitivas mostradas anteriormente, la sintaxis de acceso directo para array de inicialización también trabaja con canónicas Object tipos:

Object[] array10 = { new Object(), new Object() };

Debido a que las matrices son covariantes, una matriz de tipo de referencia se puede inicializar como una matriz de una subclase, aunque se ArrayStoreException una ArrayStoreException si intenta establecer un elemento en algo diferente a una String :

Object[] array11 = new String[] { "foo", "bar", "baz" };
array11[1] = "qux"; // fine
array11[1] = new StringBuilder(); // throws ArrayStoreException

La sintaxis de acceso directo no se puede usar para esto porque la sintaxis de acceso directo tendría un tipo implícito de Object[] .

Una matriz se puede inicializar con cero elementos utilizando String[] emptyArray = new String[0] . Por ejemplo, una matriz con una longitud cero como esta se usa para crear una Array partir de una Collection cuando el método necesita el tipo de tiempo de ejecución de un objeto.

Tanto en los tipos primitivos como en los de referencia, una inicialización de matriz vacía (por ejemplo, String[] array8 = new String[3] ) inicializará la matriz con el valor predeterminado para cada tipo de datos .

Creando e inicializando arrays genéricos

En las clases genéricas, las matrices de tipos genéricos no se pueden inicializar de esta manera debido al borrado de tipos :

public class MyGenericClass<T> {
    private T[] a;

    public MyGenericClass() {
        a = new T[5]; // Compile time error: generic array creation
    }
}

En su lugar, se pueden crear utilizando uno de los siguientes métodos: (tenga en cuenta que estos generarán advertencias sin marcar)

1. Al crear una matriz de Object y convertirla en el tipo genérico:

   a = (T[]) new Object[5];
   

   Este es el método más simple, pero como la matriz subyacente aún es del tipo Object[] , este método no proporciona seguridad de tipo. Por lo tanto, este método de crear una matriz se usa mejor solo dentro de la clase genérica, no se expone públicamente.

2. Al usar Array.newInstance con un parámetro de clase:

   public MyGenericClass(Class<T> clazz) {
       a = (T[]) Array.newInstance(clazz, 5);
   }
   

   Aquí la clase de T tiene que pasarse explícitamente al constructor. El tipo de retorno de Array.newInstance es siempre Object . Sin embargo, este método es más seguro porque la matriz recién creada siempre es del tipo T[] y, por lo tanto, se puede externalizar de manera segura.

Rellenar una matriz después de la inicialización

Arrays.fill(array8, "abc");        // { "abc", "abc", "abc" }

Arrays.fill(array8, 1, 2, "aaa");  // Placing "aaa" from index 1 to 2.

int[] array = new int[5];
Arrays.setAll(array, i -> i); // The array becomes { 0, 1, 2, 3, 4 }.

Declaración separada e inicialización de matrices.

El valor de un índice para un elemento de matriz debe ser un número entero (0, 1, 2, 3, 4, ...) y menor que la longitud de la matriz (los índices se basan en cero). De lo contrario, se lanzará una ArrayIndexOutOfBoundsException :

int[] array9;             // Array declaration - uninitialized
array9 = new int[3];      // Initialize array  - { 0, 0, 0 }
array9[0] = 10;           // Set index 0 value - { 10, 0, 0 }
array9[1] = 20;           // Set index 1 value - { 10, 20, 0 }
array9[2] = 30;           // Set index 2 value - { 10, 20, 30 }

Es posible que las matrices no se puedan reinicializar con la sintaxis de acceso directo del inicializador de matriz

No es posible reinicializar una matriz a través de una sintaxis de acceso directo con un inicializador de matriz, ya que un inicializador de matriz solo se puede especificar en una declaración de campo o declaración de variable local, o como parte de una expresión de creación de matriz.

Sin embargo, es posible crear una nueva matriz y asignarla a la variable que se utiliza para hacer referencia a la antigua matriz. Si bien esto hace que la matriz referenciada por esa variable se reinicialice, el contenido de la variable es una matriz completamente nueva. Para hacer esto, el new operador se puede usar con un inicializador de matriz y asignarse a la variable de matriz:

// First initialization of array
int[] array = new int[] { 1, 2, 3 };

// Prints "1 2 3 ".
for (int i : array) {
    System.out.print(i + " ");
}

// Re-initializes array to a new int[] array.
array = new int[] { 4, 5, 6 };

// Prints "4 5 6 ".
for (int i : array) {
    System.out.print(i + " ");
}

array = { 1, 2, 3, 4 }; // Compile-time error! Can't re-initialize an array via shortcut 
                        // syntax with array initializer.

Vivir en Ideone

Creando una matriz de una colección

Dos métodos en java.util.Collection crean una matriz de una colección:

• Object[] toArray()

• <T> T[] toArray(T[] a)

Object[] toArray() se puede utilizar de la siguiente manera:

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// although set is a Set<String>, toArray() returns an Object[] not a String[]
Object[] objectArray = set.toArray();

<T> T[] toArray(T[] a) se puede utilizar de la siguiente manera:

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// The array does not need to be created up front with the correct size.
// Only the array type matters. (If the size is wrong, a new array will
// be created with the same type.)
String[] stringArray = set.toArray(new String[0]);  

// If you supply an array of the same size as collection or bigger, it
// will be populated with collection values and returned (new array
// won't be allocated)
String[] stringArray2 = set.toArray(new String[set.size()]);

La diferencia entre ellos es más que tener resultados tipificados frente a los no tipificados. Su rendimiento también puede diferir (para más detalles, lea esta sección de análisis de rendimiento ):

• Object[] toArray() utiliza una arraycopy vectorizada, que es mucho más rápida que la arraycopy comprobación de arraycopy utilizada en T[] toArray(T[] a) .
• T[] toArray(new T[non-zero-size]) necesita poner a cero la matriz en el tiempo de ejecución, mientras que T[] toArray(new T[0]) no. Tal evitación hace que la última llamada sea más rápida que la anterior. Análisis detallado aquí: Arrays of Wisdom of the Ancients .

String[] strings = list.stream().toArray(String[]::new);

Ejemplos tomados de dos respuestas ( 1 , 2 ) a Convertir 'ArrayList a' String [] 'en Java en desbordamiento de pila.

Arrays a una cadena

int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr));      // [1, 2, 3, 4, 5]

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
System.out.println(Arrays.deepToString(arr));  // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

public class Cat { /* implicitly extends Object */
    @Override
    public String toString() {
      return "CAT!";
    }
}

Cat[] arr = { new Cat(), new Cat() };
System.out.println(Arrays.toString(arr));        // [CAT!, CAT!]

public class Dog {
    /* implicitly extends Object */
}

Dog[] arr = { new Dog() };
System.out.println(Arrays.toString(arr));        // [Dog@17ed40e0]

Creación de una lista a partir de una matriz

El método Arrays.asList() se puede usar para devolver una List tamaño fijo que contiene los elementos de la matriz dada. La List resultante será del mismo tipo de parámetro que el tipo base de la matriz.

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = Arrays.asList(stringArray);

Nota : esta lista está respaldada por ( una vista de) la matriz original, lo que significa que cualquier cambio en la lista cambiará la matriz y viceversa. Sin embargo, los cambios en la lista que cambiarían su tamaño (y por lo tanto la longitud de la matriz) generarán una excepción.

Para crear una copia de la lista, use el constructor de java.util.ArrayList tomando una Collection como un argumento:

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<String>(Arrays.asList(stringArray));

// Using Arrays.asList()

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));

// Using ArrayList.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList(stringArray));

// Using Collections.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, stringArray);

// Using Streams

int[] ints = {1, 2, 3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

String[] stringArray = {"foo", "bar", "baz"};
List<Object> list = Arrays.stream(stringArray).collect(Collectors.toList());

Notas importantes relacionadas con el uso del método Arrays.asList ()

• Este método devuelve List , que es una instancia de Arrays$ArrayList (clase interna estática de Arrays ) y no java.util.ArrayList . La List resultante es de tamaño fijo. Eso significa que agregar o quitar elementos no es compatible y emitirá una UnsupportedOperationException :

  stringList.add("something"); // throws java.lang.UnsupportedOperationException
  

• Se puede crear una nueva List pasando una List respaldada por una matriz al constructor de una Nueva List . Esto crea una nueva copia de los datos, que tiene un tamaño variable y que no está respaldado por la matriz original:

  List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));
  

• Llamar a <T> List<T> asList(T... a) en una matriz primitiva, como int[] , producirá una List<int[]> cuyo único elemento es la matriz primitiva de origen en lugar de los elementos reales de la matriz de origen.

  El motivo de este comportamiento es que los tipos primitivos no pueden utilizarse en lugar de los parámetros de tipo genérico, por lo que la matriz primitiva completa reemplaza el parámetro de tipo genérico en este caso. Para convertir una matriz primitiva en una List , en primer lugar, convierta la matriz primitiva en una matriz del tipo de envoltura correspondiente (es decir, llame a Arrays.asList en un Integer[] lugar de a int[] ).

  Por lo tanto, esto imprimirá false :

  int[] arr = {1, 2, 3};      // primitive array of int
  System.out.println(Arrays.asList(arr).contains(1));
  

  Ver demostración

  Por otro lado, esto se imprimirá true :

  Integer[] arr = {1, 2, 3};  // object array of Integer (wrapper for int)
  System.out.println(Arrays.asList(arr).contains(1));
  

  Ver demostración

  Esto también se imprimirá true , porque la matriz se interpretará como un Integer[] ):

  System.out.println(Arrays.asList(1,2,3).contains(1));
  

  Ver demostración

Matrices multidimensionales y dentadas

Es posible definir una matriz con más de una dimensión. En lugar de acceder al proporcionar un índice único, se accede a una matriz multidimensional especificando un índice para cada dimensión.

La declaración de matriz multidimensional se puede hacer agregando [] para cada dimensión a una decoración de matriz regular. Por ejemplo, para hacer una matriz int bidimensional, agregue otro conjunto de corchetes a la declaración, como int[][] . Esto continúa para matrices tridimensionales ( int[][][] ) y así sucesivamente.

Para definir una matriz bidimensional con tres filas y tres columnas:

int rows = 3;
int columns = 3;
int[][] table = new int[rows][columns];

La matriz se puede indexar y asignarle valores con esta construcción. Tenga en cuenta que los valores no asignados son los valores predeterminados para el tipo de una matriz, en este caso 0 para int .

table[0][0] = 0;
table[0][1] = 1;
table[0][2] = 2;

También es posible crear una instancia de una dimensión a la vez, e incluso hacer matrices no rectangulares. Estos se conocen más comúnmente como matrices dentadas .

int[][] nonRect = new int[4][];

Es importante tener en cuenta que aunque es posible definir cualquier dimensión de la matriz dentada, se debe definir su nivel anterior.

// valid
String[][] employeeGraph = new String[30][];

// invalid
int[][] unshapenMatrix = new int[][10];

// also invalid
int[][][] misshapenGrid = new int[100][][10];

Cómo se representan los arreglos multidimensionales en Java

^{Fuente de la imagen: http://math.hws.edu/eck/cs124/javanotes3/c8/s5.html}

Intialización literal de matriz dentada

Las matrices multidimensionales y matrices irregulares también se pueden inicializar con una expresión literal. Lo siguiente declara y llena una matriz int 2x3:

int[][] table = {
    {1, 2, 3},
    {4, 5, 6}
};

Nota : los subarreglos irregulares también pueden ser null . Por ejemplo, el siguiente código declara y llena una matriz int bidimensional cuyo primer subarreglo es null , el segundo subarreglo es de longitud cero, el tercer subarreglo es de una longitud y el último subarreglo es una matriz de dos longitudes:

int[][] table = {
    null,
    {},
    {1},
    {1,2}
};

Para matrices multidimensionales es posible extraer matrices de dimensión de nivel inferior por sus índices:

int[][][] arr = new int[3][3][3];
int[][] arr1 = arr[0]; // get first 3x3-dimensional array from arr
int[] arr2 = arr1[0]; // get first 3-dimensional array from arr1
int[] arr3 = arr[0]; // error: cannot convert from int[][] to int[]

ArrayIndexOutOfBoundsException

La ArrayIndexOutOfBoundsException produce cuando se accede a un índice no existente de una matriz.

Las matrices están indexadas en base a cero, por lo que el índice del primer elemento es 0 y el índice del último elemento es la capacidad de la matriz menos 1 (es decir, array.length - 1 ).

Por lo tanto, cualquier solicitud de un elemento de matriz por el índice i tiene que satisfacer la condición 0 <= i < array.length , de lo contrario se ArrayIndexOutOfBoundsException la ArrayIndexOutOfBoundsException .

El siguiente código es un ejemplo simple donde se lanza una ArrayIndexOutOfBoundsException .

String[] people = new String[] { "Carol", "Andy" };

// An array will be created:
// people[0]: "Carol"
// people[1]: "Andy"

// Notice: no item on index 2. Trying to access it triggers the exception:
System.out.println(people[2]);  // throws an ArrayIndexOutOfBoundsException.

Salida:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at your.package.path.method(YourClass.java:15)

Tenga en cuenta que el índice ilegal al que se accede también se incluye en la excepción ( 2 en el ejemplo); esta información podría ser útil para encontrar la causa de la excepción.

Para evitar esto, simplemente verifique que el índice esté dentro de los límites de la matriz:

int index = 2;
if (index >= 0 && index < people.length) {
    System.out.println(people[index]);
} 

Obtener la longitud de una matriz

Las matrices son objetos que proporcionan espacio para almacenar hasta su tamaño de elementos del tipo especificado. El tamaño de una matriz no se puede modificar después de crear la matriz.

int[] arr1 = new int[0];
int[] arr2 = new int[2];
int[] arr3 = new int[]{1, 2, 3, 4};
int[] arr4 = {1, 2, 3, 4, 5, 6, 7};

int len1 = arr1.length; // 0
int len2 = arr2.length; // 2
int len3 = arr3.length; // 4
int len4 = arr4.length; // 7

El campo de length en una matriz almacena el tamaño de una matriz. Es un campo final y no puede ser modificado.

Este código muestra la diferencia entre la length de una matriz y la cantidad de objetos que almacena una matriz.

public static void main(String[] args) {
    Integer arr[] = new Integer[] {1,2,3,null,5,null,7,null,null,null,11,null,13};

    int arrayLength = arr.length;
    int nonEmptyElementsCount = 0;

    for (int i=0; i<arrayLength; i++) {
        Integer arrElt = arr[i];
        if (arrElt != null) {
            nonEmptyElementsCount++;
        }
    }

    System.out.println("Array 'arr' has a length of "+arrayLength+"\n"
                            + "and it contains "+nonEmptyElementsCount+" non-empty values");
}

Resultado:

Array 'arr' has a length of 13
and it contains 7 non-empty values

Comparando matrices para la igualdad

Los tipos de arreglos heredan las implementaciones de equals() (y hashCode() ) de java.lang.Object , por lo que equals() solo devolverá true cuando se compare con el mismo objeto de arreglo. Para comparar arreglos de igualdad en función de sus valores, use java.util.Arrays.equals , que está sobrecargado para todos los tipos de arreglos.

int[] a = new int[]{1, 2, 3};
int[] b = new int[]{1, 2, 3};
System.out.println(a.equals(b)); //prints "false" because a and b refer to different objects
System.out.println(Arrays.equals(a, b)); //prints "true" because the elements of a and b have the same values

Cuando el tipo de elemento es un tipo de referencia, Arrays.equals() llama a equals() en los elementos de la matriz para determinar la igualdad. En particular, si el tipo de elemento es en sí mismo un tipo de matriz, se utilizará la comparación de identidad. Para comparar matrices multidimensionales para la igualdad, use Arrays.deepEquals() lugar como se muestra a continuación:

int a[] = { 1, 2, 3 };
int b[] = { 1, 2, 3 };

Object[] aObject = { a }; // aObject contains one element
Object[] bObject = { b }; // bObject contains one element

System.out.println(Arrays.equals(aObject, bObject)); // false
System.out.println(Arrays.deepEquals(aObject, bObject));// true

Debido a que los conjuntos y mapas utilizan equals() y hashCode() , los arreglos generalmente no son útiles como elementos de conjunto o claves de mapa. hashCode() en una clase auxiliar que implemente equals() y hashCode() en términos de los elementos de la matriz, o hashCode() a instancias de List y almacene las listas.

Arreglos para transmitir

String[] arr = new String[] {"str1", "str2", "str3"};
Stream<String> stream = Arrays.stream(arr);

int[] intArr = {1, 2, 3};
IntStream intStream = Arrays.stream(intArr);

int[] values = {1, 2, 3, 4};
IntStream intStream = Arrays.stream(values, 2, 4);

Stream<Integer> intStream = Stream.of(1, 2, 3);
Stream<String> stringStream = Stream.of("1", "2", "3");
Stream<Double> doubleStream = Stream.of(new Double[]{1.0, 2.0});

Iterando sobre matrices

Puede iterar sobre matrices usando un bucle mejorado para (también conocido como foreach) o usando índices de matrices:

int[] array = new int[10];

// using indices: read and write
for (int i = 0; i < array.length; i++) {
    array[i] = i;
}

// extended for: read only
for (int e : array) {
    System.out.println(e);
}

Vale la pena señalar aquí que no hay una forma directa de usar un iterador en un Array, pero a través de la biblioteca de Arrays se puede convertir fácilmente en una lista para obtener un objeto Iterable .

Para arrays en caja use Arrays.asList :

Integer[] boxed = {1, 2, 3};
Iterable<Integer> boxedIt = Arrays.asList(boxed); // list-backed iterable
Iterator<Integer> fromBoxed1 = boxedIt.iterator();

Para matrices primitivas (usando java 8) use flujos (específicamente en este ejemplo - Arrays.stream -> IntStream ):

int[] primitives = {1, 2, 3};
IntStream primitiveStream = Arrays.stream(primitives); // list-backed iterable
PrimitiveIterator.OfInt fromPrimitive1 = primitiveStream.iterator();

Si no puede usar secuencias (no java 8), puede elegir usar la biblioteca de guayabas de google:

Iterable<Integer> fromPrimitive2 = Ints.asList(primitives);

En arreglos bidimensionales o más, ambas técnicas pueden usarse de una manera un poco más compleja.

Ejemplo:

int[][] array = new int[10][10];

for (int indexOuter = 0; indexOuter < array.length; indexOuter++) {
    for (int indexInner = 0; indexInner < array[indexOuter].length; indexInner++) {
        array[indexOuter][indexInner] = indexOuter + indexInner;
    }
}

for (int[] numbers : array) {
    for (int value : numbers) {
        System.out.println(value);
    }
}

Es imposible establecer un Array en un valor no uniforme sin usar un bucle basado en índices.

Por supuesto, también puede usar bucles while o do-while while cuando se iteran utilizando índices.

Una nota de precaución: cuando utilice índices de matriz, asegúrese de que el índice esté entre 0 y array.length - 1 (ambos inclusive). No haga suposiciones de código rígido en la longitud de la matriz, de lo contrario podría romper su código si la longitud de la matriz cambia pero sus valores codificados no lo hacen.

Ejemplo:

int[] numbers = {1, 2, 3, 4};

public void incrementNumbers() {
    // DO THIS :
    for (int i = 0; i < numbers.length; i++) {
        numbers[i] += 1; //or this: numbers[i] = numbers[i] + 1; or numbers[i]++;      
    }
 
    // DON'T DO THIS :
    for (int i = 0; i < 4; i++) {
        numbers[i] += 1;
    }
}

También es mejor si no usa cálculos sofisticados para obtener el índice, pero si lo usa para iterar y si necesita valores diferentes, calcúlelos.

Ejemplo:

public void fillArrayWithDoubleIndex(int[] array) {
    // DO THIS :
    for (int i = 0; i < array.length; i++) {
        array[i] = i * 2;
    }
 
    // DON'T DO THIS :
    int doubleLength = array.length * 2;
    for (int i = 0; i < doubleLength; i += 2) {
        array[i / 2] = i;
    }
}

Acceso a matrices en orden inverso

int[] array = {0, 1, 1, 2, 3, 5, 8, 13};
for (int i = array.length - 1; i >= 0; i--) {
   System.out.println(array[i]);
}

Uso de matrices temporales para reducir la repetición de código

Iterar sobre una matriz temporal en lugar de repetir el código puede hacer que su código sea más limpio. Se puede utilizar donde se realiza la misma operación en múltiples variables.

// we want to print out all of these
String name = "Margaret";
int eyeCount = 16;
double height = 50.2;
int legs = 9;
int arms = 5;


// copy-paste approach:
System.out.println(name);
System.out.println(eyeCount);
System.out.println(height);
System.out.println(legs);
System.out.println(arms);


// temporary array approach:
for(Object attribute : new Object[]{name, eyeCount, height, legs, arms})
    System.out.println(attribute);

// using only numbers
for(double number : new double[]{eyeCount, legs, arms, height})
    System.out.println(Math.sqrt(number));

Tenga en cuenta que este código no debe usarse en secciones críticas para el rendimiento, ya que se crea una matriz cada vez que se ingresa al bucle, y las variables primitivas se copiarán en la matriz y, por lo tanto, no se podrán modificar.

Copiando matrices

Java proporciona varias formas de copiar una matriz.

en bucle

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length]; 
for (int i = 0; i < a.length; i++) {
    b[i] = a[i];
}

Tenga en cuenta que el uso de esta opción con una matriz de objetos en lugar de una matriz primitiva llenará la copia con referencia al contenido original en lugar de una copia de la misma.

Object.clone ()

Dado que las matrices son Object en Java, puede usar Object.clone() .

int[] a = { 4, 1, 3, 2 };
int[] b = a.clone(); // [4, 1, 3, 2]

Tenga en cuenta que el método Object.clone para una matriz realiza una copia superficial , es decir, devuelve una referencia a una nueva matriz que hace referencia a los mismos elementos que la matriz de origen.

Arrays.copyOf ()

java.util.Arrays proporciona una manera fácil de realizar la copia de una matriz a otra. Aquí está el uso básico:

int[] a = {4, 1, 3, 2};
int[] b = Arrays.copyOf(a, a.length); // [4, 1, 3, 2]

Tenga en cuenta que Arrays.copyOf también proporciona una sobrecarga que le permite cambiar el tipo de la matriz:

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

System.arraycopy ()

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) Copia una matriz de la matriz de origen especificada, comenzando en la posición especificada, a la posición especificada de la matriz de destino.

A continuación un ejemplo de uso.

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length];
System.arraycopy(a, 0, b, 0, a.length); // [4, 1, 3, 2]

Arrays.copyOfRange ()

Utilizado principalmente para copiar una parte de una matriz, también puede usarla para copiar una matriz completa a otra como se muestra a continuación

int[] a = { 4, 1, 3, 2 };
int[] b = Arrays.copyOfRange(a, 0, a.length); // [4, 1, 3, 2]

Matrices de fundición

Las matrices son objetos, pero su tipo está definido por el tipo de los objetos contenidos. Por lo tanto, uno no puede simplemente lanzar A[] a T[] , pero cada miembro A de A[] específico debe ser lanzado a un objeto T Ejemplo genérico:

public static <T, A> T[] castArray(T[] target, A[] array) {
    for (int i = 0; i < array.length; i++) {
        target[i] = (T) array[i];
    }
    return target;
}

Por lo tanto, dada una matriz A[] :

T[] target = new T[array.Length];
target = castArray(target, array);

Java SE proporciona el método Arrays.copyOf(original, newLength, newType) para este propósito:

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

Eliminar un elemento de una matriz

Java no proporciona un método directo en java.util.Arrays para eliminar un elemento de una matriz. Para realizarlo, puede copiar la matriz original en una nueva sin el elemento para eliminar o convertir su matriz en otra estructura que permita la eliminación.

Usando ArrayList

Puede convertir la matriz en una java.util.List , eliminar el elemento y volver a convertir la lista en una matriz de la siguiente manera:

String[] array = new String[]{"foo", "bar", "baz"};

List<String> list = new ArrayList<>(Arrays.asList(array));
list.remove("foo");

// Creates a new array with the same size as the list and copies the list
// elements to it.
array = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(array)); //[bar, baz]

Usando System.arraycopy

System.arraycopy() se puede usar para hacer una copia de la matriz original y eliminar el elemento que desee. A continuación un ejemplo:

int[] array = new int[] { 1, 2, 3, 4 }; // Original array.
int[] result = new int[array.length - 1]; // Array which will contain the result.
int index = 1; // Remove the value "2".

// Copy the elements at the left of the index.
System.arraycopy(array, 0, result, 0, index);
// Copy the elements at the right of the index.
System.arraycopy(array, index + 1, result, index, array.length - index - 1);

System.out.println(Arrays.toString(result)); //[1, 3, 4]

Usando Apache Commons Lang

Para eliminar fácilmente un elemento, puede usar la biblioteca Lang de Apache Commons y especialmente el método estático removeElement() de la clase ArrayUtils . A continuación un ejemplo:

int[] array = new int[]{1,2,3,4};
array = ArrayUtils.removeElement(array, 2); //remove first occurrence of 2
System.out.println(Arrays.toString(array)); //[1, 3, 4]

Array Covariance

Las matrices de objetos son covariantes, lo que significa que así como Integer es una subclase de Number , Integer[] es una subclase de Number[] . Esto puede parecer intuitivo, pero puede resultar en un comportamiento sorprendente:

Integer[] integerArray = {1, 2, 3};
Number[] numberArray = integerArray;  // valid
Number firstElement = numberArray[0]; // valid
numberArray[0] = 4L;                  // throws ArrayStoreException at runtime

Aunque Integer[] es una subclase de Number[] , solo puede contener Integer s, y al intentar asignar un elemento Long se genera una excepción de tiempo de ejecución.

Tenga en cuenta que este comportamiento es exclusivo de las matrices y que se puede evitar utilizando una List genérica en su lugar:

List<Integer> integerList = Arrays.asList(1, 2, 3);
//List<Number> numberList = integerList;  // compile error
List<? extends Number> numberList = integerList;
Number firstElement = numberList.get(0);
//numberList.set(0, 4L);                  // compile error

No es necesario que todos los elementos de la matriz compartan el mismo tipo, siempre que sean una subclase del tipo de la matriz:

interface I {}

class A implements I {}
class B implements I {}
class C implements I {}

I[] array10 = new I[] { new A(), new B(), new C() }; // Create an array with new
                                                     // operator and array initializer.

I[] array11 = { new A(), new B(), new C() };         // Shortcut syntax with array
                                                     // initializer.

I[] array12 = new I[3];                              // { null, null, null }

I[] array13 = new A[] { new A(), new A() };          // Works because A implements I.

Object[] array14 = new Object[] { "Hello, World!", 3.14159, 42 }; // Create an array with
                                                     // new operator and array initializer.

Object[] array15 = { new A(), 64, "My String" };     // Shortcut syntax 
                                                     // with array initializer.

¿Cómo cambias el tamaño de una matriz?

La respuesta simple es que no puedes hacer esto. Una vez que se ha creado una matriz, su tamaño no se puede cambiar. En cambio, una matriz solo puede "redimensionarse" creando una nueva matriz con el tamaño apropiado y copiando los elementos de la matriz existente a la nueva.

String[] listOfCities = new String[3];   // array created with size 3.
listOfCities[0] = "New York";
listOfCities[1] = "London";
listOfCities[2] = "Berlin";

Supongamos (por ejemplo) que es necesario agregar un nuevo elemento a la matriz listOfCities definida como se listOfCities anteriormente. Para hacer esto, necesitarás:

1. crear una nueva matriz con tamaño 4,
2. copie los 3 elementos existentes de la matriz antigua a la nueva matriz en las compensaciones 0, 1 y 2, y
3. agregue el nuevo elemento a la nueva matriz en el desplazamiento 3.

Hay varias formas de hacer lo anterior. Antes de Java 6, la forma más concisa era:

String[] newArray = new String[listOfCities.length + 1];
System.arraycopy(listOfCities, 0, newArray, 0, listOfCities.length);
newArray[listOfCities.length] = "Sydney";

Desde Java 6 en adelante, los métodos Arrays.copyOf y Arrays.copyOfRange pueden hacer esto de manera más simple:

String[] newArray = Arrays.copyOf(listOfCities, listOfCities.length + 1);
newArray[listOfCities.length] = "Sydney";

Para otras formas de copiar una matriz, consulte el siguiente ejemplo. Tenga en cuenta que necesita una copia de matriz con una longitud diferente a la original al cambiar el tamaño.

• Copiando matrices

Una mejor alternativa para cambiar el tamaño de matriz

Hay dos inconvenientes principales con el cambio de tamaño de una matriz como se describe anteriormente:

• Es ineficiente. Hacer una matriz más grande (o más pequeña) implica copiar muchos o todos los elementos de la matriz existente, y asignar un nuevo objeto de matriz. Cuanto mayor sea la matriz, más caro se vuelve.
• Debe poder actualizar cualquier variable "viva" que contenga referencias a la matriz anterior.

Una alternativa es crear la matriz con un tamaño suficientemente grande para comenzar. Esto solo es viable si puede determinar ese tamaño con precisión antes de asignar la matriz . Si no puede hacer eso, entonces surge nuevamente el problema de cambiar el tamaño de la matriz.

La otra alternativa es utilizar una clase de estructura de datos proporcionada por la biblioteca de clases Java SE o una biblioteca de terceros. Por ejemplo, el marco de "colecciones" de Java SE proporciona varias implementaciones de las API de List , Set y Map con diferentes propiedades de tiempo de ejecución. La clase ArrayList es la más cercana a las características de rendimiento de una matriz simple (p. Ej., Búsqueda O (N), obtención y configuración O (1), inserción y eliminación aleatoria O (N) al tiempo que proporciona un cambio de tamaño más eficiente sin el problema de actualización de referencia.

(La eficiencia de cambio de tamaño para ArrayList proviene de su estrategia de duplicar el tamaño de la matriz de respaldo en cada cambio de tamaño. Para un caso de uso típico, esto significa que solo cambia el tamaño ocasionalmente. Cuando amortiza durante la vida útil de la lista, el costo del cambio de tamaño por inserción es O(1) . Puede ser posible usar la misma estrategia al cambiar el tamaño de una matriz simple).

Encontrar un elemento en una matriz

Hay muchas maneras de encontrar la ubicación de un valor en una matriz. Los siguientes fragmentos de ejemplo suponen que la matriz es una de las siguientes:

  String[] strings = new String[] { "A", "B", "C" };
  int[] ints = new int[] { 1, 2, 3, 4 };

Además, cada uno establece el index o el index index2 en el índice del elemento requerido, o -1 si el elemento no está presente.

Usando Arrays.binarySearch (solo para arreglos ordenados)

  int index = Arrays.binarySearch(strings, "A");
  int index2 = Arrays.binarySearch(ints, 1);

Uso de Arrays.asList (solo para matrices no primitivas)

  int index = Arrays.asList(strings).indexOf("A");
  int index2 = Arrays.asList(ints).indexOf(1);  // compilation error

Usando una Stream

  int index = IntStream.range(0, strings.length)
                       .filter(i -> "A".equals(strings[i]))
                       .findFirst()
                       .orElse(-1); // If not present, gives us -1.
  // Similar for an array of primitives

Búsqueda lineal utilizando un bucle.

  int index = -1;
  for (int i = 0; i < array.length; i++) {
      if ("A".equals(array[i])) {
          index = i;
          break;
      }            
  }
  // Similar for an array of primitives

Búsqueda lineal utilizando bibliotecas de terceros como org.apache.commons

  int index = org.apache.commons.lang3.ArrayUtils.contains(strings, "A");
  int index2 = org.apache.commons.lang3.ArrayUtils.contains(ints, 1);

Nota: Usar una búsqueda lineal directa es más eficiente que envolver en una lista.

Probando si una matriz contiene un elemento

Los ejemplos anteriores se pueden adaptar para probar si la matriz contiene un elemento simplemente probando para ver si el índice calculado es mayor o igual a cero.

Alternativamente, también hay algunas variaciones más concisas:

boolean isPresent = Arrays.asList(strings).contains("A");

boolean isPresent = Stream<String>.of(strings).anyMatch(x -> "A".equals(x));

boolean isPresent = false;
for (String s : strings) {
    if ("A".equals(s)) {
        isPresent = true;
        break;
    }
}

boolean isPresent = org.apache.commons.lang3.ArrayUtils.contains(ints, 4);

Ordenando matrices

La clasificación de matrices se puede hacer fácilmente con la matriz de matrices .

import java.util.Arrays;

// creating an array with integers
int[] array = {7, 4, 2, 1, 19};
// this is the sorting part just one function ready to be used
Arrays.sort(array);
// prints [1, 2, 4, 7, 19]
System.out.println(Arrays.toString(array));

Clasificación de matrices de cuerdas:

String no es un dato numérico, define su propio orden, que se denomina orden lexicográfico, también conocido como orden alfabético. Cuando ordena una matriz de String usando el método sort() , la matriz se ordena en el orden natural definido por la interfaz comparable, como se muestra a continuación:

Orden creciente

String[] names = {"John", "Steve", "Shane", "Adam", "Ben"};
System.out.println("String array before sorting : " + Arrays.toString(names));
Arrays.sort(names); 
System.out.println("String array after sorting in ascending order : " + Arrays.toString(names));

Salida:

String array before sorting : [John, Steve, Shane, Adam, Ben]    
String array after sorting in ascending order : [Adam, Ben, John, Shane, Steve]

Orden decreciente

Arrays.sort(names, 0, names.length, Collections.reverseOrder());
System.out.println("String array after sorting in descending order : " + Arrays.toString(names));

Salida:

String array after sorting in descending order : [Steve, Shane, John, Ben, Adam]

Ordenar una matriz de objetos

Para ordenar una matriz de objetos, todos los elementos deben implementar una interfaz Comparable o Comparator para definir el orden de la clasificación.

Podemos usar cualquiera de los métodos de sort(Object[]) para ordenar una matriz de objetos en su orden natural, pero debe asegurarse de que todos los elementos de la matriz deben implementar Comparable .

Además, también deben ser mutuamente comparables, por ejemplo, e1.compareTo(e2) no debe lanzar una ClassCastException para ningún elemento e1 y e2 en la matriz. Alternativamente, puede ordenar una matriz de objetos en orden personalizado usando el método de sort(T[], Comparator) como se muestra en el siguiente ejemplo.

// How to Sort Object Array in Java using Comparator and Comparable
Course[] courses = new Course[4];
courses[0] = new Course(101, "Java", 200);
courses[1] = new Course(201, "Ruby", 300);
courses[2] = new Course(301, "Python", 400);
courses[3] = new Course(401, "Scala", 500);
       
System.out.println("Object array before sorting : " + Arrays.toString(courses));
       
Arrays.sort(courses);
System.out.println("Object array after sorting in natural order : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.PriceComparator());
System.out.println("Object array after sorting by price : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.NameComparator());
System.out.println("Object array after sorting by name : " + Arrays.toString(courses));

Salida:

Object array before sorting : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting in natural order : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by price : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by name : [#101 Java@200 , #301 Python@400 , #201 Ruby@300 , #401 Scala@500 ]

Conversión de matrices entre primitivas y tipos de caja.

A veces es necesaria la conversión de tipos primitivos a tipos en caja .

Para convertir la matriz, es posible usar flujos (en Java 8 y superior):

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = 
    Arrays.stream(primitiveArray).boxed().toArray(Integer[]::new);

Con versiones inferiores, puede ser iterando la matriz primitiva y copiándola explícitamente a la matriz en caja:

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = new Integer[primitiveArray.length];
for (int i = 0; i < primitiveArray.length; ++i) {
    boxedArray[i] = primitiveArray[i]; // Each element is autoboxed here
}

De manera similar, una matriz en caja se puede convertir en una matriz de su contraparte primitiva:

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = 
    Arrays.stream(boxedArray).mapToInt(Integer::intValue).toArray();

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = new int[boxedArray.length];
for (int i = 0; i < boxedArray.length; ++i) {
    primitiveArray[i] = boxedArray[i]; // Each element is outboxed here
}