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

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

preguntado el 29 de julio de 09 a las 14:07

Antes de publicar una nueva respuesta, considere que ya hay más de 25 respuestas para esta pregunta. Por favor, asegúrese de que su respuesta aporte información que no se encuentre entre las respuestas existentes. -

30 Respuestas

Puede usar una declaración de matriz o un 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};

// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html

int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort 

Para 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 una matriz primero y luego la inicializa, pasa una matriz como un argumento de función o devuelve una matriz. Se requiere el tipo explícito.

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

respondido 03 mar '21, 16:03

¿Cuál es el propósito de tener tanto la segunda como la tercera forma de hacerlo? - Quazi Irfan

@iamcreasy Parece que la segunda forma no funciona con declaraciones de retorno. return {1,2,3} da un error, mientras return new int[]{1,2,3} funciona bien (asumiendo, por supuesto, que su función devuelve una matriz de enteros). - Skylar Ittner

@SkylarMT Pero todavía podemos usar la primera forma de usar con la declaración de retorno. - Quazi Irfan

@iamcreasy Recientemente escribí una función que devolvió una matriz de ints. Si ocurría un error dentro de la función, quería que devolviera un cierto valor, pero la función necesitaba devolver una matriz. ¿Qué forma funciona para una declaración de devolución de una sola línea? Solo el tercero. - Skylar Ittner

@apadana En el segundo caso, está creando un objeto anónimo que solo se define en el alcance adjunto (función o lo que sea). Después de devolverlo a la persona que llama, ya no es válido. Usando la nueva palabra clave, asigna el nuevo objeto del montón y es válido fuera del ámbito de definición. - teukkam

Hay dos tipos de matrices.

Matriz unidimensional

Sintaxis de 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 indica claramente que se está hablando aquí de una matriz. De lo contrario, no hay diferencia. Para nada.

Matriz multidimensional

Declaración

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

Or

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

Or

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;

Or

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

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<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 irregulares son matrices multidimensionales.
Para una explicación, consulte el detalle de la matriz multidimensional en los tutoriales oficiales de java

Respondido el 20 de diciembre de 15 a las 23:12

¿No conducirá el primero a una matriz nula / vacía, en lugar de a una matriz con valores predeterminados? - Vipin8169

Estoy de acuerdo en ese punto, y podemos agregar una característica más, podemos cambiar el tamaño de forma dinámica. - AdamIJK

Podría discutir con usted sobre el punto de que una matriz multidimensional es un "tipo" diferente de matriz. Es simplemente un término que se usa para describir una matriz que contiene otras matrices. Tanto las matrices externas como las internas (y las intermedias, si existen) son solo matrices regulares. - Equipo M.

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.

respondido 12 nov., 14:22

Estoy de acuerdo en ese punto. El tipo de la variable no es "TIPO", sino un TIPO [], por lo que tiene sentido escribirlo de esa manera para mí. - Chet

Estilo de Google sugiero esto también. - Wener

Tenga en cuenta que int[] a, b; no será lo mismo que int a[], b;, un error fácil de cometer si utiliza la última forma. - Jeroen Vannevel

Hay varias formas en las 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 Tutorial de sol sitio y el Javoc.

Respondido 06 Feb 18, 20:02

Me parece útil que comprenda cada parte:

Type[] name = new Type[5];

Type[] es la clase de los variable llamado nombre ("nombre" se llama el 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 que asigne memoria para la nueva matriz. El número entre corchetes 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 desea una matriz de tamaño 5, necesita 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 las primitivas son números enteros y que hay 5 de ellos, por lo que el tamaño de la matriz se puede determinar implícitamente.

Respondido 12 Oct 13, 13:10

Entonces no es necesario incluir int[] name = new int[5] ? - Cookie Monster

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 y la inicialización de la matriz:

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

Ahora, lo siguiente también muestra la declaración y la inicialización de la matriz:

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

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

Si solo escribimos:

int[] myIntArray;

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

myIntArray=new int[3];

Respondido el 23 de junio de 14 a las 01:06

No hay absolutamente ninguna diferencia entre el segundo y tercer enfoque, aparte de que el segundo enfoque , de manera funciona cuando también declaras una variable. No está claro lo que quiere decir con "muestra la propiedad de la creación de objetos de matriz anónimos", pero en realidad son piezas de código equivalentes. - Jon Skeet

Además, el primer fragmento Inicialice la matriz: se garantiza que tendrá el valor 0 para cada elemento de la matriz. - Jon Skeet

¿Realmente no hay diferencia entre el segundo y el tercero enfoques? - campo propio

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 del 0 al 9 para usar).

Respondido 29 Jul 09, 18:07

¿Cuál es el estándar que se debe utilizar? Acabo de descubrir el primero y lo encuentro horriblemente engañoso: | - Anti Tierra

Por lo que vale, mi profesor dijo que la segunda forma es más típica en Java y que transmite mejor lo que está sucediendo; como una matriz relacionada con el tipo en el que se emitió la variable. - Celeritas

Para una nota al margen: un lenguaje que tiene más de una semántica para declarar una cosa que significa mal diseño de lenguaje. - Muhammad Suleman

Además, en caso de que desee algo más dinámico, existe la interfaz List. 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" );

respondido 19 mar '13, 14:03

¿Cómo se llama el "<>" en la lista que creó? - Chipre

@Chipre List es una clase genérica, tiene un tipo como parámetro, encerrado en <>. Eso ayuda porque solo necesita definir un tipo genérico una vez y luego puede usarlo con varios tipos diferentes. Para obtener una explicación más detallada, consulte docs.oracle.com/javase/tutorial/java/generics/types.html - Heimdall

Hay dos formas principales de hacer una matriz:

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

Respondido el 26 de junio de 16 a las 01:06

Toma el tipo primitivo int por ejemplo. Hay varias formas de declarar y int formación:

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[] en lugar de int[] i.

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

Tenga en cuenta que en los parámetros del método, ... Indica variable arguments. Básicamente, 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 es tratado como un 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 vía. En la declaración int[] i = *{a, b, c, d, etc}*, el compilador asume que el {...} significa un int[]. Pero eso se debe a que está declarando una variable. Al pasar una matriz a un método, la declaración debe ser new Type[capacity] or new Type[] {...}.

Matrices multidimensionales

Las matrices multidimensionales son mucho más difíciles de manejar. Básicamente, 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 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]

contestado el 23 de mayo de 15 a las 23:05

En Java 9

Utilizando 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

Usando el patrón de velas del Inferencia de tipo de variable local:

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

contestado el 23 de mayo de 19 a las 01:05

Si desea crear matrices usando reflejos, puede hacer lo siguiente:

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

contestado el 23 de mayo de 15 a las 23:05

¿Por qué querría crear una matriz de esa manera? - Dorian Gray

Declarar una matriz de referencias a 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
    }
}

Respondido el 26 de junio de 16 a las 00:06

En Java 8 puedes usar algo como esto.

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

Respondido el 02 de enero de 21 a las 04:01

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 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 M dimensional

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 un M La matriz dimensional es cara en términos de espacio. Desde que creas un M matriz 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 matriz de referencias (M-1) dimensional. El tamaño total es el siguiente

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

Respondido 21 Oct 15, 16:10

Para crear matrices de objetos de clase, puede utilizar el 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

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

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

Respondido 08 ago 16, 13:08

Declare e inicialice para Java 8 y versiones posteriores. Cree 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 números 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 [] debe especificar un constructor:

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

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

Respondido 22 Feb 18, 01:02

¿Se incluyen realmente -50 y / o +50? Es decir, ¿el interior está abierto en uno o en ambos extremos? - Peter Mortensen

-50 está incluido y +50 está excluido. Esta información de API de Java "origen dado (inclusive) y consolidado (exclusivo)". Yo uso la declaración de intervalo de wiki . Entonces creo que será más correcto [-50, 50) - Kirill Podlivaev

Aquí hay muchas respuestas. Estoy agregando algunas formas complicadas de crear matrices (desde un examen punto de vista es bueno saber esto)

  1. Declarar y definir una matriz

    int intArray[] = new int[3];
    

    Esto creará una matriz de longitud 3. Como contiene un tipo primitivo, int, todos los valores se establecen en 0 por defecto. Por ejemplo,

    intArray[2]; // Will return 0
    
  2. Uso de corchetes [] antes del nombre de la variable

    int[] intArray = new int[3];
    intArray[0] = 1;  // Array content is now {1, 0, 0}
    
  3. Inicializar y proporcionar datos a la matriz

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

    Esta vez no es necesario mencionar el tamaño en el soporte de la caja. Incluso una variante simple de esto es:

    int[] intArray = {1, 2, 3, 4};
    
  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 coloca un soporte de caja 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 todos los elementos internos sean 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 si está utilizando la sintaxis anterior, que 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 covariante

    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

IMPORTANTE: Para los tipos referenciados, el valor predeterminado almacenado en la matriz es nulo.

Respondido el 07 de Septiembre de 19 a las 20:09

Una matriz tiene dos tipos básicos.

Matriz estática: Matriz de tamaño fijo (su tamaño debe declararse al principio y no se puede cambiar más adelante)

Matriz dinámica: No se considera límite de tamaño para esto. (Las matrices dinámicas puras no existen en Java. En su lugar, se recomienda utilizar List).

Para declarar una matriz estática de Integer, string, float, etc., use la siguiente declaración e instrucciones de inicialización.

int[] intArray = new int[10];
String[] intArray = new int[10];
float[] intArray = new int[10];

// Here you have 10 index starting from 0 to 9

Para usar funciones dinámicas, debe usar List ... List es puro matriz dinámica y no es necesario declarar el tamaño al principio. A continuación se muestra la forma correcta de declarar una lista en Java:

ArrayList<String> myArray = new ArrayList<String>();
myArray.add("Value 1: something");
myArray.add("Value 2: something more");

Respondido el 02 de enero de 21 a las 04:01

Gracias @Matheus por mejorar mis respuestas. Le pediría que vote a favor de esto, para que pueda llegar a más usuarios. - Zia

Si por "matriz" te refieres a usar java.util.Arrays, puedes hacerlo así:

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

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

Este es bonito sencillo y sencillo.

Respondido el 18 de enero de 21 a las 19:01

No lo vi en otras respuestas, así que pensé que podía agregarlo. - Sylhare

Una lista no es una matriz - Tirno

A veces, las personas se refieren a matrices, cuando quieren una lista. - Sylhare

Otra forma de declarar e inicializar ArrayList:

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

Respondido 04 ago 17, 10:08

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

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

Or

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

Respondido el 07 de Septiembre de 19 a las 20:09

Java no tiene var. - Cameron Hudson

@CameronHudson Java 10 tiene var openjdk.java.net/jeps/286 - Konstantin Spirin

package com.examplehub.basics;

import java.util.Arrays;

public class Array {

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        System.out.println("numbers[0] = " + numbers[0]);
        System.out.println("numbers[1] = " + numbers[1]);
        System.out.println("numbers[2] = " + numbers[2]);
        System.out.println("numbers[3] = " + numbers[3]);
        System.out.println("numbers[4] = " + numbers[4]);

        /*
         * Array index is out of bounds
         */
        //System.out.println(numbers[-1]);
        //System.out.println(numbers[5]);


        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        for (int i = 0; i < 5; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        /*
         * Length of numbers = 5
         */
        System.out.println("length of numbers = " + numbers.length);

        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        /*
         * numbers[4] = 5
         * numbers[3] = 4
         * numbers[2] = 3
         * numbers[1] = 2
         * numbers[0] = 1
         */
        for (int i = numbers.length - 1; i >= 0; i--) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        /*
         * 12345
         */
        for (int number : numbers) {
            System.out.print(number);
        }
        System.out.println();

        /*
         * [1, 2, 3, 4, 5]
         */
        System.out.println(Arrays.toString(numbers));



        String[] company = {"Google", "Facebook", "Amazon", "Microsoft"};

        /*
         * company[0] = Google
         * company[1] = Facebook
         * company[2] = Amazon
         * company[3] = Microsoft
         */
        for (int i = 0; i < company.length; i++) {
            System.out.println("company[" + i + "] = " + company[i]);
        }

        /*
         * Google
         * Facebook
         * Amazon
         * Microsoft
         */
        for (String c : company) {
            System.out.println(c);
        }

        /*
         * [Google, Facebook, Amazon, Microsoft]
         */
        System.out.println(Arrays.toString(company));

        int[][] twoDimensionalNumbers = {
                {1, 2, 3},
                {4, 5, 6, 7},
                {8, 9},
                {10, 11, 12, 13, 14, 15}
        };

        /*
         * total rows  = 4
         */
        System.out.println("total rows  = " + twoDimensionalNumbers.length);

        /*
         * row 0 length = 3
         * row 1 length = 4
         * row 2 length = 2
         * row 3 length = 6
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.println("row " + i + " length = " + twoDimensionalNumbers[i].length);
        }

        /*
         * row 0 = 1 2 3
         * row 1 = 4 5 6 7
         * row 2 = 8 9
         * row 3 = 10 11 12 13 14 15
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.print("row " + i + " = ");
            for (int j = 0; j < twoDimensionalNumbers[i].length; j++) {
                System.out.print(twoDimensionalNumbers[i][j] + " ");
            }
            System.out.println();
        }

        /*
         * row 0 = [1, 2, 3]
         * row 1 = [4, 5, 6, 7]
         * row 2 = [8, 9]
         * row 3 = [10, 11, 12, 13, 14, 15]
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.println("row " + i + " = " + Arrays.toString(twoDimensionalNumbers[i]));
        }

        /*
         * 1 2 3
         * 4 5 6 7
         * 8 9
         * 10 11 12 13 14 15
         */
        for (int[] ints : twoDimensionalNumbers) {
            for (int num : ints) {
                System.out.print(num + " ");
            }
            System.out.println();
        }

        /*
         * [1, 2, 3]
         * [4, 5, 6, 7]
         * [8, 9]
         * [10, 11, 12, 13, 14, 15]
         */
        for (int[] ints : twoDimensionalNumbers) {
            System.out.println(Arrays.toString(ints));
        }


        int length = 5;
        int[] array = new int[length];
        for (int i = 0; i < 5; i++) {
            array[i] = i + 1;
        }

        /*
         * [1, 2, 3, 4, 5]
         */
        System.out.println(Arrays.toString(array));

    }
}

Fuente de examplehub / java

Respondido el 02 de enero de 21 a las 04:01

Una explicación estaría en orden. - Peter Mortensen

Otro ejemplo completo con una clase de películas:

public class A {

    public static void main(String[] args) {

        class Movie {

            String movieName;
            String genre;
            String movieType;
            String year;
            String ageRating;
            String rating;

            public Movie(String [] str)
            {
                this.movieName = str[0];
                this.genre = str[1];
                this.movieType = str[2];
                this.year = str[3];
                this.ageRating = str[4];
                this.rating = str[5];
            }
        }

        String [] movieDetailArr = {"Inception", "Thriller", "MovieType", "2010", "13+", "10/10"};

        Movie mv = new Movie(movieDetailArr);

        System.out.println("Movie Name: "+ mv.movieName);
        System.out.println("Movie genre: "+ mv.genre);
        System.out.println("Movie type: "+ mv.movieType);
        System.out.println("Movie year: "+ mv.year);
        System.out.println("Movie age : "+ mv.ageRating);
        System.out.println("Movie  rating: "+ mv.rating);
    }
}

Respondido el 02 de enero de 21 a las 04:01

int[] x = new int[enter the size of array here];

Ejemplo:

int[] x = new int[10];
              

Or

int[] x = {enter the elements of array here];

Ejemplo:

int[] x = {10, 65, 40, 5, 48, 31};

Respondido el 02 de enero de 21 a las 04:01

Una matriz puede contener tipos de datos primitivos, así como objetos de una clase, según la definición de la matriz. En el caso de tipos de datos primitivos, los valores reales se almacenan en ubicaciones de memoria contiguas. En el caso de objetos de una clase, los objetos reales se almacenan en el segmento de pila.


Matrices unidimensionales:

La forma general de una declaración de matriz unidimensional es

type var-name[];
OR
type[] var-name;

Creación de instancias de una matriz en Java

var-name = new type [size];

Por ejemplo,

int intArray[];  // Declaring an array
intArray = new int[20];  // Allocating memory to the array

// The below line is equal to line1 + line2
int[] intArray = new int[20]; // Combining both statements in one
int[] intArray = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Accessing the elements of the specified array
for (int i = 0; i < intArray.length; i++)
    System.out.println("Element at index " + i + ": "+ intArray[i]);

Ref: Matrices en Java

Respondido el 02 de enero de 21 a las 04:01

    String[] colors;
    String[] cars = {"red", "blue", "green", "gray"};
    System.out.println(colors[0]);
    colors[0] = "pink";
    
Also to create a two-dimensional array, add each array within its own set of 
curly braces:

    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
    
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
    int x = myNumbers[1][2];
    
You can also use a for loop inside another for loop to get the elements of a 
two-dimensional array: 
    for (int i = 0; i < myNumbers.length; ++i) {
          for(int j = 0; j < myNumbers[i].length; ++j) {
            System.out.println(myNumbers[i][j]);
          }
        }

respondido 06 mar '21, 13:03

Declarar matriz: int[] arr;

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

Declarar matriz multidimensional: int[][] arr;

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

Inicializar una matriz significa especificar su tamaño.

Respondido el 10 de junio de 19 a las 03:06

Es muy fácil declarar e inicializar una matriz. Por ejemplo, desea guardar cinco elementos enteros que son 1, 2, 3, 4 y 5 en una matriz. Puedes hacerlo de la siguiente manera:

a)

int[] a = new int[5];

or

b)

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

por lo que el patrón básico es para la inicialización y declaración por el método a) es:

datatype[] arrayname = new datatype[requiredarraysize];

datatype debe estar en minúsculas.

Entonces, el patrón básico es para la inicialización y declaración por el método a es:

Si es una matriz de cadenas:

String[] a = {"as", "asd", "ssd"};

Si es una matriz de caracteres:

char[] a = {'a', 's', 'w'};

Para float double, el formato de la matriz será el mismo que el de un entero.

Por ejemplo:

double[] a = {1.2, 1.3, 12.3};

pero cuando declara e inicializa la matriz mediante el "método a", tendrá que ingresar los valores manualmente o por bucle o algo así.

Pero cuando lo haga por el "método b" no tendrá que ingresar los valores manualmente.

Respondido el 07 de Septiembre de 19 a las 20:09

int[] SingleDimensionalArray = new int[2]

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

respondido 19 nov., 15:23

Si bien este código puede responder la pregunta, sería mejor explicar cómo resuelve el problema sin presentar a otros y por qué usarlo. Las respuestas de solo código no son útiles a largo plazo. - Bono

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.