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

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

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

Me parece útil que comprenda cada parte:

Type[] name = new Type[5];

Type[] es la tipo de la 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.

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

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

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" );

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

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]

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 Inferencia de tipo de variable local:

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

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

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

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

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

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

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
}

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

Aquí hay muchas respuestas. Estoy agregando algunas formas complicadas de crear matrices (desde un las 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.

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");

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.

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

Or

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

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

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

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

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, los servicios administrativos de

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

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

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.

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.

int[] SingleDimensionalArray = new int[2]

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