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

2055

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

bestattendance
fuente
44
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 contribuya con información que no se encuentre entre las respuestas existentes.
Janniks

Respuestas:

2684

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"};
glmxndr
fuente
33
¿Cuál es el propósito de tener la segunda y la tercera forma de hacerlo?
Quazi Irfan
123
@iamcreasy Parece que la segunda forma no funciona con las declaraciones de devolución. return {1,2,3}da un error, mientras return new int[]{1,2,3}funciona bien (suponiendo, por supuesto, que su función devuelva una matriz entera).
Skylar Ittner
1
@SkylarMT Pero aún podemos usar la primera forma de usar con la declaración de devolución.
Quazi Irfan
66
@iamcreasy Recientemente escribí una función que devolvió una serie de entradas. Si ocurrió un error dentro de la función, quería que devolviera un cierto valor, pero la función necesitaba devolver una matriz. ¿De qué manera funciona para una declaración de devolución de una línea? Solo el tercero.
Skylar Ittner
55
@apadana En el segundo caso, está creando un objeto anónimo que solo se define en el ámbito de inclusión (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
280

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

Ingeniero Isabella
fuente
¿El primero no conducirá a una matriz nula / vacía, en lugar de una matriz con valores predeterminados?
vipin8169
Estoy de acuerdo con ese punto, y podemos agregar una característica más, podemos cambiar el tamaño dinámicamente.
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 utilizado para describir una matriz que contiene otras matrices. Tanto las matrices externas como las matrices internas (y las intermedias, si existen) son solo matrices regulares.
Tim M.
127
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.

Nate
fuente
22
Estoy de acuerdo en ese punto. El tipo de la variable no es "TYPE", sino un TYPE [], por lo que tiene sentido escribirlo de esa manera para mí.
Chet
3
El estilo de Google sugiere esto también.
Wener
11
Tenga en cuenta que int[] a, b;no será lo mismo int a[], b;, un error fácil de cometer si utiliza el último formulario.
Jeroen Vannevel
39

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 .

Anirudh
fuente
31

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.

Chet
fuente
Entonces, ¿no es necesario incluir int[] name = new int[5]?
Cookie Monster
31

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];
Amit Bhandari
fuente
2
No hay absolutamente ninguna diferencia entre el segundo y el tercer enfoque, aparte de eso, el segundo enfoque solo funciona cuando también se declara una variable. No está claro qué quiere decir con "muestra la propiedad de la creación anónima de objetos de matriz", pero realmente son piezas de código equivalentes.
Jon Skeet
44
Además, el primer fragmento hace inicializar la matriz - es la garantía de tener el valor 0 para cada elemento de la matriz.
Jon Skeet
¿Realmente no hay diferencia entre el segundo y el tercer enfoque?
truthadjustr
27

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

Thomas Owens
fuente
77
¿Cuál es el estándar para usar? Acabo de descubrir lo primero, y lo encuentro terriblemente engañoso: |
Anti Earth
2
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 de la variable se convirtió como.
Celeritas
2
Para una nota al margen: un lenguaje que tiene más de una semántica para declarar una cosa que significa mal diseño del lenguaje.
Muhammad Suleman
26

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" );
Dave
fuente
2
¿Cómo se llama "<>" en la lista que creó?
Cyprus
@CyprUS Listes una clase genérica, tiene un tipo como parámetro, incluido <>. Eso ayuda porque solo necesita definir un tipo genérico una vez y luego puede usarlo con múltiples tipos diferentes. Para obtener una explicación más detallada, consulte docs.oracle.com/javase/tutorial/java/generics/types.html
Heimdall el
15

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 ...} ...};
codecubed
fuente
11

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]
Hiperneutrino
fuente
10

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"};
Oleksandr Pyrohov
fuente
9

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

 int size = 3;
 int[] intArray = (int[]) Array.newInstance(int.class, size ); 
Muhammad Suleman
fuente
¿Por qué querrías crear una matriz de esa manera?
Dorian Gray
9

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

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
Khaled.K
fuente
7

En Java 8 puedes usar así.

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

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
}
Samuel Newport
fuente
5

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]]
Kirill Podlivaev
fuente
¿Se incluyen realmente -50 y / o +50? Es decir, ¿está abierto el interno en uno o ambos extremos?
Peter Mortensen
1
-50 está incluido y +50 está excluido. Esta información de Java API "da origen (incluido) y obligado (exclusivo)". Yo uso declaración de intervalo de wiki . Así que creo que será más correcto [-50, 50)
Kirill Podlivaev
3

Otra forma de declarar e inicializar ArrayList:

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};
Clement.Xu
fuente
2

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.

Arundev
fuente
2

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.

Sylhare
fuente
No lo vi en otras respuestas, así que pensé que podría agregarlo.
Sylhare
1
Una lista no es una matriz
Tirno
A veces las personas se refieren a matrices, cuando quieren una lista.
Sylhare
1

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 }
Konstantin Spirin
fuente
Java no tiene var.
Cameron Hudson
3
@CameronHudson Java 10 tiene var openjdk.java.net/jeps/286
Konstantin Spirin
1

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

Zia Muhammad
fuente
1
Gracias @Matheus por mejorar mis respuestas. Le pediría que votara esto, para que esto pueda llegar a más usuarios.
Zia Muhammad
0

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.

Kundus
fuente
0

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.

Syed Salman Hassan
fuente
0

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/

Zgpeace
fuente
0

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


            }

        } 
Dupinder Singh
fuente
-1
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};
Virangaa
fuente
-7
int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]
TreyMcGowan
fuente
66
Si bien este código puede responder la pregunta, sería mejor explicar cómo resuelve el problema sin presentar otros y por qué usarlo. Las respuestas de solo código no son útiles a largo plazo.
Bono