Arrays: arranjos de dados

Antes de começar a aprender sobre arrays, é fundamental que você já saiba o que é uma variável e uma estrutura de repetição for.

Para aprender sobre variáveis, leia este artigo onde te explicamos com detalhes sobre o assunto.

Para aprender sobre estruturas de repetição for, leia este artigo onde te explicamos com detalhes sobre o assunto.

Mas vamos ao que interessa!

O que é um array?

Da maneira mais direta possível, um array (também conhecido como arranjo de dados) pode ser definido como um recurso de programação que te permite manipular muitas variáveis de maneira simples e intuitiva. Mas antes de entender como isso é possível, vamos observar alguns exemplos práticos dos problemas que podem ser resolvidos pelo uso de um array.

O problema de usar variáveis

Imagine que queremos criar um programa para solicitar do usuário um único valor numérico e exibi-lo na tela. É uma tarefa muito simples! O Algoritmo abaixo faz exatamente isso:

1.int valor;
2.println("Digite um valor");
3.valor = input();
4.println("Valor digitado = "+valor);

Veja na linha 1 (código acima) que foi criada uma única variável para armazenar esse valor, que foi solicitado do usuário (linha 3 do código acima) e impresso na tela (linha 4 do código acima).

Agora imagine que, ao invés de um único valor numérico, precisamos solicitar do usuário 5 valores numéricos. Nesse caso, precisamos criar mais 4 variáveis, solicitar o valor do usuário mais 4 vezes e escrever mais 4 comandos de impressão. Veja abaixo como ficaria esse novo código:

1.int valor1;
2.int valor2;
3.int valor3;
4.int valor4;
5.int valor5;
6.println("Digite o valor 1");
7.valor1 = input();
8.println("Digite o valor 2");
9.valor2 = input();
10.println("Digite o valor 3");
11.valor3 = input();
12.println("Digite o valor 4");
13.valor4 = input();
14.println("Digite o valor 5");
15.valor5 = input();
16.println("Valor 1 digitado = "+valor1);
17.println("Valor 2 digitado = "+valor2);
18.println("Valor 3 digitado = "+valor3);
19.println("Valor 4 digitado = "+valor4);
20.println("Valor 5 digitado = "+valor5);

Como você pode perceber o código cresceu bastante! Para cada nova informação que o programa precisar manipular, precisamos criar uma nova variável. Imagine agora se precisássemos solicitar 1000 valores ao invés de 5. Seria um desastre! O código ficaria enorme!

Para começar a resolver o problema de ter que escrever muitas linhas de código para lidar com muitas variáveis, recorremos ao uso dos arrays.

Como criar um array?

A maneira padrão de criar um array varia a depender da linguagem de programação. Veja abaixo uma forma muito utilizada para criar um array. O código mostra a criação de um único array denominado “valores” para armazenar 5 variáveis do tipo int:

1.int[ ] valores = new int[5];

Veja (no código acima) o detalhe marcante de um array: a presença dos colchetes “[” “]” (conhecidos como “operador subscrito”). São eles que diferenciam a criação de um array e de uma variável. Observe que “int valor” é uma variável e “int[ ] valores” é um array.

Vamos observar mais detalhes.

A criação de um array se divide em duas etapas: declaração e inicialização. Observe a ilustração abaixo.

O trecho “int[ ] valores” representa a declaração do array do tipo int. O trecho “new int[5]” representa a inicialização do array. Na declaração usamos os colchetes “[” “]” vazios. Na inicialização colocamos o valor da capacidade dentro dos colchetes.

Poderíamos ter criado arrays para armazenar outros Tipos Primitivos de variáveis no lugar do tipo int. Por exemplo:

1.char[ ] letras = new char[10];
2.double[ ] salarios = new double[35];
3.boolean[ ] validacoes = new boolean[12];

Também poderíamos ter criado arrays para armazenar Tipos Abstratos de Dados, ao invés de Tipos Primitivos:

1.String[ ] nomes = new String[8];
2.Funcionario[ ] listaFuncionarios = new Funcionario[30];
3.Pessoa[ ] moradores = new Pessoa[100];

É importante observar que existem diferenças impactantes na forma de criar um array a depender da linguagem de programação que seja utilizada. Nas linguagens C e C++, por exemplo, a criação é bem mais simples. Na linguagem Python, não existe o conceito de arrays; usa-se bibliotecas, tal como a NumPy, para emular o comportamento de um array.

Veja abaixo o código para a criação de um array em várias linguagens de programação diferentes:

1.int[ ] valores = new int[5];
2.// ou
3.int valores[ ] = new int[5];

1.// não há necessidade de usar a palavra new
2.int valores[5];

1.// não há necessidade de usar a palavra new
2.int valores[5];

1.int[ ] valores = new int[5];

1.# Python não possui suporte para arrays
2.# Recomenda-se usar a biblioteca NumPy 

Índices de um array

As posições de um array (conhecidas como índices) são utilizadas como mecanismo de acesso aos seus elementos. Vamos retomar o exemplo do nosso array de capacidade 5, ou seja, com 5 índices.

1.int[ ] valores = new int[5];

Os índices de um array são numerados a partir do valor 0 (zero) até o valor de sua capacidade menos uma unidade (capacidade-1). Por exemplo: o array de capacidade 5 (criado no código acima) possui os índices de 0 a 4, conforme a ilustração abaixo:

Da mesma forma, um array de capacidade 10 possui os índices de 0 a 9:

Os índices representam as posições de cada uma das variáveis de um array.

Atribuição de valores a um array

Para compreender melhor o significado e o uso dos índices, vamos comparar a atribuição de valores a uma variável com a atribuição de valores a um array:

Atribuição de um valor a uma variável

1.int valor;
2.valor = 50;

Observe na linha 2 do código acima como o valor 50 é atribuído à variável “valor” sem nenhum problema! É como se o valor 50 fosse jogado dentro da variável.

Será que o mesmo poderia ser feito a um array?

Atribuição de um valor a um array

1.int[ ] valores = new int[5];
2.valores = 50; // isso é um erro! 

Observe na linha 2 do código acima como o valor 50 é atribuído ao array “valores”! Isso é um grande erro! O fato de o array “valores” ser uma coleção de 5 variáveis impede que o valor 50 seja diretamente atribuído a ele sem antes especificar o índice da posição de inserção.

Para especificar o índice da posição de inserção em um array também utilizamos os colchetes “[” “]” (o “operador subscrito”). Veja no código abaixo um exemplo da criação de um array de capacidade 5, a atribuição de alguns valores e a impressão desses valores na tela:

1.int[ ] valores = new int[5];
2.valores[0] = 13;
3.valores[1] = 53;
4.valores[2] = 9;
5.valores[3] = 16;
6.valores[4] = 25;
7.println(valores[0]);
8.println(valores[1]);
9.println(valores[2]);
10.println(valores[3]);
11.println(valores[4]);

Observe nas linhas de 2 a 6 (código acima) como os colchetes são utilizados para especificar a posição de atribuição dos valores no array. O mesmo é feito nas linhas de 7 a 11 (código acima), onde os colchetes são utilizados para ler os valores do array.

Veja na animação abaixo a simulação da atribuição de valores a um array pelos seus índices:

Veja abaixo os exemplos completos do código acima em várias linguagens de programação diferentes:

1.import java.util.Scanner;
2.class Main {
3.        public static void main(String[] args) {
4.                int[ ] valores = new int[5];
5.                valores[0] = 13;
6.                valores[1] = 53;
7.                valores[2] = 9;
8.                valores[3] = 16;
9.                valores[4] = 25;
10.                System.out.println(valores[0]);
11.                System.out.println(valores[1]);
12.                System.out.println(valores[2]);
13.                System.out.println(valores[3]);
14.                System.out.println(valores[4]);
15.        }
16.}

1.#include <stdio.h>
2.int main(void) {
3.        int valores[5];
4.        valores[0] = 13;
5.        valores[1] = 53;
6.        valores[2] = 9;
7.        valores[3] = 16;
8.        valores[4] = 25;
9.        printf("%d\n",valores[0]);
10.        printf("%d\n",valores[1]);
11.        printf("%d\n",valores[2]);
12.        printf("%d\n",valores[3]);
13.        printf("%d\n",valores[4]);
14.}

1.#include <iostream>
2.int main() {
3.        int valores[5];
4.        valores[0] = 13;
5.        valores[1] = 53;
6.        valores[2] = 9;
7.        valores[3] = 16;
8.        valores[4] = 25;
9.        std::cout << valores[0] << std::endl;
10.        std::cout << valores[1] << std::endl;
11.        std::cout << valores[2] << std::endl;
12.        std::cout << valores[3] << std::endl;
13.        std::cout << valores[4] << std::endl;
14.}

1.using System;
2.class MainClass {
3.        public static void Main (string[] args) {
4.                int[ ] valores = new int[5];
5.                valores[0] = 13;
6.                valores[1] = 53;
7.                valores[2] = 9;
8.                valores[3] = 16;
9.                valores[4] = 25;
10.                Console.WriteLine(valores[0]);
11.                Console.WriteLine(valores[1]);
12.                Console.WriteLine(valores[2]);
13.                Console.WriteLine(valores[3]);
14.                Console.WriteLine(valores[4]);
15.        }
16.}

1.# Python não possui suporte para arrays 
2.# Este exemplo usa a biblioteca NumPy 
3.import numpy
4.valores = numpy.array([13, 53, 9, 16, 25])
5.print(valores[0])
6.print(valores[1])
7.print(valores[2])
8.print(valores[3])
9.print(valores[4])

Limites de um array

É de responsabilidade única do programador gerenciar os limites dos índices de um array. Imagine o que aconteceria se tentássemos acessar o índice 6 de um array que possui capacidade 5? O código abaixo ilustra essa situação:

1.int[ ] valores = new int[5];
2.valores[6] = 37;

O problema é que, na maioria das linguagens de programação, esse algoritmo seria compilado e executado normalmente. O erro aconteceria durante a execução, quando o algoritmo tentasse atribuir o valor 37 ao índice 6 do array (linha 2 do código acima). Esse tipo de erro é conhecido como “indexação fora dos limites”.

É muito comum programadores iniciantes cometerem esses erros de “indexação fora dos limites” durante o uso dos arrays. Por isso, fique atento!

Automatização dos arrays

Vamos retomar o problema inicial do artigo, que cria um programa para solicitar do usuário 5 valores numéricos e os exibe na tela. Mas agora vamos usar um array no lugar de 5 variáveis. O código abaixo mostra esse programa:

1.int[ ] valores = new int[5];
2.println("Digite o valor 1");
3.valores[0] = input();
4.println("Digite o valor 2");
5.valores[1] = input();
6.println("Digite o valor 3");
7.valores[2] = input();
8.println("Digite o valor 4");
9.valores[3] = input();
10.println("Digite o valor 5");
11.valores[4] = input();
12.println("Valor 1 digitado = "+valores[0]);
13.println("Valor 2 digitado = "+valores[1]);
14.println("Valor 3 digitado = "+valores[2]);
15.println("Valor 4 digitado = "+valores[3]);
16.println("Valor 5 digitado = "+valores[4]);

Observe que a única otimização conseguida nesse código foi a criação do array (linha 1 do código acima). Ao invés de criar 5 variáveis, criamos apenas um único arranjo de dados.

Perceba que as solicitações dos valores por parte do usuário (linhas 2 a 11 do código acima) e as impressões na tela (linhas 12 a 16 do código acima) ainda continuam com código repetido.

Isso não é bom! Se precisarmos aumentar o número de valores solicitados para 1000, recairemos no mesmo problema de código fonte gigantesco!

Para resolver esse problema utilizamos as estruturas de repetição. O uso dos arrays está intimamente ligado ao uso das estruturas de repetição. Sem elas não é possível obter as vantagens de automatização e economia de código que os arrays podem proporcionar.

Mas vamos entender isso com mais exemplos. Observe a estrutura de repetição for abaixo:

1.for(int i=0; i < 5; i++){
2.        println(i);
3.}

Se você conhece o comando for, sabe que a variável de controle “i” vai assumir, durante as repetições, todos os valores no intervalo de 0 a 4.

Agora observe na ilustração abaixo como os índices de um array de capacidade 5 coincidem exatamente com os valores no intervalo de 0 a 4.

Mera coincidência? Não! Automatização!

É justamente a variável de controle “i” do comando for quem vai proporcionar a automatização do array. Veja o código abaixo:

1.for(int i=0; i < 5; i++){
2.        println(valores[i]);
3.}

Perceba que a variável de controle “i” (linha 2 do código acima) assume dentro dos colchetes “[” “]” do array cada um dos índices de 0 a 4 durante as repetições, imprimindo, com uma única linha de código, todas as posições do array.

Veja na animação abaixo a simulação de como isso acontece:

Desta forma, podemos modificar o código do problema inicial do artigo e otimizá-lo com a estrutura de repetição for. Veja abaixo como fica esse código para solicitar do usuário 5 valores numéricos e exibi-los na tela:

1.int[ ] valores = new int[5];
2.for(int i=0; i < 5; i++){ // solicita os 5 valores
3.        println("Digite o valor "+(i+1));
4.        valores[i] = input();
5.}
6.for(int i=0; i < 5; i++){ // exibe os 5 valores 
7.        println(valores[i]);
8.}

Agora, independente da quantidade de valores solicitados, não existe a necessidade de adicionar mais nenhuma linha de código. Precisamos apenas trocar os valores 5 (no código) pela nova quantidade desejada.

Veja abaixo esse mesmo código completo em várias linguagens de programação diferentes:

1.import java.util.Scanner;
2.class Main {
3.        public static void main(String[] args) {
4.                Scanner sc = new Scanner(System.in);
5.                int[] valores = new int[5];
6.                for(int i=0; i < 5; i++){
7.                        System.out.println("Digite o valor "+(i+1));
8.                        valores[i] = sc.nextInt();
9.                }
10.                for(int i=0; i < 5; i++){
11.                        System.out.println(valores[i]);
12.                }
13.        }
14.}

1.#include <stdio.h>
2.int main(void) {
3.        int valores[5];
4.        for(int i=0; i < 5; i++){
5.                printf("Digite o valor %d\n",(i+1));
6.                scanf("%d",&valores[i]);
7.        }
8.        for(int i=0; i < 5; i++){
9.                printf("%d\n",valores[i]);
10.        }
11.}

1.#include <iostream>
2.int main() {
3.        int valores[5];
4.        for(int i=0; i < 5; i++){
5.                std::cout << "Digite o valor " << (i+1) <<"\n";
6.                std::cin >> valores[i];
7.        }
8.        for(int i=0; i < 5; i++){
9.                std::cout << valores[i] << "\n";
10.        }
11.}

1.using System;
2.class MainClass {
3.        public static void Main (string[] args) {
4.                int[] valores = new int[5];
5.                for(int i=0; i < 5; i++){
6.                        Console.WriteLine("Digite o valor "+(i+1));
7.                        valores[i] = Convert.ToInt32(Console.ReadLine());
8.                }
9.                for(int i=0; i < 5; i++){
10.                        Console.WriteLine(valores[i]);
11.                }
12.        }
13.}

1.# Python não possui suporte para arrays 
2.# Este exemplo usa a biblioteca NumPy 
3.import numpy
4.valores = numpy.array([])
5.for i in range(5):
6.        valor=int(input("Digite o valor "+str(i+1)+"\n"))
7.        valores = numpy.append(valores, valor)
8.for i in range(5):
9.        print(valores[i])

Termine a sua saga de aprendizado na programação básica. Leia o nosso artigo sobre funções. O último assunto para você aprender nessa série de programação básica.