Certificação Java SE 7 Programmer I: criando e usando Arrays

Declare, instancie, inicialize e use um array uni-dimensional - Introdução

Boas-vindas ao curso de Certificação Java SE 7 Programmer I: Criando e usando Arrays. Nele, nós aprenderemos como declarar, inicializar, percorrer e acessar os arrays de tipos primitivos em Java. Para declarar um array em Java, nós usamos os colchetes. Por exemplo, int[] idades, essa é uma declaração válida de um array de inteiros que consegue armazenar um conjunto de vários inteiros cujo nome da variável será “idades”.

Existem outras maneiras também de você declarar o array, por exemplo, double pesos[], podemos declarar ainda de outra maneira, long []numeros, também é uma forma válida. E finalmente long[]tamanhos. Todas essas formas são maneiras válidas de você declarar um array em Java. Repare que basta ter um colchete, um par de colchetes abrindo e fechando, ou ao lado do tipo de variável, como em idades, ou após o nome da variável, como em pesos.

Também é possível colocar esse colchete logo antes do nome da variável como eu fiz nos números ou grudar tudo como fiz em tamanhos. Todas essas formas são válidas, você pode colocar o par de colchetes onde você quiser praticamente. Ou depois do tipo, ou antes do nome, depois do nome, tanto faz, todos são formas válidas de declarar um array.

Como inicializamos essa variável? Como criamos um array realmente? Aqui declaramos, vamos aprender a inicializar agora. Vou apagar esses outros arrays, vou ficar apenas com o meu array de idades. Como array é um objeto, a inicialização dele é feita usando o operador new, então new int[10], por exemplo. Essa é uma maneira de você declarar um array de dez posições.

Repare que quando você manda inicializar um array, quando você cria realmente a instância daquele objeto você precisa declarar aqui dentro de colchetes qual a capacidade do array, ou seja, quantas variáveis do tipo int consigo guardar dentro desse array de idades. No caso, dentro desse array de idades consigo guardar dez números inteiros diferentes.

O array tem uma característica interessante. No momento em que você inicia ele, no momento em que você cria esse objeto array, ele já inicia cada uma dessas variáveis, no meu caso cada uma das dez variáveis, com um valor default para aquele tipo. Então, por exemplo, se forem primitivos o valor default será zero para todos os tipos numéricos, ou false para todos os tipos booleanos.

Se o array for um array de referências, um array de objetos, todos os valores serão inicializados com null, que é o valor default para qualquer objeto. Então vamos pegar aqui só para fazer uma verificação. Vou colocar um System.out.println e vou imprimir o que existe dentro do array de idades na posição zero.

Nós vamos focar logo nessa parte de acessar algo do array, mas quando você quer ler um valor de lá de dentro você usa essa sintaxe aqui, pega o nome da variável, que representa aquele array, a variável que aponta para aquele array e indica dentro de colchetes qual a posição daquele array que você quer acessar. Todas as posições do array começam com zero, então se eu compilar e rodar este código temos que o valor que existe dentro desse array é zero, na posição zero de idades está o valor zero, pois zero é o valor default para o tipo inteiro.

O compilador do Java exige apenas que você passe no momento da inicialização a quantidade de posições que você quer naquele array, então ele apenas vai checar se você passou uma certa quantidade, mas ele não verifica se o número que você passou é um número válido para aquela posição ou não.

Eu posso, por exemplo, mandar inicializar o meu array com zero, nesse caso estou criando um array que não tem nenhuma posição dentro dele, é um array que tem tamanho zero, não tem nenhuma posição ali. Inclusive eu posso até mesmo passar para a inicialização do array um número negativo.

Estou tentando criar um array com menos uma posição. É interessante notar que esse código passando menos um compila, então você não tem nenhum erro de compilação se você tentar inicializar um array com um tamanho negativo. Embora na hora que você vai tentar rodar esse array, você vai tentar rodar essa classe, você leva uma exception, negative array size exception. Você não pode passar um valor negativo, mas esse é apenas uma exception, um erro de execução. Compilação ocorre normalmente.

Vou voltar para zero. Outra maneira de inicializar o array pode ser muito útil se você já sabe todos os valores que você pretende passar ali dentro. Se eu já sei, por exemplo, que eu quero passar todos os números pares entre zero e dez, ao invés de declarar o array, descobrir qual o tamanho dessa sequência, colocar o número aqui e depois preencher, se você já sabe exatamente os valores que você vai incluir lá dentro você pode mudar sua declaração e fazer desta maneira, new int[] e logo após os colchetes você abre e fecha uma chave.

Dentro dessa chave você vai colocar a sequência de valores que você quer colocar nesse array, no nosso caso, por exemplo, zero, dois, quatro, seis e oito, seriam os números pares. Essa também é uma maneira válida de iniciar um array, você coloca, por exemplo, new int, abre e fecha colchetes, e entre chaves você já coloca os valores todos que serão incluídos nesse array.

Nesse cenário, por exemplo, se eu pegar e tentar imprimir o que existe na posição um do array, vamos ver o que acontece. Compilo o código, executo normalmente, dois, na posição um desse array temos o valor dois. Isso também é válido se você quiser criar um array de referências.

Vou incluir no meio, por exemplo, um array de cliente, Cliente [] clientes = new Cliente[]{}, e posso passar aqui diversos valores, vou colocar na linha de baixo para ficar mais fácil de ver, mas eu podia passar new Cliente(), null, new Cliente (), essa também é uma maneira válida de inicializar o array.

Então, new cliente, array, new cliente que é a primeira posição que é o objeto cliente, a segunda não tem nada, está null, e a terceira tem outro objeto cliente. Eu vou remover essa linha rapidamente. Tem uma forma até um pouco mais simples ainda de você declarar um array. Se você vai criar o objeto como estou criando o “idades” e já vai incluir os valores lá dentro, você não precisa nem mesmo escrever o new int array, você pode deixar simplesmente int[] idades = {0,2,4,6,8}, esse código também compila.

Vamos testar. Compila normalmente e roda, ele fala que está tudo certo, tem o número dois na posição. Mas para usar essa forma um pouco mais sucinta, sem precisar dar o new explicitamente no objeto, você tem que tomar um pouco de cuidado, você só consegue fazer isso no Java se tudo isso estiver na mesma linha. Eu já estou declarando a variável e estou declarando o array, tudo na mesma linha, declarando a variável do array e inicializando este array todo numa linha só.

Se você quiser fazer isto aqui em duas etapas essa forma não funciona. Vamos fazer um teste aqui. Vou criar um novo array chamado “idades2”. Eu só declarei uma variável chamada idades2. Agora vou inicializar isso, idades2 vai receber o tamanho do array só com as chaves. Vamos ver o que acontece quando tento compilar esse código.

Dá um erro de compilação porque esse tipo de expressão não é válido, você não pode usar esta construção aqui para uma variável que já foi declarada, você só pode usar esse modo de inicializar o array se você inicializar e declarar tudo exatamente na mesma linha.

Para inicializar um array desta maneira nós precisamos colocar o new int[], então eu só posso, se eu for fazer a declaração separada da inicialização, nesse cenário que quero passar os valores, só posso fazer nesta forma que você tem que dar o new explicitamente.

Vamos ver agora como ficou. Vou limpar o console, compila de novo, dessa vez compilou sem nenhum tipo de problema. Tem que ficar bastante atento que a forma de inicializar só com as chaves só funciona se for na mesma linha da declaração da variável.

Vamos entender agora realmente com detalhes como você faz para acessar as posições de um array. O acesso ao array é feito usando essa sintaxe que já andamos testando anteriormente, você pega o nome da variável que representa aquele array e coloca entre colchetes o índice, a posição que você está querendo acessar.

As posições do array são baseadas em zero, então no caso esse array tem quantos valores? Tem cinco valores dentro desse array, então as posições são necessariamente de zero até quatro. Array de cinco posições, de zero até quatro para você acessá-las.

A primeira posição se eu quiser acessar é zero, vamos rodar o código, compila, executa, ele me imprime zero. Se eu quisesse acessar o último valor desse array, quatro, vamos compilar, executar, oito, que é o último número do meu array. A forma de acesso dos arrays é com base nesse índice, usando o colchete, e é sempre de zero até o tamanho daquele array menos um. Se o array tem dez posições é de zero até nove. E assim sucessivamente.

Mas isso tudo que estamos fazendo é com relação à leitura do array. E se eu quisesse colocar um valor ali dentro, como eu faria? Aqui vou fazer uma mudança. Na posição em idades, no array idades, na posição quatro, eu queria incluir outro número. Gostaria de incluir o número dez. Como eu faço? Pega aquele array, naquela certa posição entre colchetes, recebe dez, recebe o número que você quer aí.

Quando eu rodar o meu System.out.println ele vai imprimir o valor que está dentro daquela posição, dez. Então o acesso ao array é feito usando também os colchetes, porém, você usa o igual para atribuir um valor ali dentro. Se você tentar acessar ou para leitura ou para escrita uma posição do array que não existe, vamos ver o que vai acontecer.

Por exemplo, esse array tem cinco posições eu estou tentando acessar a posição dez desse array, essa posição não existe. Vamos entender o que vai acontecer aqui. Repare que o código compila normalmente, o compilador só verifica se você passou um número, ele não sabe se é válido ou não, só vai descobrir isso quando for executar o código.

Vamos executar agora. Ele lança uma exception se você tentar acessar uma posição inválida do array, no caso array index out of bounds exception, você tentou pegar uma posição do array fora do limite dele, fora do tamanho que ele tem declarado dentro dele. E lembra sempre, esse é um erro de execução, na hora de compilar tudo vai funcionar.

Se eu quisesse saber, por exemplo, qual o tamanho então real desse array, como poderíamos fazer? Vamos pegar o array idades, todos os arrays implicitamente dentro deles têm uma propriedade que chama length, uma propriedade pública, e você consegue acessá-la para saber o tamanho declarado desse array. Vamos dar uma olhada como fica.

idades.length, vamos mandar imprimir esse valor e ver o que vai aparecer. Compilo o código, imprime, cinco, então esse é um array que tem cinco posições, o tamanho desse array é cinco então. Essa propriedade pode ajudar bastante quando você quer percorrer um array. Então, vamos pegar e fazer um for, ficaria algo mais ou menos assim, for(int i = 0’; ), eu preciso que esse int saia de zero e vá até o tamanho do meu array, então vou fazer enquanto i for menor que idades.length, enquanto i for menor que length, sendo que ele é cinco, vai até i, quatro no caso.

E i++ no fim para incrementar os valores. Dentro eu poderia imprimir o que existe em cada uma das posições desse array. Vamos colocar para fazer a impressão. Vamos rodar e ver o que vai rolar agora. Compilou, rodou. Cinco é o tamanho que eu imprimi aqui fora, e zero, dois, quatro, seis e dez, porque eu mudei o valor que tinha na última posição.

Usar o length pode ser bem interessante na hora que você quer percorrer o array usando um for. No Java 5 em diante existe uma outra maneira de você percorrer um array, que é o for each. Vamos dar uma olhada em como o for each funciona. Ficaria algo assim a sintaxe. Para cada inteiro idade presente, para cada idade que está no array chamado “idades”, você vai fazer o seguinte, você vai imprimir para mim o valor dessa idade.

Repare que é uma sintaxe muito mais enxuta, e eu já consigo pegar um valor que tem dentro desse array e setar dentro de uma variável, no caso chamada idade. Cada valor que tem dentro do array idades ele coloca na variável int idade e eu uso essa idade para fazer a impressão embaixo.

Vamos executar e ver se dá o mesmo resultado. Rodou, ok, ele foi até o dez, imprimiu até o dez, e logo em seguida imprimiu zero, dois, quatro, seis e dez novamente. É exatamente o mesmo resultado, ele consegue percorrer o array inteiro e imprimir todos os valores.

É bem importante reparar na diferença entre os dois fors, na primeira versão, no for mais tradicional, você tem o i, que seria o índice. E com esse índice eu posso acessar a posição que eu quero do array. É importante perceber que no de baixo você não tem o índice, então esse for each só pode ser usado se você quiser, por exemplo, percorrer o array inteiro. Não tem uma maneira simples de você parar no meio, você teria que usar um break para parar no meio essa execução.

E outra coisa, o for each nesse caso dos arrays você só conseguiria usar como uma forma de leitura. Não teria como eu escrever dentro do array, porque para escrever lá dentro, para acessar igual fiz nessa linha, eu preciso do i, precisaria desse ponteiro, desse contador para saber em qual índice estou no momento. Não tenho isso no for each.

Se o seu objetivo é escrever no array ou você quer saber em que posição você está, em que índice desse array você está, você tem que usar o for tradicional. Se seu objetivo é apenas fazer uma leitura passando por todos os valores do array, aí você pode usar essa segunda opção, você pode usar o for each. Por enquanto é só.

Declare, instancie, inicialize e use um array uni-dimensional - Array de referências - Arrays de referência

Tudo que falamos até agora sobre arrays se aplica a arrays de qualquer tipo. Vamos focar um pouco nos arrays de referência, arrays que não são de tipos primitivos, como ints ou doubles, são arrays que armazenam objetos mesmo, como clientes, provas ou qualquer outra coisa.

Vamos parar e dar uma olhada neles porque eles têm algumas peculiaridades próprias deles. Vamos focar só um pouco para ver essas pequenas diferenças. Tenho aqui no meu código uma classe cliente que é um atributo do tipo string nome. Vamos criar um array para colocar vários clientes no nosso sistema. Então Cliente[] clientes = new Cliente[10].

Está aqui criado um array do tipo de cliente. Até aqui nada de mais. Vamos ver o que acontece quando tento acessar uma posição desse array de clientes. Vamos dar uma imprimida System.out.println(clientes[0]nome), vamos compilar o código. Compilou. Vamos executar e ver o que acontece.

Deu uma exception, deu um null pointer exception. Vamos tentar entender direito o que aconteceu. Quando você cria um array, você declara um array, e quando você inicializa esse array, o array automaticamente inicializa cada um dos slots, cada um dos espaços que tem nesse array com valor default para aquele tipo. O valor default para os tipos de referência, ou seja, para os tipos de objetos, como aqui no caso é um cliente, é null. Ou seja, não tem nada ali dentro, ele inicia com vazio.

E o que eu fiz na linha do meu código? Tentei acessar na posição zero, pega o nome que está dentro daquele objeto. Mas como iniciei o array com tudo ele inicia com null e tentei acessar o nome do que tivesse lá dentro, que no caso é null, não tem nada lá dentro, nesse caso, quando você tenta acessar um objeto que está null você acaba levando um null pointer exception, foi isso que aconteceu.

Tem essa pequena diferença. arrays de primitivos são inicializados com valor default, na maioria dos casos, zero, arrays de variáveis, de referências são inicializadas com null. Tem que tomar cuidado para não acessar nada dentro do array antes de inicializar aquele valor, senão você vai acabar levando null pointer exception.

Vamos então iniciar esse array, colocar valores dentro e depois tentar ler para ver se é mais ou menos a mesma coisa. Vou criar um for(int i = 0; i< clientes.length;i++), que é para você conseguir pegar o tamanho daquele array. Vamos começar a iniciar esse array de clientes. Então, clientes na posição i vai receber um novo cliente, vou colocar um novo objeto do tipo cliente ali dentro.

E clientes na posição i.nome vai receber um nome de cliente, Mário. Esse código vai rodar e vai executar sem nenhum problema, porque agora quando tento acessar o valor nome, quando tento acessar a variável nome dentro do “clientes” na posição i, vai ter um objeto lá dentro, que foi o que eu criei na linha de cima, ou seja, na primeira posição, terei um novo cliente e eu vou acessar esse nome e vou atribuir o valor de Mário.

Isso vai iniciar o nosso array, vamos dar uma percorrida nele, vamos percorrer todos usando for each. Para cada cliente c em meu array de clientes. Para cada cliente dentro do array de clientes vou mandar imprimir o nome desse cliente, println(c.nome), salvou. Vamos rodar e ver o que acontece.

Compilou normal. Todos eles estão com o mesmo nome. Tem sempre que tomar esse cuidado, quando é array de referência inicializar antes de começar a usar. Como o array é de referências, podemos usar um array do tipo “clientes” para guardar qualquer coisa que é um cliente, lembra do polimorfismo.

Então vou colocar uma classe extra no meu código, vou criar uma nova classe do tipo ClienteEspecial, não vou colocar nenhum atributo nela e vou falar que ClienteEspecial extends cliente, ou seja, ClienteEspecial é um cliente. Vamos criar o novo array do tipo cliente, Cliente clientes2[] = new Cliente[5].

Vamos fazer um teste. Em clientes2 na posição zero vou tentar colocar um new cliente, um novo objeto do tipo cliente. Vai funcionar tranquilo, foi o que fizemos até agora, pegamos objeto do tipo cliente, joga no array de clientes. Agora vamos pegar clientes2 na posição um desse array, vou tentar criar um new ClienteEspecial, vou tentar jogar ali dentro um objeto de outro tipo, tipo ClienteEspecial que também é um cliente. Vamos ver se ele vai compilar tranquilo.

Compilou de boa. Então, dentro de um array você consegue jogar objetos que são do subtipo do que aquele array está declarado. Se o meu array é de cliente posso jogar lá dentro cliente ou ClienteEspecial, desde que ele estenda cliente e coisas desse tipo. Se for um array de pessoa, você pode jogar lá dentro, pessoa física, pessoa jurídica, subclasses de pessoa.

Vou jogar o código um pouco para cima para falar de outro assunto. Como nós estamos tratando de arrays de referência, temos que tomar um pouco de cuidado para lembrar que são variáveis de referências. Então vamos fazer um teste. Vou criar um cliente Guilherme igual a new cliente. Criei uma variável do tipo cliente. Vou pegar o Guilherme e vou colocar um nome nele. O nome do Guilherme é Guilherme mesmo.

Vou pegar esse Guilherme, essa pessoa, e vou atribuir ela numa variável daquele meu array, aquele de clientes que estávamos trabalhando agora há pouco. Aliás, vou colocar nesse clientes2 que é o está aparecendo na tela. Clientes2 na posição zero vai receber meu amigo Guilherme.

Guilherme então está na posição zero. Vamos fazer um teste aqui. System.out.println, vamos ver. Eu vou fazer um Guilherme.nome, para imprimir o nome que está na variável Guilherme, e vou copiar e colar. Quero ver o que está no array no meu clientes2 na posição zero, vamos ver o nome de quem está na posição zero.

Vamos compilar esse código e executá-lo. Os dois são exatamente com o mesmo nome. Agora vamos fazer uma alteração. Eu vou pegar a variável Guilherme.nome e vou mudar o nome, ao invés de Guilherme vou colocar Silveira, que é o sobrenome dele.

Aí vou repetir exatamente o mesmo código. Ou seja, vou ver o nome que está dentro do Guilherme e vou olhar o nome que está dentro do array na posição zero. Vamos rodar de novo para dar uma olhada. Compilou, rodou, Silveira e Silveira. Você percebe que quando modifiquei o valor do nome do objeto Guilherme, ele também foi lá e modificou o nome do objeto que estava na posição zero do array. Por que ele fez isso? Eu mudei em um e ele mudou em outro? Não. Porque é o mesmo objeto.

Lembra, o array é de referência, então a variável que guarda não é um valor, não é uma cópia do objeto, é simplesmente um ponteiro, uma referência, e no caso, tanto o caso do Guilherme quanto clientes2 zero, as duas variáveis estão apontando para o mesmo objeto, então se eu modifico aquele objeto, as duas variáveis vão estar apontando para um objeto que foi modificado, as duas vão ter os mesmos valores.

Isso é bem diferente dos primitivos, porque primitivos guarda o valor mesmo do objeto, não uma referência, o valor mesmo. Fica atento quando você estiver mexendo com objeto para lembrar que você modifica uma referência, você modifica aquele objeto usando uma referência, todas as variáveis, todas as referências que apontam para aquele objeto também vão ser modificadas.

Continuando com arrays, vamos fazer um pequeno teste? Vou criar um array de int valores igual a new int array dez, vamos ver o que acontece. O array é um objeto, o que acontece se eu tentar fazer um cast de um array para outro tipo? Tenho um array de inteiros, vou criar um outro array long números e vou tentar jogar o valores ali dentro. Vamos ver o que vai acontecer.

Estou pegando um array de inteiros e vou tentar jogar ele dentro de um array de longs. Lembra, long é muito maior do que int, eu posso pegar um int e jogar dentro de um long. Vamos ver o que acontece quando compilo esse código. Tipos incompatíveis, números não podem ser atribuídos a valores, então você já vê que não tem como fazer esse cast naturalmente, eles são incompatíveis.

Vamos tentar forçar a barra e colocar que é para converter para um long array. O cast normal já não funciona, entre um array de inteiros e um array de long, então vamos forçar o cast, vou colocar que vou pegar esse valor e converter para um array de longs.

Coloquei aqui. Os tipos não são conversíveis, não posso pegar o array de valores e tentar fazer um cast dele para um array de long. Então quando estamos falando de arrays de tipos primitivos, não dá para fazer cast neles, não tem como você fazer esse negócio funcionar.

Vamos fazer outro exemplo. E se eu estiver falando de objetos? Será que é possível fazer esse cast ou não? Vou criar um array de string nomes e vou iniciar esse array, vou usar uma inicialização mais simples. Mário e Guilherme, criei um array de strings chamado long, só vou comentar a linha de cima para não dar problema quando eu continuar executando esse código.

Tenho o array de strings nomes, vou criar embaixo um array de object, chamado objetos. E embaixo vou fazer “objetos”, vai receber nomes. E será que esse código vai compilar ou não? Vamos dar uma olhada. Compilou, sem nenhum tipo de problema.

Então quando o array é de referência, ou seja, array de objetos, você consegue fazer o cast de um para o outro desde que os tipos sejam compatíveis. String é um object, então consigo pegar um array de string e jogar dentro de um array de object, vai funcionar sem nenhum problema.

Se eu tentasse pegar esse array de string e jogar dentro de um array de long também não daria certo porque são tipos completamente incompatíveis. O cast funcionou, mas será que consigo ler os valores desse array? Vamos dar uma olhada. Para cada object o, vou ler do array de objetos, vamos pegar esse array e vamos dar System.out.println, vamos ver o que tem dentro desse o. Coloquei Mário e Guilherme.

Compilou, vamos executar. Mário e Guilherme. Além de você conseguir fazer o cast você também pode usar os valores dentro normalmente sem nenhum tipo de problema. Te vejo na próxima.

Declare, instancie, inicialize e use um array multi-dimensional - Arrays multidimensionais

Os arrays em Java podem ter mais de uma dimensão. Vamos aprender a como declarar esse tipo de array, int[][] tabela. Nesse caso aqui eu acabei de declarar um array com duas dimensões. Repare que para cada dimensão que você quer colocar no array você coloca um conjunto de colchetes, um par de colchetes abrindo e fechando.

A tabela no caso é um array com duas dimensões. Podemos declarar assim também int[][] cubo[], um cubo seriam três dimensões. Repare que posso colocar os colchetes tanto logo após o tipo da variável quanto após o nome da variável. Então você pode colocar de qualquer lugar. E não precisa necessariamente ser todos no mesmo local, igual eu fiz com cubo. Eu coloquei dois antes e um depois. Você pode colocar os colchetes onde você quiser.

Vamos criar só mais um aqui, int [][] hipercubo[][], tem múltiplas dimensões, quatro dimensões nesse caso. Todas essas declarações são válidas e você pode usar isso para declarar um array com múltiplas dimensões.

Agora que vimos como você declara um array de múltiplas dimensões, vamos ver como faz para iniciar esses arrays. Vou pegar primeiro nosso tabela = new int[], a diferença é que como ele tem múltiplas dimensões você pode inicializar ele de várias maneiras. Uma forma seria você já inicializa as duas dimensões desse array. No caso aqui esse array tabela é uma tabela de dez por cinco. Então eu já inicializei e já coloquei todos os valores ali dentro. Já tem um array de dez com outro array de cinco, cada posição desse array de dez tem outro array de cinco posições.

Podemos pensar que arrays multidimensionais são arrays de arrays. Então, dez por cinco. Essa é a forma mais tradicional de você inicializar um array. Você também pode fazer o seguinte. Vou fazer com o cubo, se você quiser cubo = new int[10][][], você pode inicializar apenas uma dimensão desse array.

Aqui essa declaração é válida, apesar de ficar meio esquisita. Você pode falar que só a primeira dimensão tem dez posições, enquanto as outras dimensões você vai deixar para inicializar posteriormente. Também é um tipo de declaração totalmente válido.

O último tipo é você fazer aquela inicialização já colocando os valores dentro do array. Vamos criar um novo array int[][] teste = new int[][], vou colocar as duas dimensões, lembra que você tem que falar quanto tem ali dentro, senão você pode inicializar o array aqui já passando todos os valores.

Eu poderia fazer o seguinte, dentro desse array vou ter um array cujos valores são 1, 2, 3, esse seria o primeiro, um array de três posições dentro da primeira dimensão. Vamos fazer mais um pouco 4, 5, 6, e um outro 7, 8, 9. O que eu fiz aqui? Qual a ideia desse array de teste?

É um array de três dimensões por duas dimensões. Sendo que na primeira tem 1, 2, 3, então é um array cuja na primeira dimensão tem três dimensões. Depois outro array de três e um outro array de três, então fica três por três. Tem que tomar um pouco de cuidado para balancear essas chaves. Você abriu a chave, tem que fechar a chave, prestar bastante atenção se está tudo no lugar certo.

E por fim, nem todo array precisa ser necessariamente quadrado. Nós já tínhamos criado um array de dez por cinco, mas ele pode assumir dimensões completamente esquisitas. Vamos criar mais um array estranho e esse array estranho vou inicializar com new int[2][] não sei quantas posições na outra dimensão, um array de dois por não sei quanto.

Vamos acessar ele aqui e já iniciar os valores. Então o meu array estranho, na posição 0, na primeira posição, vou incluir ali dentro um novo array de inteiros de tamanho vinte. Você vê que se você não inicializa o array direto, passando as duas dimensões, você precisa em cada posição inicializar com o outro array ali dentro, com o tamanho que você quer.

Eu criei, na posição 0, um array de vinte. Então na 0 é dois por vinte, só na primeira posição. Agora vamos adicionar outro na posição 1, na segunda posição do meu array, dez. Esse array mesmo é um caso bem estranho, ele é dois por vinte, mas só a primeira posição tem vinte, a segunda acaba tendo dez. Não necessariamente precisam os dois terem o mesmo tamanho.

Vamos percorrer esse array também para ver como fica. Então, for(int i=0; i<estranho.length; i++). Agora vamos começar a percorrer. Vou imprimir System.out.println, vou imprimir o tamanho de cada uma das posições desse array estranho, então estranho[i]length, vamos compilar esse código.

O resultado é vinte e dez. Que é realmente o que esperávamos, afinal colocamos que a primeira posição do array tem vinte, a segunda posição tem dez. Quando você trabalhar com arrays de múltiplas dimensões lembre sempre, ele pode ser quadrado, pode ser retangulares e eventualmente podem ter tamanhos totalmente variados, não necessariamente precisa ser uma coisa quadrada ali.

Sobre o curso Certificação Java SE 7 Programmer I: criando e usando Arrays

O curso Certificação Java SE 7 Programmer I: criando e usando Arrays possui 75 minutos de vídeos, em um total de 31 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Declarar, inicializar e usar um array unidimensional
• Declarar, inicializar e usar um array multidimensional
• Declare e use uma ArrayList