Considerar:
int[][] multD = new int[5][];
multD[0] = new int[10];
É assim que você cria uma matriz bidimensional com 5 linhas e 10 colunas?
Eu vi esse código online, mas a sintaxe não fazia sentido.
Considerar:
int[][] multD = new int[5][];
multD[0] = new int[10];
É assim que você cria uma matriz bidimensional com 5 linhas e 10 colunas?
Eu vi esse código online, mas a sintaxe não fazia sentido.
Respostas:
Tente o seguinte:
int[][] multi = new int[5][10];
... que é uma mão curta para algo como isto:
int[][] multi = new int[5][];
multi[0] = new int[10];
multi[1] = new int[10];
multi[2] = new int[10];
multi[3] = new int[10];
multi[4] = new int[10];
Note-se que todos os elementos serão inicializados com o valor padrão para int
, 0
, de modo que o acima são também equivalente a:
int[][] multi = new int[][]{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
new int[][]
na =new int[][]{...}
variante? Podemos apenas escrever ={...}
?
new
palavra-chave.
int array[][] = new int[3][];
VS int array[][] = new int[][3];
?? qual é legal, já que li as duas versões em algum lugar.
Podemos declarar uma matriz bidimensional e armazenar diretamente elementos no momento de sua declaração como:
int marks[][]={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};
Aqui int representa elementos do tipo inteiro armazenados na matriz e o nome da matriz é 'marks'. int é o tipo de dados para todos os elementos representados dentro dos colchetes "{" e "}" porque uma matriz é uma coleção de elementos com o mesmo tipo de dados.
Voltando à nossa declaração escrita acima: cada linha de elementos deve ser escrita dentro das chaves. As linhas e os elementos em cada linha devem ser separados por vírgulas.
Agora observe a instrução: você pode obter 3 linhas e 5 colunas, portanto a JVM cria 3 * 5 = 15 blocos de memória. Esses blocos podem ser referidos individualmente como:
marks[0][0] marks[0][1] marks[0][2] marks[0][3] marks[0][4]
marks[1][0] marks[1][1] marks[1][2] marks[1][3] marks[1][4]
marks[2][0] marks[2][1] marks[2][2] marks[2][3] marks[2][4]
NOTA:
Se você deseja armazenar n elementos, o índice da matriz começa em zero e termina em n-1 . Outra maneira de criar uma matriz bidimensional é declarar a matriz primeiro e depois alocar memória para ela usando o novo operador.
int marks[][]; // declare marks array
marks = new int[3][5]; // allocate memory for storing 15 elements
Combinando os dois acima, podemos escrever:
int marks[][] = new int[3][5];
Você pode criá-los da maneira que os outros mencionaram. Mais um ponto a acrescentar: Você pode até criar uma matriz bidimensional inclinada com cada linha, sem necessariamente ter o mesmo número de colunas, assim:
int array[][] = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[5];
int array[][] = new int[3][];
VS int array[][] = new int[][3];
?? qual é legal, já que li as duas versões em algum lugar.
O idioma mais comum para criar uma matriz bidimensional com 5 linhas e 10 colunas é:
int[][] multD = new int[5][10];
Como alternativa, você pode usar o seguinte, que é mais semelhante ao que você possui, embora seja necessário inicializar explicitamente cada linha:
int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
multD[i] = new int[10];
}
Object[][] ary2d = new Object[5][10];
então, ainda deverá inicializar cada elemento da matriz 2D.
null
caso com segurança para quaisquer não primitivos. Se você deve ou não inicializar cada elemento, depende completamente do seu design. Além disso, apenas para esclarecer - as primitivas não podem ser nulas e são instanciadas para um valor padrão definido se não tiver sido atribuído por você. Por exemplo, um int
não pode ser nulo e quando você diz int i;
sem atribuir um valor, o padrão 0
é usado. Leia aqui
Tentar:
int[][] multD = new int[5][10];
Observe que no seu código apenas a primeira linha da matriz 2D é inicializada como 0. As linhas 2 a 5 nem existem. Se você tentar imprimi-los, conseguirá null
todos eles.
int [][] twoDim = new int [5][5];
int a = (twoDim.length);//5
int b = (twoDim[0].length);//5
for(int i = 0; i < a; i++){ // 1 2 3 4 5
for(int j = 0; j <b; j++) { // 1 2 3 4 5
int x = (i+1)*(j+1);
twoDim[i][j] = x;
if (x<10) {
System.out.print(" " + x + " ");
} else {
System.out.print(x + " ");
}
}//end of for J
System.out.println();
}//end of for i
Em Java, uma matriz bidimensional pode ser declarada como a mesma de uma matriz unidimensional. Em uma matriz unidimensional, você pode escrever como
int array[] = new int[5];
onde int é um tipo de dados, array [] é uma declaração de array e new array
é um array com seus objetos com cinco índices.
Assim, você pode escrever uma matriz bidimensional como a seguir.
int array[][];
array = new int[3][4];
Aqui array
está um tipo de dados int. Em primeiro lugar, declarei em uma matriz unidimensional desses tipos, então uma matriz de 3 linhas e 4 colunas é criada.
No seu código
int[][] multD = new int[5][];
multD[0] = new int[10];
significa que você criou uma matriz bidimensional, com cinco linhas. Na primeira linha, existem 10 colunas. Em Java, você pode selecionar o tamanho da coluna para cada linha conforme desejar.
int rows = 5;
int cols = 10;
int[] multD = new int[rows * cols];
for (int r = 0; r < rows; r++)
{
for (int c = 0; c < cols; c++)
{
int index = r * cols + c;
multD[index] = index * 2;
}
}
Aproveitar!
Tente desta maneira:
int a[][] = {{1,2}, {3,4}};
int b[] = {1, 2, 3, 4};
Esses tipos de matrizes são conhecidos como matrizes irregulares em Java:
int[][] multD = new int[3][];
multD[0] = new int[3];
multD[1] = new int[2];
multD[2] = new int[5];
Nesse cenário, cada linha da matriz mantém o número diferente de colunas. No exemplo acima, a primeira linha conterá três colunas, a segunda linha conterá duas colunas e a terceira linha conterá cinco colunas. Você pode inicializar essa matriz em tempo de compilação, como abaixo:
int[][] multD = {{2, 4, 1}, {6, 8}, {7, 3, 6, 5, 1}};
Você pode facilmente iterar todos os elementos em sua matriz:
for (int i = 0; i<multD.length; i++) {
for (int j = 0; j<multD[i].length; j++) {
System.out.print(multD[i][j] + "\t");
}
System.out.println();
}
Na verdade, o Java não possui matriz multidimensional no sentido matemático. O que o Java possui é apenas uma matriz de matrizes, uma matriz em que cada elemento também é uma matriz. É por isso que o requisito absoluto de inicializá-lo é o tamanho da primeira dimensão. Se o restante for especificado, ele criará uma matriz preenchida com o valor padrão.
int[][] ar = new int[2][];
int[][][] ar = new int[2][][];
int[][] ar = new int[2][2]; // 2x2 array with zeros
Também nos dá uma peculiaridade. O tamanho da sub-matriz não pode ser alterado adicionando mais elementos, mas podemos fazer isso atribuindo uma nova matriz de tamanho arbitrário.
int[][] ar = new int[2][2];
ar[1][3] = 10; // index out of bound
ar[1] = new int[] {1,2,3,4,5,6}; // works