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

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

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

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

Hay dos tipos de matriz.

Matriz unidimensional

Sintaxis para valores predeterminados:

int[] num = new int[5];

O (menos preferido)

int num[] = new int[5];

Sintaxis con los 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 está hablando aquí sobre array. 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} };

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

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 obtener una explicación, consulte los detalles 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 sitio de tutoriales de Sun y JavaDoc .

Creo que es útil si comprende 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 newdice asignar memoria para la nueva matriz. El número entre paréntesis dice qué tan grande será la nueva matriz y cuánta memoria asignar. Por ejemplo, si Java sabe que el tipo base Typetoma 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 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 de ellos, por lo que el tamaño de la matriz se puede determinar implícitamente.

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 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 anónima de objetos de matriz que apunta 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 solo escribimos:

int[] myIntArray;

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

myIntArray=new int[3];

Alternativamente,

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

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

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

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

Tome el tipo primitivo intpor ejemplo. Hay varias formas de declarar y intordenar:

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

Con reflexión, puedes 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, varargsse trata como algo normal int[]. Type...solo se puede usar en parámetros de método, por int... i = new int[] {}lo que no se compilará.

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

Matrices Multidimensionales

Las matrices 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 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]

En Java 9

Usando diferentes IntStream.iteratey IntStream.takeWhilemé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

Uso de la inferencia de tipo de variable local :

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

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

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

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

La matriz 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 asignarlos nullpara inicializarlos usando new Type(..)clases como Stringy Integerson 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 Mdimensionales

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 crear una Mmatriz dimensional es costoso en términos de espacio. Desde cuando crea una Mmatriz dimensional con Ntodas 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

En Java 8 puedes usar así.

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

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

variableNamees una referencia a la matriz que significa que manipular variableNamemanipulará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 le permite editar arrayName(convencional for loop):

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

Declarar e inicializar para Java 8 y posterior. Cree una matriz entera 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 la Cadena [] 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]]

Otra forma de declarar e inicializar ArrayList:

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

Hay muchas respuestas aquí. Estoy agregando algunas formas difíciles de crear matrices (desde el punto de vista del examen , 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 de forma predeterminada. Por ejemplo,

   intArray[2]; // Will return 0

2. Usando 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 hay necesidad de 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 pones 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 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, que la dirección hacia adelante tiene que especificar los valores entre paréntesis. 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 la 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.

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

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 }

La matriz tiene dos tipos básicos.

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

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

Para declarar una matriz estática de Integer, string, float, etc ... use la siguiente declaración y declaraciones 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 características dinámicas, debe usar List ... List es pura matriz dinámica y no es necesario declarar el tamaño al principio. A continuación es 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");

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 veces 17 es 170.

Inicializar una matriz significa especificar el tamaño de la misma.

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:

una)

int[] a = new int[5];

o

si)

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

entonces el patrón básico es para la inicialización y la 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 la 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 flotante doble, el formato de la matriz será el mismo que el entero.

Por ejemplo:

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

pero cuando declara e inicializa la matriz mediante el "método a", deberá 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.

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

Matrices unidimensionales:
la forma general de una declaración de matriz unidimensional es

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

Instanciar una matriz en Java

var-name = new type [size];

Por ejemplo

    int intArray[];    //declaring array
    intArray = new int[20];  // allocating memory to array
    // the below line is equals 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: https://www.geeksforgeeks.org/arrays-in-java/

otro ejemplo completo con 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);


            }

        } 

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

ejemplo:

int[] x=new int[10];

o

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

ejemplo:

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

int[] SingleDimensionalArray = new int[2]

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