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

https://stackoverflow.com/questions/1200621

05-07-2019
|

Pregunta

Solución

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

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

Otros consejos

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 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 dice que estás hablando aquí sobre array. De lo contrario no hay diferencia. En absoluto.

Matriz multidimensional

Declaración

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

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

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;

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

Matriz irregular (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.
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<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 el detalle de la 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 en realidad una matriz.

Hay varias formas de 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 Tutorial de Sun sitio y JavaDoc .

A continuación se muestra la declaración de una matriz, pero la matriz no está inicializada:

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

Encuentro que es útil si entiendes cada parte:

Type[] name = new Type[5];

Type [] es el type de la variable llamada name (" nombre " se llama el identifier ). 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 arreglos son a su vez tipos propios, lo que le permite crear arreglos multidimensionales como Type [] [] (el tipo de arreglo de Type []). 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 base Tipo 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.

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

Además, en caso de que desee algo más dinámico, está la interfaz de la Lista. Esto no funcionará también, 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" );

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

Tome el tipo primitivo int por ejemplo. Hay varias formas de declarar y 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, puedes usar int i [] en 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 argumentos variables . 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. 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 usar la tercera vía. En la declaración int [] i = * {a, b, c, d, etc} * , el compilador asume que el {...} 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 nuevo Tipo [capacidad] o nuevo Tipo [] {...} .

Matrices 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 un int [] [] se declara como int [x] [y] , el índice máximo es i [x-1] [ y-1] . Esencialmente, un int [3] [5] rectangular 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 lo siguiente:

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

En Java 9

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

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

Utilizando el Inferencia de tipo de variable local :

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

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 objetos, debe asignarlo a null para inicializarlos usando new Type (..) , 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, puede crear matrices que sean M dimensional

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 un arreglo dimensional M es costoso en términos de espacio. Desde que 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 matriz de referencias dimensional (M-1). 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<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

Asignar valores a la matriz:

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

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

En Java 8 puedes usar 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 versiones posteriores. 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 potencia 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]]

También puedes hacerlo con java.util.Arrays :

List<String> number = Arrays.asList("1", "2", "3");

Out: ["1", "2", "3"]

Este es bastante simple y sencillo. No lo vi en otras respuestas, así que pensé que podría agregarlo.

Otra forma de declarar e inicializar ArrayList:

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

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

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

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

Muchas respuestas aquí. Adición de algunas formas difíciles de crear matrices (desde un punto de vista es bueno saber esto)

declarar y definir una matriz
```
int intArray[] = new int[3];
```

esto creará una matriz de longitud 3. Como mantiene el tipo primitivo int, todos los valores se establecen en 0 de forma predeterminada. Por ejemplo,

    intArray[2]; // will return 0

Usar corchetes [] antes del nombre de la variable

int[] intArray = new int[3];
intArray[0] = 1;  // array content now {1,0,0}

Inicialice y proporcione datos a la matriz
```
int[] intArray = new int[]{1,2,3};
```
esta vez no es necesario mencionar el tamaño en el soporte de cuadro. Incluso una variante simple de esto es
```
int[] intArray = {1,2,3,4};
```

Una matriz de longitud 0

int[] intArray = new int[0];
int length = intArray.length; // will return length 0

Similar para matrices multidimensionales

int intArray[][] = new int[2][3]; 
// This will create an array of length 2 and 
//each element contains another array of length 3.
// { {0,0,0},{0,0,0} } 
int lenght1 = intArray.length; // will return 2
int length2 = intArray[0].length; // will return 3

Usando corchetes antes de la variable

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

está absolutamente bien si pones un corchete al final

int[] intArray [] = new int[2][4];
int[] intArray[][] = new int[2][3][4]

Algunos ejemplos

    int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
    int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
    int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}} 
    // All the 3 arrays assignments are valid
    //Array looks like {{1,2,3},{4,5,6}}

No es obligatorio que cada elemento interno sea del mismo tamaño.

    int [][] intArray = new int[2][];
    intArray[0] = {1,2,3};
    intArray[1] = {4,5};
    //array looks like {{1,2,3},{4,5}}

    int[][] intArray = new int[][2] ; // this won't compile keep this in mind.

Debe asegurarse de que si está utilizando la sintaxis anterior, en la dirección de avance debe especificar los valores entre corchetes. De lo contrario, no se compilará. Algunos ejemplos:

    int [][][] intArray = new int[1][][];
    int [][][] intArray = new int[1][2][];
    int [][][] intArray = new int[1][2][3];

Otra característica importante es covariant

    Number[] numArray = {1,2,3,4};   // java.lang.Number
    numArray[0] = new Float(1.5f);   // java.lang.Float
    numArray[1] = new Integer(1);    // java.lang.Integer
   //You can store a subclass object in an array that is declared
   // to be of the type of its superclass. 
   // Here Number is the superclass for both Float and Integer.

   Number num[] = new Float[5]; // this is also valid

IMP: para los tipos de referencia, el valor predeterminado almacenado en la matriz es nulo.

Declare Array: int [] arr;

Inicializar matriz: int [] arr = new int [10]; 10 representa el número de elementos permitidos en la matriz

Declare Multidimensional Array: int [] [] arr;

Inicialice la matriz multidimensional: int [] [] arr = new int [10] [17]; 10 filas y 17 columnas y 170 elementos porque 10 veces 17 es 170.

Inicializar una matriz significa especificar su tamaño.

int[] SingleDimensionalArray = new int[2]

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

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow