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

matriz java filas columnas

Question

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

Answer 1

En java 9

Usando diferentes métodos IntStream.iterate e IntStream.takeWhile :

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]

En java 10

Usando la inferencia de tipo de variable local :

var letters = new String[]{"A", "B", "C"};

Answer 2

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

 int[] myIntArray = new int[3];

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

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

Ahora, lo siguiente también muestra la declaración, 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 que está señalada por una variable de referencia "myIntArray", por lo que si escribimos simplemente "new int [] {1,2,3};" entonces así es como se puede crear un objeto de matriz anónimo.

Si acabamos de escribir:

int[] myIntArray;

esto no es una declaración de matriz, pero la siguiente declaración completa la declaración anterior:

myIntArray=new int[3];

Answer 3

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

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );

Answer 4

Alternativamente,

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

Eso declara una matriz llamada arrayName de tamaño 10 (tiene elementos de 0 a 9 para usar).

Answer 5

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 utilizando 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
;

Es digno de notar que crear una matriz dimensional es costoso en términos de espacio. Ya que cuando creas una matriz dimensional M 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) - Array 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

Answer 6

Con la inferencia de tipo de variable local, solo tiene que especificar el tipo una vez:

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

o

int[] values = { 1, 2, 3 }

Answer 7

Declarar e inicializar para Java 8 y versiones posteriores. Crear una matriz entera entera:

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 del 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 [] debes especificar un constructor:

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

Arreglos 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]]

Answer 8

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

Answer 9

En Java 8 puedes usar así.

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

Answer 10

Hay dos formas principales de hacer una matriz:

Éste, 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 puedes 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 ...} ...};

Answer 11

Hay dos tipos de matriz.

Matriz unidimensional

Sintaxis para los valores por defecto:

int[] num = new int[5];

O (menos preferido)

int num[] = new int[5];

Sintaxis con valores dados (inicialización de 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 indica que está hablando aquí sobre array. De lo contrario no hay diferencia. De ningún modo.

Array 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} };

Matriz desigual (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];

Así que 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 el acceso:

for (int i=0; i<(num.length); i++ ) {
    for (int j=0;j<num[i].length;j++)
        System.out.println(num[i][j]);
}

Alternativamente:

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

Las matrices desiguales son matrices multidimensionales.
Para una explicación, vea detalles de matrices multidimensionales en los tutoriales oficiales de java

Answer 12

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 de tutoriales de Sun y en JavaDoc .

Answer 13

Me parece útil si entiendes cada parte:

Type[] name = new Type[5];

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

También puede crear matrices con los valores que ya están allí, 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 los primitivos son enteros y que hay 5 de ellos, por lo que el tamaño de la matriz se puede determinar implícitamente.

Answer 14

Otra forma de declarar e inicializar ArrayList:

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};

Answer 15

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

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

Asignar valores a la matriz:

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

Leer de la matriz:

ClassName variableName = arrayName.get(index);

Nota:

variableName es una referencia a la matriz, lo que significa que manipular 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 bucle que le permite editar arrayName (convencional para bucle):

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

Answer 16

Puede usar la declaración de matriz o el literal de matriz (pero solo cuando declara y afecta la variable de inmediato, los literales de matriz no pueden usarse para reasignar una matriz).

Para los 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 inicializar es útil cuando declara primero la matriz y luego la inicializa. El elenco es necesario aquí.

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

Answer 17

Si desea crear matrices utilizando reflexiones, puede hacer lo siguiente:

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

Answer 18

Tomemos el tipo primitivo int por ejemplo. Hay varias formas de declarar e int array:

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 . Esencialmente, cualquier número 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 un int[] normal int[] . Type... solo se puede usar en los parámetros del método, por lo que int... i = new int[] {} no se compilará.

Tenga en cuenta que al pasar un int[] a un método (o cualquier otro Type[] ), no puede utilizar la tercera forma. En la declaración int[] i = *{a, b, c, d, etc}* , el compilador asume que {...} significa un int[] . Pero eso es porque estás declarando una variable. Cuando se pasa una matriz a un método, la declaración debe ser new Type[capacity] o new Type[] {...} .

Arreglos Multidimensionales

Los arreglos multidimensionales son mucho más difíciles de manejar. Esencialmente, una matriz 2D es una matriz de matrices. int[][] significa una matriz de int[] s. La clave es que si se declara un int[][] como int[x][y] , el índice máximo es i[x-1][y-1] . Esencialmente, un int[3][5] 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]

Answer 19

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 en realidad una matriz.

Answer 20

int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]