Declarar e manipular um conjunto de elementos, de maneira bem resumida, é a função de um Java array. Sua importância está na facilidade de manipulação de vetores durante o desenvolvimento das aplicações. É uma das estruturas mais comuns estudadas durante o processo de aprendizado de pessoas desenvolvedoras.
Mesmo não sendo escassas as informações sobre o tema, as possibilidades de uso de um array podem ser um pouco confusas para o entendimento daqueles que iniciaram o caminho da programação agora. São variados tipos de dados, estruturas mais complexas e funções mais detalhadas em relação a temas ainda mais básicos.
Se você se encaixa nesse perfil, não tenha medo, é muito mais simples do que pode imaginar. Mas se você é mais experiente, saiba que, neste guia, abordaremos assuntos bastante relevantes e que podem trazer pequenos detalhes capazes de influenciar o seu dia a dia profissional ou acadêmico, com exemplos práticos que ilustram toda a teoria.
Confira os principais tópicos que exploraremos:
- O que é um array em Java?
- Qual a sintaxe do Java array?
- Quais os tipos de arrays em Java?
- Quais as características dos arrays em Java?
- Como declarar arrays em Java?
- Como descobrir o tamanho de um array?
- Como inicializar um array?
- Como alterar elementos de um array?
- Em que usamos o array em nosso dia a dia?
Tenha uma boa leitura e sua IDE preparada para seguir os exemplos de nosso guia!
O que é um array em Java?
Quando precisamos armazenar mais de um valor em uma variável, fazemos isso utilizando um array. Essa palavra pode ser traduzida de forma livre como um “conjunto de variedades” — como qualquer conjunto, implica na existência de alguns elementos agrupados, portanto.
Nos arrays, cada elemento desse grupo tem a sua posição. Dessa forma, para armazenar esse conjunto de valores em uma única variável, sem precisar declarar cada uma para um valor, usamos um array.
Qual a sintaxe do Java array?
Em Java, quando utilizamos um array, escrevemos sua representação com o uso de chaves — “[elemento1, elemento2 …]”. Podemos definir uma array sem número especificado, apenas indicando que aquela variável é um array. A sintaxe é a seguinte:
tipo do objeto, como String, Integer, etc. [] nome de nosso array
Para facilitar o entendimento, veja um exemplo aplicado:
String[] nomes;
No exemplo acima, apenas definimos um array — sem determinar elementos ou número de posições para serem ocupadas. Poderemos preencher esses espaços no array apenas os designando durante o desenvolvimento do código. Assim:
String[] nomes = {"Darci", "Cris", "Alex", "Juraci"}
Quando precisarmos acessar alguns desses elementos pertencentes às mesmas variáveis, buscamos diretamente a variável do array “nome”. Vamos a um exemplo prático, bem simples, para ajudar no entendimento:
public class Main {
public static void main(String[] args) {
String[] carros = {"Fusca", "Brasilia", "Gurgel"};
System.out.println(carrs[0]);
}
}
O primeiro elemento de um array começa sempre a ser contado em 0. Nesse caso, quando pedimos a posição zero (“[0]”) do array “carros”, a saída no console desse código será:
Fusca
Quais os tipos de arrays em Java?
Durante o desenvolvimento de aplicações, muitas vezes, não temos a possibilidade de alocar todos os elementos de que precisamos para o funcionamento do sistema durante a programação. Nesses casos, podemos fazer um array vazio, mas com “espaços” para alocar cada elemento.
Sendo um objeto, um array em Java, não pode apenas ser declarado — para definirmos o tamanho de nosso array sem a necessidade de criar os elementos, precisamos definir o número de posições, dessa forma:
String[] nomes = [4]
Já para criar um novo array, por sua vez, usamos a expressão “new”, um comum operador do Java:
int[] novo_array = new int[100];
Aqui, temos um array simples, o qual tem 100 posições possíveis de serem ocupadas. Isso é chamado “Index” — o índice do array existe, basicamente, para que seja possível enumerar e classificar cada um dos valores contidos nele.
Mas antes de criarmos nosso array, para que possamos manipulá-lo, precisamos saber alguns detalhes importantes. Por exemplo, um array pode conter apenas uma linha de elemento, enquanto outros serão preenchidos da mesma forma que matrizes. Essa é a diferença entre arrays unidimensionais e multidimensionais. Confira, a seguir, alguns detalhes.
Arrays unidimensionais
Arrays de uma única dimensão são vetores que têm um único índice como identificador para cada elemento contido em um array. No caso do exemplo de que falamos logo acima, a forma que usamos para declarar um array sem determinar seus elementos, mas apenas as posições que serão ocupadas, será da seguinte maneira:
public class MyClass {
public static void main(String args[]) {
int[] array_de_uma_dimensão = new int[5];
}
}
Repare que, nesse exemplo, criamos um array com o nome de “array_de_uma_dimensão”, e percebemos que ele terá 5 posições possíveis de serem ocupadas. Mas será que podemos criar objetos como tabelas, com mais de uma linha de índices? É sobre isso que falaremos, a seguir.
Arrays multidimensionais
Saiba que também podemos operar com arrays de mais de uma dimensão. É possível compará-los a tabelas. Isso porque você pode enumerar múltiplos índices em um mesmo array, formando, assim, diversas linhas e colunas, com cada espaço sendo pertencente a um elemento. Para declararmos um array multidimensional, fazemos dessa forma:
public class MyClass {
public static void main(String args[]) {
int[][] array_multimensão = new int[5][5];
}
}
Aqui, temos a aplicação de um novo array, mas com duas dimensões — ou dois índices. Eles acabam formando uma tabela 5 X 5, com 25 posições possíveis, nesse caso.
Quais as características dos arrays em Java?
Para um bom funcionamento e maior dinâmica durante as operações realizadas por meio de nossos sistemas em Java, temos quase uma inumerável série de características que permeiam os recursos para esse devido aproveitamento. Para facilitar o seu entendimento dessas questões, trazemos, em nosso guia, algumas das principais delas, as quais mais interferem ao desenvolvermos serviços com essas estruturas de dados. Confira!
Elementos do array e tipos de dados
É cada unidade do tipo de dado inserido, podendo ser números (integer), caracteres (string), decimais (double) ou verdadeiro/falso (boolean). Cada elemento ocupa uma posição determinada no índice e pode ser acessado a partir da manipulação do array.
Índices do array
O índice do array pode ser explicado como uma lista, ordenada de alguma maneira ou não, dos elementos contidos em um dado array. Os arrays podem ter apenas um ou vários índices.
Dimensão do array
A dimensão de um array é relacionada à sua quantidade de índices contidos. Se um array tem um único índice, ele é chamado unidimensional, e caso tenha mais de um, multidimensional.
Como declarar arrays em Java?
De maneira geral, definir arrays em Java é a mesma coisa que realizar a declaração de variáveis. Podemos declarar um array de uma única dimensão — ou vetor, como também é chamado — das seguintes formas:
tipo do dado nomeDoArray [opcional: quantidade de elementos];
tipo do dado nomeDoArray {elementos separados por vírgula};
tipo do dado [opcional: quantidade de elementos] nomeDoArray;
Veja um exemplo que envolve a aplicação de várias formas de um array — repare nos comentários feitos ao longo do código:
public class Main {
public static void main(String[] args) {
int[] a = new int[4];
int[] b;
b = new int[10];
// Declarando mais de um array por vez:
int[] r = new int[44], k = new int[23];
//Inicializando valores do array:
int[] inicia_Valores = {2,52,504,7,88,9,6,14,666};
//Declarando array tipo interger (números inteiros:)
int[] array_exemplo_N_inteiro;
//Definindo 9 posições para nossos números e inicializando cada elemento:
array_exemplo_N_inteiro = new int[9];
array_exemplo_N_inteiro [0] = 100;
array_exemplo_N_inteiro [1] = 85;
array_exemplo_N_inteiro [2] = 88;
array_exemplo_N_inteiro [3] = 93;
array_exemplo_N_inteiro [4] = 123;
array_exemplo_N_inteiro [5] = 952;
array_exemplo_N_inteiro [6] = 344;
array_exemplo_N_inteiro [7] = 233;
array_exemplo_N_inteiro [8] = 622;
//imprimir no console as posições 8 e 4:
System.out.println(array_exemplo_N_inteiro[8]);
System.out.println(array_exemplo_N_inteiro[4]);
}
}
Como descobrir o tamanho de um array?
Como já era de se esperar, há diversas maneiras de se contabilizar os elementos contidos em um array. A mais óbvia, para aquelas pessoas já familiarizadas ao mundo da programação, é a criação de uma variável, e usar um laço de repetição para modificá-la a cada elemento. Ficaria dessa maneira:
public class Main {
public static void main(String[] args) {
int contador = 0;
String[] carros = {"Fusca", "Kombi", "Gol", "Ferrari"};
for (String i : carros) {
contador = ++contador;
}
System.out.println(contador);
}
}
Veja que, nesse exemplo, temos como resultado a impressão do número 4 no console, indicando a presença de 4 elementos. Perceba que a contagem se deu a partir do laço for utilizado na variável “contador”.
Outra maneira possível e bastante optada pelas pessoas desenvolvedoras é usar o método length(). Com ele, acessamos diretamente a informação referente à quantidade de posições ocupadas em um array. Trazemos um exemplo para facilitar seu entendimento:
public class Main {
public static void main(String[] args) {
String[] carros = {""Fusca", "Kombi", "Gol", "Ferrari"};
System.out.println(carros.length);
}
}
A saída será a mesma da anterior:
4
Uma última maneira é o método size(). Com ele, acessamos diretamente o tamanho do número de posições atualmente ocupadas em um array. Trazemos um exemplo prático para que você possa entender melhor:
import java.util.*;
public class Main {
public static void main(String[] arg)
{
List<Integer> lista = new array<Integer>();
lista.add(1);
lista.add(2);
lista.add(3);
lista.add(4);
lista.add(5);
System.out.println("Todos elementos " + lista);
int tamanho = lista.size();
System.out.println("Tamanho total dos elementos: = " + tamanho);
}
}
O console exibirá a seguinte saída para o código:
Todos elementos: [1, 2, 3, 4, 5]
Tamanho total dos elementos: = 5
O método size() foi utilizado na declaração da variável tamanho — dessa forma, é possível percebermos que o método já tem a operação de contagem desses elementos em seus processos internos, não sendo necessário contarmos cada um deles.
Como inicializar um array?
A melhor forma de inicializar um array, de acordo com as melhores práticas, é utilizar o operador new, como já apresentamos:
int[] novo_array = new int[100];
Precisamos detalhar, primeiramente, o tipo de dado (inteiros, caracteres, booleanos ou decimais), seguido dos colchetes (“[ ]”). Após isso, damos um nome para nosso array e usamos o sinal de igual para associá-lo a um novo conjunto de elementos, de determinado tipo de dado.
Precisamos dar a quantidade de posições disponíveis nesse conjunto entre os colchetes, que, no caso do exemplo acima, seria o valor de 100. Há outras formas de inicializar o array, e já descrevemos as principais delas, na seção “Qual a sintaxe do Java array” — se você perdeu essa parte, vale a pena voltar e conferir!
Como percorrer os elementos de um Array?
Na maioria das vezes, usamos o laço for aprimorado — “enhanced-for loop”, ou também conhecido por forEach Loop — para percorrer cada elemento de nosso array. No caso que apresentaremos, percorremos cada elemento de um array e, como já fizemos anteriormente, usaremos uma variável para armazenar o valor que precisamos.
Confira o exemplo, na sequência:
public class Somando_os_elementos {
public static void main(String[] args) {
int[] array = {44, 33, 55, 66, 77, 88, 99, 0, 1};
int total = 0;
//Percorrendo cada um dos elementos com forEach e armazenando e somando-os na variável “total”:
for(int i : array)
total += i;
System.out.printf("Total: %d\n", total);
}
}
Como alterar elementos de um array?
Podemos realizar a alteração de nossos elementos em um array de diversas formas. Uma delas é a partir do índice, buscando alterar o valor de dada posição ocupada em nosso array.
A partir do uso de um laço for, percorrendo cada posição em nosso array, usamos uma variável para armazenar temporariamente os elementos para que possamos manipulá-los, seja para modificá-los no valor, seja na posição. Na seção de exemplos que trazemos, o primeiro deles é a aplicação desse método. Você pode ir até lá para conferir e depois voltar aqui.
Outra maneira, amplamente utilizada, é a implementação do método skip() — a partir do Java na versão 8. O método skip descarta elementos e retorna aqueles restantes:
import java.util.*;
public class Main {
public static void main(String[] args) {
int [] array = { 0, 1, 2, 3, 4, 5, 6, 7 ,8 };
Arrays.stream(array).skip(1).forEach(System.out::println);
}
}
No exemplo acima, além de usarmos um método forEach para iterar cada elemento, adotamos o método skip() para retirar o elemento que ocupa a posição 1, no caso, o número 1. O console nos mostrará a seguinte saída:
1
2
3
4
5
6
7
8
Podemos, também, mudar nossos arrays bem facilmente com o uso da função Collections.rotate(). Ela realizará a rotação da ordem de um array — definiremos quantas posições serão puladas, veja o exemplo:
import java.util.*;
public class Main {
public static void main(String args[]){
String [] strArray = {"Primeiro","Segundo","Terceiro","Último"};
System.out.println("Lista normal : " + Arrays.toString(strArray));
List<String> list = Arrays.asList(strArray);
Collections.rotate(list, 3);
System.out.println("Lista manipulada " + list);
}
}
A saída no console será a seguinte:
Lista normal: [Primeiro, Segundo, Terceiro, Último]
Lista manipulada: [Segundo, Terceiro, Último, Primeiro]
Saiba que existe outra maneira, e essa é bem mais simples. Basta definirmos um novo valor para determinada posição, assim:
String[] nomes = {"Juci", "Darci", "Alex", "Frye"};
nomes[0] = "Benedita";
System.out.println(nomes[0]);
Saída no console:
Benedita
Aqui, a saída não será a posição zero, que no caso, seria “Juci”, mas sim, “Benedita” — a posição zero, representada por “[0]” foi, simplesmente, substituída.
Confira 3 exemplos de aplicação para o Java array
Vamos à prática para que você entenda bem do que estamos falando.
Exemplo 1: Mudando a ordem das estruturas
Aqui, usamos o método ShiftToRight() para trocar os elementos de lugar em relação à posição 4 do array, em que a quarta posição acaba sendo a primeira— lembrando, mais uma vez, que iniciamos a contagem dos elementos em um array a partir de 0:
import java.util.Arrays;
public class Main {
public static void main(String args[]){
int [] array_a = {1,2,3,4,5};
int n = 4;
System.out.println("Nosso array é: "+Arrays.toString(array_a));
ShiftToRight(array_a,n);
}
public static void ShiftToRight(int a[],int n){
int temp = a[n];
for (int i = n; i > 0; i--) {
a[i] = a[i-1];
}
a[0] = temp;
System.out.println("Mas, usando o ShiftToRitgh, fica: "+Arrays.toString(a));
}
}
O resultado será assim:
Nosso array é: [1, 2, 3, 4, 5]
Mas, usando o ShiftToRitgh, fica: [5, 1, 2, 3, 4]
Exemplo 2 — usando arrays multidimensionais
A seguir, um exemplo simples do uso de arrays multidimentsionais e como podemos manipulá-los:
public class Main {
public static void main(String[] args) {
int[][] arrayn1 = { { 9,8,7 }, { 6, 5, 4 } };
int[][] arrayn2 = { { 0, 1 }, { 5 }, { 3, 4, 9} };
//imprime o array 2 em cada linha
System.out.println("Array 1:");
outputArray( arrayn1 );
//imprime o array 2 em cada linha
System.out.println("Array 2:");
outputArray( arrayn2 );
}
public static void outputArray(int[][] array)
{
for(int linha = 0; linha < array.length; linha++)
{
for( int coluna = 0; coluna < array[linha].length; coluna++)
System.out.printf("%d ", array[linha][coluna]);
System.out.println();
}
}
}
No exemplo, fazemos a iteração pelos elementos do array para cada linha e cada coluna que é processada. Como podemos perceber, o laço for será realizado tanto na linha quanto na coluna. Teremos a seguinte saída no console:
Array 1
9 8 7
6 5 4
Array 2:
0 1
5
3 4 9
Exemplo 3 — qual o tamanho do meu array?
Aqui, veremos como contar cada elemento de nosso array. Podemos fazer a maior parte de operações matemáticas para contabilizá-los ou compará-los no tamanho. A seguir, um exemplo bem simples do que é possível ser feito com esses métodos que apresentamos:
public class Main {
public static void main(String[] args) {
int[] array_1 = { 20, 25, 66, 33, 3, 6, 0, 1, 2, 3, 4 };
int[] array_2 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
if(array_1.length > 2){
System.out.println("Nosso array 1 tem mais de uma posição!");
System.out.println("\nNosso array 2 tem o seguinte número de posições: "+array_1.length);
}else{
System.out.println("Tamanho do ArrayDois - Menor que 1!");
}
}
}
A saída que veremos no console será essa:
Nosso array 1 tem mais de uma posição!
Nosso array 2 tem o seguinte número de posições: 10
Em que usamos o array em nosso dia a dia?
É bastante complicado explorarmos o uso de array no dia a dia das pessoas programadoras. Isso se deve ao fato de a aplicação desse recurso estar intimamente ligada a uma imensa variedade de recursos utilizados por diversas das funções, métodos e classes disponíveis nos inúmeros pacotes que atentem à linguagem Java.
A cada atualização da linguagem, temos vários desse elementos como novidade. É verdade que veremos muito sua aplicação quando trabalhamos no desenvolvimento de jogos e coisas mais simples — o princípio didático ainda se torna bastante expoente para o array.
Como já temos estruturas e frameworks que lidam mais facilmente com os arrays, optamos por eles na maioria das vezes. Isso porque trarão maior dinamicidade, confiança e agilidade para o andamento de nossa aplicação que está sendo desenvolvida.
No decorrer de nosso guia, vimos a importância do Java array no desenvolvimento de aplicações e que as possibilidades de suas funções são quase infinitas. Abordamos aspectos teóricos e trazemos exemplos práticos de uso de arrays para explicá-los. Conferimos suas principais características de funcionamento e implementação, assim como exploramos seus detalhes.
Portanto, por meio deste guia, possibilitamos às pessoas iniciantes da linguagem Java se inteirar de mais um recurso importantíssimo da linguagem, assim como alguns pontos que merecem atenção das boas práticas durante as explicações. Esperamos que, com isso, haja uma maior evolução daqueles que se aplicam em aprender sempre mais sobre tecnologia e sobre o mundo digital.
Por outro lado, também descobrimos que o Java array em seu estado puro não é tão utilizado em aplicações e ferramentas — na maior parte das vezes em que usamos a linguagem nos ambientes profissionais da programação. Mesmo assim, é muito importante entender sobre a base em que as muitas funções, métodos e classes opera — utilizada amplamente em ambientes mais complexos, com imensa importância para as melhores pessoas desenvolvedoras.
Se você ainda quer saber o que está por vir e ainda mais sobre a linguagem Java e outras, não deixe de assinar nossa newsletter e receba as novidades gratuitamente em sua caixa de entrada! Temos vários conteúdos sendo disponibilizados constantemente para garantir as melhores informações aos visitantes do blog da Trybe.
