Como declarar e inicializar uma matriz em Java?

2055

Como declarar e inicializar uma matriz em Java?

melhor atendimento
fonte
4
Antes de postar uma nova resposta, considere que já existem mais de 25 respostas para esta pergunta. Por favor, verifique se sua resposta contribui com informações que não estão entre as existentes.
janniks 03/02

Respostas:

2684

Você pode usar declaração de matriz ou literal de matriz (mas somente quando você declara e afeta a variável imediatamente, os literais de matriz não podem ser usados ​​para redesignar uma 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 aulas, por exemplo String, é o mesmo:

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

A terceira maneira de inicializar é útil quando você declara a matriz primeiro e depois a inicializa. O elenco é necessário aqui.

String[] myStringArray;
myStringArray = new String[]{"a", "b", "c"};
glmxndr
fonte
33
Qual é o propósito de ter a segunda e a terceira maneira de fazer isso?
Quazi Irfan
123
@iamcreasy Parece que a segunda maneira não funciona com declarações de retorno. return {1,2,3}dá um erro, enquanto return new int[]{1,2,3}funciona bem (assumindo, é claro, que sua função retorna um array inteiro).
Skylar Ittner
1
@ SkylarMT Mas ainda podemos usar a primeira maneira de usar com a declaração de retorno.
Quazi Irfan
6
@iamcreasy Eu escrevi recentemente uma função que retornava uma matriz de ints. Se um erro acontecesse dentro da função, eu queria que ele retornasse um certo valor, mas a função precisava retornar uma matriz. Qual o caminho que funciona para uma declaração de retorno de uma linha? Apenas o terceiro.
Skylar Ittner
5
@apadana No segundo caso, você está criando um objeto anônimo que é definido apenas no escopo incluído (função ou qualquer outra coisa). Depois de devolvê-lo ao chamador, ele não é mais válido. Usando a nova palavra-chave, você aloca o novo objeto da pilha e é válido fora do escopo de definição.
Teukkam
280

Existem dois tipos de matriz.

Matriz unidimensional

Sintaxe para valores padrão:

int[] num = new int[5];

Ou (menos preferido)

int num[] = new int[5];

Sintaxe com os valores fornecidos (inicialização de variável / campo):

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

Ou (menos preferido)

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

Nota: Por conveniência, int [] num é preferível porque indica claramente que você está falando aqui sobre array. Caso contrário, não há diferença. De modo nenhum.

Matriz multidimensional

Declaração

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

Ou

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

Ou

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

Inicialização

 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;

Ou

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

Matriz irregular (ou matriz não retangular)

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

Então, aqui estamos definindo colunas explicitamente.
Outra maneira:

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

Para acessar:

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

Matrizes irregulares são matrizes multidimensionais.
Para obter uma explicação, consulte os detalhes da matriz multidimensional nos tutoriais oficiais do java

Engenheira Isabella
fonte
O primeiro não levará a uma matriz nula / vazia, em vez de uma matriz com valores padrão?
vipin8169
Concordo com esse ponto, e podemos adicionar mais um recurso, podemos alterar o tamanho dinamicamente.
AdamIJK
Eu poderia argumentar com você no ponto em que uma matriz multidimensional é um "tipo" diferente de matriz. É simplesmente um termo usado para descrever uma matriz que contém outras matrizes. As matrizes externas e internas (e as intermediárias, se existirem) são apenas matrizes regulares.
Tim M.
127
Type[] variableName = new Type[capacity];

Type[] variableName = {comma-delimited values};



Type variableName[] = new Type[capacity]; 

Type variableName[] = {comma-delimited values};

também é válido, mas eu prefiro os colchetes após o tipo, porque é mais fácil ver que o tipo da variável é realmente uma matriz.

Nate
fonte
22
Eu concordo com esse ponto. O tipo da variável não é "TYPE", mas na verdade um TYPE [], por isso faz sentido escrevê-lo dessa maneira para mim.
Chet
3
O estilo do Google sugere isso também.
Wener
11
Observe que int[] a, b;não será o mesmo que int a[], b;, um erro fácil de cometer se você usar o último formulário.
Jeroen Vannevel
39

Existem várias maneiras pelas quais você pode declarar uma matriz em Java:

float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};

Você pode encontrar mais informações no site de tutoriais da Sun e no JavaDoc .

Anirudh
fonte
31

Acho útil se você entender cada parte:

Type[] name = new Type[5];

Type[]é o tipo da variável chamada nome ("nome" é chamado identificador ). O "Tipo" literal é o tipo de base, e os colchetes significam que este é o tipo de matriz dessa base. Os tipos de matriz são por sua vez tipos próprios, o que permite criar matrizes multidimensionais como Type[][](o tipo de matriz de Type []). A palavra-chave newdiz para alocar memória para a nova matriz. O número entre os colchetes indica o tamanho da nova matriz e a quantidade de memória a ser alocada. Por exemplo, se Java sabe que o tipo base Typeocupa 32 bytes e você deseja uma matriz de tamanho 5, ele precisa alocar internamente 32 * 5 = 160 bytes.

Você também pode criar matrizes com os valores já existentes, como

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

que não apenas cria o espaço vazio, mas o preenche com esses valores. Java pode dizer que as primitivas são números inteiros e que existem cinco, portanto o tamanho da matriz pode ser determinado implicitamente.

Chet
fonte
Portanto, não é necessário incluir int[] name = new int[5]?
Biscoito Monstro
31

A seguir, mostra a declaração de uma matriz, mas a matriz não é inicializada:

 int[] myIntArray = new int[3];

A seguir, são mostradas a declaração e a inicialização da matriz:

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

Agora, o seguinte também mostra a declaração e a inicialização da matriz:

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

Mas este terceiro mostra a propriedade da criação anônima de objeto de matriz, apontada por uma variável de referência "myIntArray"; portanto, se escrevermos apenas "new int [] {1,2,3}"; então é assim que um objeto de matriz anônimo pode ser criado.

Se apenas escrevermos:

int[] myIntArray;

isso não é declaração de matriz, mas a seguinte declaração completa a declaração acima:

myIntArray=new int[3];
Amit Bhandari
fonte
2
Não há absolutamente nenhuma diferença entre a segunda e a terceira abordagens, exceto que a segunda abordagem funciona quando você também está declarando uma variável. Não está claro o que você quer dizer com "mostra a propriedade da criação anônima de objeto de matriz", mas eles realmente são partes de código equivalentes.
21715 Jon Skeet
4
Além disso, o primeiro trecho faz inicializar a matriz - é a garantia de ter o valor 0 para cada elemento da matriz.
Jon Skeet
Realmente não há diferença entre a segunda e a terceira abordagens?
truthadjustr 15/01
27

Alternativamente,

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

Isso declara uma matriz chamada arrayNamede tamanho 10 (você tem elementos de 0 a 9 para usar).

Thomas Owens
fonte
7
Qual é o padrão para o qual usar? Acabei de descobrir o primeiro e acho terrivelmente enganador: |
Anti Earth
2
Pelo que vale a pena, meu professor disse que a segunda maneira é mais típica em Java e transmite melhor o que está acontecendo; como uma matriz relacionada ao tipo em que a variável foi convertida.
Celeritas
2
Para uma observação lateral: Uma linguagem com mais de uma semântica para declarar uma coisa que significa design de linguagem ruim.
Muhammad Suleman
26

Além disso, caso você queira algo mais dinâmico, existe a interface List. Isso não terá bom desempenho, mas é mais flexível:

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );
Dave
fonte
2
qual é o "<>" chamado na lista que você criou?
Cyprus 27/08/15
O @CyprUS Listé uma classe genérica, tem um tipo como parâmetro, incluído <>. Isso ajuda porque você só precisa definir um tipo genérico uma vez e pode usá-lo com vários tipos diferentes. Para uma explicação mais detalhada, consulte docs.oracle.com/javase/tutorial/java/generics/types.html
Heimdall
15

Existem duas maneiras principais de criar uma matriz:

Este, para uma matriz vazia:

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array

E este, para uma matriz inicializada:

int[] array = {1,2,3,4 ...};

Você também pode criar matrizes multidimensionais, assim:

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};
codecubed
fonte
11

Pegue o tipo primitivo, intpor exemplo. Existem várias maneiras de declarar e intagrupar:

int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};

onde em tudo isso, você pode usar em int i[]vez de int[] i.

Com reflexão, você pode usar (Type[]) Array.newInstance(Type.class, capacity);

Observe que nos parâmetros do método, ...indica variable arguments. Essencialmente, qualquer número de parâmetros é bom. É mais fácil explicar com o 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 do método, varargsé tratado como normal int[]. Type...só pode ser usado em parâmetros de método, portanto int... i = new int[] {}, não será compilado.

Observe que ao passar int[]para um método (ou qualquer outro Type[]), você não pode usar a terceira maneira. Na declaração int[] i = *{a, b, c, d, etc}*, o compilador assume que os {...}meios an int[]. Mas isso é porque você está declarando uma variável. Ao passar uma matriz para um método, a declaração deve ser new Type[capacity]ounew Type[] {...} .

Matrizes multidimensionais

Matrizes multidimensionais são muito mais difíceis de lidar. Essencialmente, uma matriz 2D é uma matriz de matrizes. int[][]significa uma matriz de int[]s. A chave é que, se um int[][]é declarado como int[x][y], o índice máximo é i[x-1][y-1]. Essencialmente, um retangular int[3][5]é:

[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]
HyperNeutrino
fonte
10

No Java 9

Usando diferentes IntStream.iteratee 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]

No Java 10

Usando a inferência de tipo de variável local :

var letters = new String[]{"A", "B", "C"};
Oleksandr Pyrohov
fonte
9

Se você deseja criar matrizes usando reflexões, pode fazer o seguinte:

 int size = 3;
 int[] intArray = (int[]) Array.newInstance(int.class, size ); 
Muhammad Suleman
fonte
Por que você deseja criar uma matriz dessa maneira?
Dorian Gray
9

Declarando uma matriz de referências 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
    }
}
2787184
fonte
7

Matriz é uma lista seqüencial de itens

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

Se é um objeto, então é o mesmo conceito

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

No caso de objetos, você precisa atribuí-lo para nullinicializá-los usando new Type(..)classes como Stringe Integersão casos especiais que serão tratados da seguinte maneira

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

Em geral, você pode criar matrizes Mdimensionais

int [][]..[] array =
//  ^ M times [] brackets

    {{..{
//  ^ M times { bracket

//            this is array[0][0]..[0]
//                         ^ M times [0]

    }}..}
//  ^ M times } bracket
;

Vale ressaltar que a criação de uma Mmatriz dimensional é cara em termos de espaço. Desde quando você cria uma Mmatriz dimensional com Ntodas as dimensões, o tamanho total da matriz é maior que N^M, uma vez que cada matriz tem uma referência e, na dimensão M, existe uma matriz de referências (M-1) dimensional. O tamanho total é o seguinte

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

No Java 8, você pode usar assim.

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

Para criar matrizes da classe Objects, você pode usar o java.util.ArrayList. para definir uma matriz:

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

Atribua valores à matriz:

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

Leia a partir da matriz:

ClassName variableName = arrayName.get(index);

Nota:

variableNameé uma referência à matriz, o que significa que manipular variableNamemanipularáarrayName

para loops:

//repeats for every value in the array
for (ClassName variableName : arrayName){
}
//Note that using this for loop prevents you from editing arrayName

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

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

Declare e inicialize para Java 8 e posterior. Crie uma matriz inteira simples:

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]

Crie uma matriz aleatória para números inteiros entre [-50, 50] e para duplos [0, 1E17]:

int [] a2 = new Random().ints(15, -50, 50).toArray();
double [] a3 = new Random().doubles(5, 0, 1e17).toArray();

Sequência de potência de dois:

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 [], você deve especificar um construtor:

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

Matrizes multidimensionais:

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
fonte
-50 e / ou +50 estão realmente incluídos? Ou seja, o interno está aberto em uma ou nas duas extremidades?
Peter Mortensen
1
-50 está incluído e +50 é excluído. Esta informação do java api "deu origem (inclusive) e encadernou (exclusivo)". Eu uso declaração de intervalo do wiki . Então, acho que será mais correto [-50, 50) #
Kirill Podlivaev
3

Outra maneira de declarar e inicializar ArrayList:

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

Há muitas respostas aqui. Estou adicionando algumas maneiras complicadas de criar matrizes (do ponto de vista do exame , é bom saber disso)

  1. Declarar e definir uma matriz

    int intArray[] = new int[3];

    Isso criará uma matriz de comprimento 3. Como contém um tipo primitivo, int, todos os valores são definidos como 0 por padrão. Por exemplo,

    intArray[2]; // Will return 0
  2. Usando colchetes [] antes do nome da variável

    int[] intArray = new int[3];
    intArray[0] = 1;  // Array content is now {1, 0, 0}
  3. Inicialize e forneça dados para a matriz

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

    Desta vez, não há necessidade de mencionar o tamanho no suporte da caixa. Mesmo uma variante simples disso é:

    int[] intArray = {1, 2, 3, 4};
  4. Uma matriz de comprimento 0

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

    Semelhante para matrizes multidimensionais

    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 colchetes antes da variável:

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

É absolutamente bom se você colocar um suporte de caixa no final:

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

Alguns exemplos

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

Não é obrigatório que cada elemento interno seja do mesmo tamanho.

    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.

Você precisa se certificar de que está usando a sintaxe acima e que a direção a seguir deve especificar os valores entre colchetes. Caso contrário, não será compilado. Alguns exemplos:

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

Outra característica importante é a covariância

    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 tipos referenciados, o valor padrão armazenado na matriz é nulo.

Arundev
fonte
2

Você também pode fazer isso com java.util.Arrays:

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

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

Este é bem simples e direto.

Sylhare
fonte
Não o vi em outras respostas, então pensei em poder adicioná-lo.
Sylhare
1
Uma lista não é uma matriz
Tirno 08/01
Às vezes, as pessoas querem dizer arrays, quando querem uma lista.
Sylhare 8/01
1

Com a inferência de tipo de variável local, você precisa especificar o tipo apenas uma vez:

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

Ou

int[] values = { 1, 2, 3 }
Konstantin Spirin
fonte
Java não possui var.
Cameron Hudson
3
@CameronHudson O Java 10 tem var openjdk.java.net/jeps/286
Konstantin Spirin
1

Matriz tem dois tipos básicos.

Matriz estática: matriz de tamanho fixo (seu tamanho deve ser declarado no início e não pode ser alterado posteriormente)

Matriz dinâmica: nenhum limite de tamanho é considerado para isso. (Matrizes dinâmicas puras não existem em Java. Em vez disso, a Lista é mais recomendada)

Para declarar uma matriz estática de Inteiro, string, float, etc ... use as instruções de declaração e inicialização abaixo.

    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 recursos dinâmicos, você precisa usar List ... List é pura matriz dinâmica e não há necessidade de declarar tamanho no início. Abaixo está a maneira correta de declarar uma lista em JAVA>

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

Zia Muhammad
fonte
1
Obrigado @Matheus por melhorar minhas respostas. Eu pediria que você desse um voto positivo, para que isso alcance mais usuários.
Zia Muhammad
0

Declarar matriz: int[] arr;

Initialize Array: int[] arr = new int[10];10 representa o número de elementos permitidos na matriz

Declarar matriz multidimensional: int[][] arr;

Inicializar matriz multidimensional: int[][] arr = new int[10][17]; 10 linhas e 17 colunas e 170 elementos porque 10 vezes 17 é 170.

Inicializar uma matriz significa especificar o tamanho dela.

kundus
fonte
0

É muito fácil declarar e inicializar uma matriz. Por exemplo, você deseja salvar cinco elementos inteiros 1, 2, 3, 4 e 5 em uma matriz. Você pode fazer isso da seguinte maneira:

a)

int[] a = new int[5];

ou

b)

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

portanto, o padrão básico é para inicialização e declaração pelo método a) é:

datatype[] arrayname = new datatype[requiredarraysize];

datatype deve estar em minúsculas.

Portanto, o padrão básico é para inicialização e declaração pelo método a é:

Se for uma matriz de string:

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

Se for uma matriz de caracteres:

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

Para float double, o formato da matriz será igual ao número inteiro.

Por exemplo:

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

mas quando você declara e inicializa a matriz pelo "método a", terá que inserir os valores manualmente ou por loop ou algo assim.

Mas quando você faz isso pelo "método b", não precisará inserir os valores manualmente.

Syed Salman Hassan
fonte
0

A matriz pode conter tipos de dados primitivos e objetos de uma classe, dependendo da definição de matriz. No caso de tipos de dados primitivos, os valores reais são armazenados em locais de memória contíguos. No caso de objetos de uma classe, os objetos reais são armazenados no segmento de heap.


Matrizes
unidimensionais : a forma geral de uma declaração de matriz unidimensional é

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

Instanciando uma matriz em Java

var-name = new type [size];

Por exemplo

    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
fonte
0

outro exemplo completo com a classe de filmes 😋

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
fonte
-1
int[] x=new int[enter the size of array here];

exemplo:

int[] x=new int[10];

ou

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

exemplo:

int[] x={10,65,40,5,48,31};
Virangaa
fonte
-7
int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]
TreyMcGowan
fonte
6
Embora esse código possa responder à pergunta, seria melhor explicar como ele resolve o problema sem apresentar outros e por que usá-lo. Respostas apenas de código não são úteis a longo prazo.
Bono