¿Cómo declaro e inicializo una matriz en Java?

¿Cómo declaro e inicializo una matriz en Java?

Puede usar statement de matriz o literal de matriz (pero solo cuando declara y afecta la variable de inmediato, los literales de matriz no se pueden usar para reasignar una matriz).

Para tipos primitivos:

int[] myIntArray = new int[3]; int[] myIntArray = {1,2,3}; int[] myIntArray = new int[]{1,2,3}; 

Para las clases, por ejemplo, String , es lo mismo:

 String[] myStringArray = new String[3]; String[] myStringArray = {"a","b","c"}; String[] myStringArray = new String[]{"a","b","c"}; 

La tercera forma de inicialización es útil cuando declaras primero la matriz y luego la inicializas. El elenco es necesario aquí.

 String[] myStringArray; myStringArray = new String[]{"a","b","c"}; 

Hay dos tipos de matriz.

Matriz unidimensional

Sintaxis para los valores predeterminados:

 int[] num = new int[5]; 

O (menos preferido)

 int num[] = new int[5]; 

Sintaxis con valores dados (inicialización variable / campo):

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

O (menos preferido)

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

Nota: Por conveniencia int [] num es preferible porque claramente dice que está hablando aquí acerca de la matriz. De lo contrario, no hay diferencia. De ningún modo.

Matriz multidimensional

Declaración

 int[][] num = new int[5][2]; 

O

 int num[][] = new int[5][2]; 

O

 int[] num[] = new int[5][2]; 

Inicialización

  num[0][0]=1; num[0][1]=2; num[1][0]=1; num[1][1]=2; num[2][0]=1; num[2][1]=2; num[3][0]=1; num[3][1]=2; num[4][0]=1; num[4][1]=2; 

O

  int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} }; 

Ragged Array (o matriz no rectangular)

  int[][] num = new int[5][]; num[0] = new int[1]; num[1] = new int[5]; num[2] = new int[2]; num[3] = new int[3]; 

Entonces aquí estamos definiendo columnas explícitamente.
De otra manera:

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

Para acceder:

 for (int i=0; i<(num.length); i++ ) { for (int j=0;j 

Alternativamente:

 for (int[] a : num) { for (int i : a) { System.out.println(i); } } 

Las matrices irregulares son matrices multidimensionales.
Para una explicación, vea detalles de matriz multidimensional en los tutoriales oficiales de Java

 Type[] variableName = new Type[capacity]; Type[] variableName = {comma-delimited values}; Type variableName[] = new Type[capacity]; Type variableName[] = {comma-delimited values}; 

también es válido, pero prefiero los corchetes después del tipo, porque es más fácil ver que el tipo de la variable es realmente una matriz.

Hay varias formas en que puede declarar una matriz en Java:

 float floatArray[]; // Initialize later int[] integerArray = new int[10]; String[] array = new String[] {"a", "b"}; 

Puede encontrar más información en el sitio tutorial de Sun y en JavaDoc .

Me parece útil si entiendes cada parte:

 Type[] name = new Type[5]; 

Type[] es el tipo de la variable llamada nombre (“nombre” se llama identificador ). El “Tipo” literal es el tipo base, y los corchetes significan que este es el tipo de matriz de esa base. Los tipos de matriz son, a su vez, tipos propios, lo que le permite crear matrices multidimensionales como Type[][] (el tipo de matriz de Tipo []). La palabra clave new dice asignar memoria para la nueva matriz. El número entre el corchete indica qué tan grande será la nueva matriz y cuánta memoria asignar. Por ejemplo, si Java sabe que el tipo base Type toma 32 bytes, y usted quiere una matriz de tamaño 5, necesita asignar internamente 32 * 5 = 160 bytes.

También puede crear matrices con los valores que ya existen, como

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

que no solo crea el espacio vacío sino que lo llena con esos valores. Java puede decir que las primitivas son números enteros y que hay 5, por lo que el tamaño de la matriz se puede determinar implícitamente.

A continuación, se muestra la statement de una matriz, pero la matriz no se inicializa:

  int[] myIntArray = new int[3]; 

A continuación se muestra la statement, así como la inicialización de la matriz:

 int[] myIntArray = {1,2,3}; 

Ahora, lo siguiente también muestra la statement, así como la inicialización de la matriz:

 int[] myIntArray = new int[]{1,2,3}; 

Pero este tercero muestra la propiedad de la creación anónima de objetos de matriz apuntada por una variable de referencia “myIntArray”, por lo que si escribimos solo “new int [] {1,2,3};” entonces así es como se puede crear el objeto de matriz anónimo.

Si solo escribimos:

 int[] myIntArray; 

esto no es una statement de matriz, pero la siguiente statement completa la statement anterior:

 myIntArray=new int[3]; 

Alternativamente,

 // Either method works String arrayName[] = new String[10]; String[] arrayName = new String[10]; 

Eso declara una matriz llamada arrayName del tamaño 10 (tiene los elementos del 0 al 9 para usar).

Además, en caso de que quieras algo más dynamic, está la interfaz de la Lista. Esto no funcionará tan bien, pero es más flexible:

 List listOfString = new ArrayList(); listOfString.add("foo"); listOfString.add("bar"); String value = listOfString.get(0); assertEquals( value, "foo" ); 

Hay dos formas principales de hacer una matriz:

Esta, para una matriz vacía:

 int[] array = new int[n]; // "n" being the number of spaces to allocate in the array 

Y este, para una matriz inicializada:

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

También puede hacer matrices multidimensionales, como esta:

 int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...}; 

Tome el tipo primitivo int por ejemplo. Hay varias formas de declarar y en matriz:

 int[] i = new int[capacity]; int[] i = new int[] {value1, value2, value3, etc}; int[] i = {value1, value2, value3, etc}; 

donde en todos estos, puede usar int i[] lugar de int[] i .

Con la reflexión, puede usar (Type[]) Array.newInstance(Type.class, capacity);

Tenga en cuenta que en los parámetros del método, ... indica variable arguments . Básicamente, cualquier cantidad de parámetros está bien. Es más fácil de explicar con código:

 public static void varargs(int fixed1, String fixed2, int... varargs) {...} ... varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100} varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200}; 

Dentro del método, varargs se trata como una int[] normal int[] . Type... solo se puede usar en parámetros de método, por lo que int... i = new int[] {} no se comstackrá.

Tenga en cuenta que al pasar un int[] a un método (o cualquier otro Type[] ), no puede usar el tercer camino. En el enunciado int[] i = *{a, b, c, d, etc}* , el comstackdor supone que {...} significa un int[] . Pero eso es porque estás declarando una variable. Al pasar una matriz a un método, la statement debe ser new Type[capacity] o new Type[] {...} .

Matrices multidimensionales

Las matrices multidimensionales son mucho más difíciles de tratar. Esencialmente, una matriz 2D es una matriz de matrices. int[][] significa una matriz de int[] s. La clave es que si int[][] se declara como int[x][y] , el índice máximo es i[x-1][y-1] . Esencialmente, un rectangular int[3][5] es:

 [0, 0] [1, 0] [2, 0] [0, 1] [1, 1] [2, 1] [0, 2] [1, 2] [2, 2] [0, 3] [1, 3] [2, 3] [0, 4] [1, 4] [2, 4] 

Si desea crear matrices utilizando reflexiones, puede hacer esto:

  int size = 3; int[] intArray = (int[]) Array.newInstance(int.class, size ); 

Declarar una matriz de referencias de objetos:

 class Animal {} class Horse extends Animal { public static void main(String[] args) { /* * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed) */ Animal[] a1 = new Animal[10]; a1[0] = new Animal(); a1[1] = new Horse(); /* * Array of Animal can hold Animal and Horse and all subtype of Horse */ Animal[] a2 = new Horse[10]; a2[0] = new Animal(); a2[1] = new Horse(); /* * Array of Horse can hold only Horse and its subtype (if any) and not allowed supertype of Horse nor other subtype of Animal. */ Horse[] h1 = new Horse[10]; h1[0] = new Animal(); // Not allowed h1[1] = new Horse(); /* * This can not be declared. */ Horse[] h2 = new Animal[10]; // Not allowed } } 

Array es una lista secuencial de elementos

 int item = value; int [] one_dimensional_array = { value, value, value, .., value }; int [][] two_dimensional_array = { { value, value, value, .. value }, { value, value, value, .. value }, .. .. .. .. { value, value, value, .. value } }; 

Si es un objeto, entonces es el mismo concepto

 Object item = new Object(); Object [] one_dimensional_array = { new Object(), new Object(), .. new Object() }; Object [][] two_dimensional_array = { { new Object(), new Object(), .. new Object() }, { new Object(), new Object(), .. new Object() }, .. .. .. { new Object(), new Object(), .. new Object() } }; 

En el caso de los objetos, debe asignarlo a null para inicializarlos usando el new Type(..) , las clases como String y Integer son casos especiales que se manejarán de la siguiente manera.

 String [] a = { "hello", "world" }; // is equivalent to String [] a = { new String({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) }; Integer [] b = { 1234, 5678 }; // is equivalent to Integer [] b = { new Integer(1234), new Integer(5678) }; 

En general, puedes crear matrices que sean M dimensionales

 int [][]..[] array = // ^ M times [] brackets {{..{ // ^ M times { bracket // this is array[0][0]..[0] // ^ M times [0] }}..} // ^ M times } bracket ; 

Vale la pena señalar que la creación de una matriz dimensional M es costosa en términos de espacio. Desde que crea una matriz M dimensional con N en todas las dimensiones, el tamaño total de la matriz es mayor que N^M , ya que cada matriz tiene una referencia, y en la dimensión M hay una (M-1) – matriz dimensional de referencias. El tamaño total es el siguiente

 Space = N^M + N^(M-1) + N^(M-2) + .. + N^0 // ^ ^ array reference // ^ actual data 

Para crear matrices de Objetos de clase puede usar java.util.ArrayList . para definir una matriz:

 public ArrayList arrayName; arrayName = new ArrayList(); 

Asignar valores a la matriz:

 arrayName.add(new ClassName(class parameters go here); 

Lea de la matriz:

 ClassName variableName = arrayName.get(index); 

Nota:

variableName es una referencia a la matriz, lo que significa que la manipulación de variableName manipulará arrayName

para bucles:

 //repeats for every value in the array for (ClassName variableName : arrayName){ } //Note that using this for loop prevents you from editing arrayName 

para loop que te permite editar arrayName (convencional para loop):

 for (int i = 0; i < arrayName.size(); i++){ //manipulate array here } 

En Java 8 puedes usarlo así.

 String[] strs = IntStream.range(0, 15) // 15 is the size .mapToObj(i -> Integer.toString(i)) .toArray(String[]::new); 

Declare e inicialice para Java 8 y posterior. Crea una matriz de enteros simple:

 int [] a1 = IntStream.range(1, 20).toArray(); System.out.println(Arrays.toString(a1)); // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 

Cree una matriz aleatoria para enteros entre [-50, 50] y para dobles [0, 1E17]:

 int [] a2 = new Random().ints(15, -50, 50).toArray(); double [] a3 = new Random().doubles(5, 0, 1e17).toArray(); 

Secuencia de Poder-de-dos:

 double [] a4 = LongStream.range(0, 7).mapToDouble(i -> Math.pow(2, i)).toArray(); System.out.println(Arrays.toString(a4)); // Output: [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0] 

Para String [] debe especificar un constructor:

 String [] a5 = Stream.generate(()->"I will not squeak chalk").limit(5).toArray(String[]::new); System.out.println(Arrays.toString(a5)); 

Arrays multidimensionales:

 String [][] a6 = List.of(new String[]{"a", "b", "c"} , new String[]{"d", "e", "f", "g"}) .toArray(new String[0][]); System.out.println(Arrays.deepToString(a6)); // Output: [[a, b, c], [d, e, f, g]] 

En Java 9

Uso de los IntStream.iterate(...) :

 int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray(); Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray(); Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

Otra forma de declarar e inicializar ArrayList:

 private List list = new ArrayList(){{ add("e1"); add("e2"); }}; 
 int[] SingleDimensionalArray = new int[2] int[][] MultiDimensionalArray = new int[3][4] 
Intereting Posts