Creación e inicialización de matrices

Download java eBook

Ejemplo

Casos basicos

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

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

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

Arrays, colecciones y corrientes

Java SE 1.2
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).
Java SE 8
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).

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:

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

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

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

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

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

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 :

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

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

Un conjunto de 10 elementos.

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:

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

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

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:

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

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[]  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).

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 :

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

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

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

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:

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

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

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

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:

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

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:

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

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:

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

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

Representación visual de una matriz multidimensional de Java.

Fuente - Live en Ideone

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

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

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:

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

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 :

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

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 :

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

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:

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

    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:

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

    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

Java SE 1.2

Arrays.fill() se puede usar para llenar una matriz con el mismo valor después de la inicialización:

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

Vivir en Ideone

fill() también puede asignar un valor a cada elemento del rango especificado de la matriz:

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

Vivir en Ideone

Java SE 8

Desde la versión 8 de Java, el método setAll y su parallelSetAll Concurrent setAll se pueden usar para establecer cada elemento de una matriz en valores generados. A estos métodos se les pasa una función de generador que acepta un índice y devuelve el valor deseado para esa posición.

El siguiente ejemplo crea una matriz de enteros y establece todos sus elementos en su valor de índice respectivo:

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

Vivir en Ideone

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 :

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

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:

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

Vivir en Ideone

Stats

Contributors: 168
2017-07-04
Licenciado bajo: CC-BY-SA

No afiliado a Stack Overflow
Rip Tutorial: info@zzzprojects.com

Descargar eBook