ESTRUTURA DE DADOS HOMOGÊNEA

 

A manipulação de dados na área de Informática emprega vários tipos de recursos tecnológicos na efetivação de um armazenamento seguro e de seu processamento ágil. Para que isso aconteça de forma eficiente são utilizados os recursos denominados Estrutura de Dados Homogêneas. Geralmente, estas estruturas também são responsáveis pelo melhor desempenho na programação de computadores que manipulam muitos dados durante seu processamento. Apesar da linguagem Java possuir várias implementações deste recurso, estruturas homogêneas, este tópico do conteúdo só abordará as implementações relacionadas abaixo, que correspondem a três classes específicas desta linguagem:

 

• Array;
 
• Vector;
 
• ArrayList.
 

 

Em Java todos os vetores são objetos, acessíveis por referência, equivalendo portanto a forma de alocação dinâmica utilizada na linguagem C. Essa alocação da memória também é feita em tempo de execução.

 

Principais Características

 

As estruturas de dados homogêneas possibilitam o armazenamento de grupos de valores em uma única variável, que será armazenada na memória do computador. Essas estruturas são chamadas de homogêneas, pois seus valores armazenados (conteúdos) serão sempre de um único tipo, não podendo ser diferentes.

 

Apesar de sua capacidade de armazenar vários valores de forma independente, esta estrutura só possui um único identificador e garante esta independência por meio de um valor único e sequencial denominado índice ou posição da estrutura.

 

O primeiro índice ou posição na estrutura possui o valor zero (0), por exemplo:

   

Um exemplo mais corriqueiro de estrutura de dados homogênea seria uma laranjeira, onde todos os seus frutos são iguais, ou seja, todos são laranjas, mas cada laranja nasce em uma posição diferente. Isso traz uma ideia inicial de estrutura de dados homogênea interessante e importante a ser compreendida. Em Java, um Array, Vector ou ArrayList trabalham com alocação de espaço na memória para cada elemento a ser armazenado, porém cada um destes elementos serão armazenados em posições diferentes da memória, apesar de estarem disponíveis para acesso através de um único identificador.

   

Array

 

Basicamente, um Array é uma variável que armazena e manipula um conjunto de dados bem organizados na memória do computador. Essa organização torna a localização de um dado na memória muito rápida e seu acesso mais eficiente. A utilização deste recurso em Java permite o armazenamento de múltiplos itens de mesmo tipo de dado em um bloco da memória, podendo este tipo ser primitivo ou definido por uma classe (objetos).

   

Cada item em um Array é chamado de elemento, e cada elemento é acessado de maneira indepedente através de sua posição numérica (índice). Como na ilustração acima as posições são numeradas a partir do zero (0). O segundo (2º) elemento, por exemplo, é acessado na posição ou índice um (1).

 

Declarando um Array

 

Como na declaração de outras variáveis ou atributos, a declaração não cria realmente o Array, mas informa ao seu compilador que esta variável terá um Array do tipo especificado na declaração, por exemplo:

 

   
   int[ ] meuArray;           // declaração de um Array do tipo primitivo int
   byte[ ] meuArrayBytes;       // declaração de um Array do tipo primitivo byte
   short[ ] meuArrayShorts;  // declaração de um Array do tipo primitivo short
   long[ ] meuArrayLongs;      // declaração de um Array do tipo primitivo long
   float[ ] meuArrayFloats;      // declaração de um Array do tipo primitivo byte
   double[ ] meuArrayDoubles;  // declaração do Array de tipo primitivo double
   boolean[ ] meuArrayBoolean; // declaração do Array de tipo primitivo bolean
   char[ ] meuArrayChars;         // declaração de um Array do tipo primitivo char
   String[ ] meuArrayStrings;  // declaração de um Array do tipo String (objetos)

 

Você também pode colocar os colchetes após o nome do Array, ou usar atalhos de sintaxe para criar e inicializar um Array, por exemplo:

 

    
    int meuArray[ ];    // outra forma de criar Array (menos usada em Java)
    // Cria Array e inicializa suas posições
    int[ ] meuArray = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};

 

Exemplo de Array unidimensional:

 

O programa a seguir cria um array de inteiros, atribui algumas posições a ele, e imprime cada valor à saída padrão.

 

/**
* Síntese
*   Objetivo: armazenar valores no Array e apresentá-los
*   Entrada: sem entrada (dados atribuídos pelo programa)
*   Saída: mostrar os elementos armazenados na memória
*/
   class ArrayDemo {
       public static void main(String[] args) {
          int[] meuArray;   // declaração de um array de inteiros
          meuArray = new int[5];  // aloca memória para guardar 5 inteiros
 
          meuArray[0] = 100;  // inicializa o primeiro elemento
          meuArray[1] = 200;  // inicializa o segundo elemento
          meuArray[2] = 300;  // inicializa o terceiro elemento
          meuArray[3] = 400;  // inicializa o quarto elemento
          meuArray[4] = 500;  // inicializa o quinto elemento
 
          // Apresentação dos dados armazenados na memória
          System.out.println("Elemento na posição 0: " + meuArray[0]);
          System.out.println("Elemento na posição 1: " + meuArray[1]);
          System.out.println("Elemento na posição 2: " + meuArray[2]);
          System.out.println("Elemento na posição 3: " + meuArray[3]);
          System.out.println("Elemento na posição 4: " + meuArray[4]);
       }
   }

 

A execução do programa anterior apresentaria a saída de dados na console como representado na figura a seguir:

   

Array Multidimensional

 

Também se pode declarar um Array de arrays (também conhecido como array multidimensional ou matriz), utilizando dois ou mais conjuntos de colchetes [ ][ ]. Cada elemento, deve consequentemente ser alcançado por um número correspondente de valores de índice.

 

Na linguagem de programação Java um array multidimensional corresponde simplesmente a existência de um Array onde seus elementos são outros arrays, ou seja, em cada elemento de um Array corretamente definido e homogêneo existirá um novo Array de mesmo tipo.

   

A figura anterior mostra a representação de um Array multidimensional (com duas dimensões - bidimensional), onde as dimensões são divididas entre linhas e colunas. No exemplo desta figura o conteúdo de cada posição foi preenchido através da definição de suas coordenadas, ou seja, da indicação da linha e coluna específica de cada posição existente neste Array bidimensional (preenchimento com linha (ponto) coluna).

 

Exemplo de Array multidimensional:

 

 
/**
* Síntese
*   Objetivo: manipular um Array multidimensional com nomes
*   Entrada: sem entrada
*   Saída: mostrar na console os nomes
*/
    class ArrayMultiDemo {
        public static void main(String[] args) {
            String[][] nomes = {{"Mr. ", "Mrs. ", "Ms. "},{"Anderson","Pimenta"}};
 
            // Mostrar dados na console
            System.out.println(nomes[0][0] + nomes[1][0]);
            System.out.println(nomes[0][2] + nomes[1][1]);
        }
    }
    

 

A execução do programa anterior é representada na figura a seguir:

   

A propriedade length do Array é utilizada para identificar seu tamanho (quantidade de posições). Essa propriedade retorna a quantidade de elementos que o seu Array possui.

 

System.out.println (meuArray.length);

 

A instrução anterior imprimirá na console o tamanho do Array declarado com identificador listaDados.

   

Um exemplo comum de Array multidimensional seria a organização do calendário mensal, onde geralmente se dividem as linhas em 7 (dias na horizontal) e as colunas em semanas (na vertical). Cada dia que se deseja pesquisar neste calendário deverá selecionar uma linha e coluna específica.

   

Veja a imagem acima como exemplo o dia 15 (selecionado na imagem), corresponderia a linha 3 e coluna 5.

 

Com intuito de apoiar o aprendizado sobre Orientação a Objeto, sugere-se assistir a videoaula para o aperfeiçoamento no conhecimento deste conteúdo.

 

Vector

 

Uma outra implementação disponível em Java para manipular este tipo de estrutura homogênea é a classe Vector. Os objetos dessa classe têm internamente um arranjo (conjunto) de objetos. A diferença para um Object[ ] é que os objetos em Vector lidam transparentemente com as necessidades de criar mais espaço para ampliar a sua área de armazenamento, enquanto os Array possuem tamanho fixo e pré-determinado, como exemplificado anteriormente.

 

Quando um objeto Vector é criado, seu conteúdo é inicialmente vazio. Os métodos para modificar o conteúdo de um Vector são vários, sendo os principais relacionados a seguir:

 

  addElement();   // acrescenta elemento no final do Vector
  insertElementAt()    // insere elemento na posição especificada
  setElementAt()        // modifica elemento da posição indicada
  removeElementAt()  // remove elemento da posição indicada
  removeAllElements()   // remove todos os elementos do Vector
  elementAt()  // retorna o elemento (objeto) da posição indicada
  indexOf() // retorna a posição dado o objeto
  contains()  // indica se dado objeto está ou não presente no Vector

 

Para utilização da classe Vector é necessária a importação da java.util.Vector em seu programa. As principais características no uso deste recurso de armazenamento e manipulação de dados em Java são:

 

• tamanho variável, sendo seu aumento controlado pelo ambiente Java;
 
• armazena somente objetos (referência);
 
• alteração acontece sobre o mesmo objeto (não "polui" a memória).
 

 

Exemplo de Vector:

 

/**
* Síntese
*   Objetivo: armazenar e mostrar elementos da memória no Vector
*   Entrada: sem entrada
*   Saída: apresenta valores armazenados na estrutura homogênea
*/
    import java.util.Vector;     // importação da classe Vector
 
    public class VectorDemo {
         static Vector vetor = new Vector();   // cria Objeto da classe Vector
 
         public static void main(String[] args) {
 
            vetor.add(500);  // Adiciona o numero 500 na estrutura Vector
            vetor.add(300);  // Adiciona o numero 300 no Vector
            vetor.add(20);    // Adiciona o numero 20 no Vector
 
            // Apresenta os valores armazenados no objeto vetor da classe Vector
            System.out.println("Segundo valor no vetor: "+vetor.get(1));
            System.out.println("Terceiro valor no vetor: "+vetor.get(2));
            System.out.println("Primeiro valor no vetor: "+vetor.get(0));
         }
    }

 

A representação da execução do programa anterior na console seria como está na figura a seguir:

   

ArrayList

 

O recurso denominado Lista (List em Java) consiste em uma forma de organização através da enumeração de dados que propiciam certas facilidades na manipulação de seus elementos para apresentação (visualização de seus conteúdos). Na área de Informática este conceito se expande para uma estrutura de dados dinâmica, em oposição aos arranjos estáticos como os Arrays.

 

O uso do Array na programação Java possui a característica de imutabilidade, ou seja, uma vez definidas suas dimensões elas não podem ser modificadas, a menos que seja criado um novo objeto Array e todos os seus elementos sejam copiados para ele (poluição da memória).

 

A classe Vector e ArrayList, que se estará estudando neste tópico, possuem muitas características em comuns. Um aspectos diferencial importante entre estas estruturas está relacionada a execução de múltiplas tarefas simultâneas, onde a classe Vector está preparada para atender tal necessidade. No entanto, apesar de tal exceção, estas duas estruturas possuem uma performance similar, quando não existirem necessidades de processamento simultâneo.

 

A interface List possui um processo de iteração especial, denominado ListIterator, que permite o início da iteração em qualquer ponto (posição) da lista. A List seria um recurso para organizar esses itens (elementos) na forma tradicional de processamento de uma lista de dados, muito comum na programação de computadores.

 

Criação de ArrayList

 

Para criar um objeto do ArrayList basta instanciar um objeto desta classe, permitindo passar ou não como parâmetro ao seu construtor a quantidade inicial de elementos que a lista deverá possuir, por exemplo:

 

 
 
   ArrayList tipoA = new ArrayList();  // sem indicação do tamanho que será padrão
 
   ArrayList tipoB = new ArrayList(20);  // com indicação de tamanho 20

 

Observe que o tamanho destes objetos (tipoA e tipoB) podem ser obtidos pelo uso do método size(), onde na circunstância de ambos o retorno será zero (0), pois não foi adicionado nenhum objeto nas listas. Contudo, o objeto tipoB foi construído com capacidade inicial de armazenamento de 20 elementos.

 

Manipulação do ArrayList

 

A inclusão de objetos na lista pode acontecer por meio do método add(). Esta inclusão poderá indicar em seu argumento a posição da lista que o novo elemento deve possuir. No caso da posição indicada já possuir um elemento (objeto), o mesmo será deslocado uma posição para frente e o novo objeto será colocado na posição solicitada.

 

O não fornecimento de uma posição específica permite que a própria lista gerencie esta inclusão, simplificando sua instrução, além da preocupação com o uso correto da lista.

 

Exemplos

 

 
   Pessoa pes = new Pessoa("joão", "josé");  
   // Adiciona em tipoA os dados contidos no objeto pes da classe Pessoa
   tipoA.add(pes);
 
   // Adiciona em tipoA os objetos Pessoa
   tipoA.add(new Pessoa("maria", "silva"));

 

Para remover um item da lista basta informar o número que corresponde a posição da lista que se deseja remover, por exemplo:

 

tipoA.remove(1);

 

Para obter dados da lista pode-se usar o método get(), por exemplo:

 

 

   Pessoa pes = (Pessoa) tipoA.get(0);  // efetuar a conversão para Pessoa
   System.out.println( pes.nome );
 
   System.out.println( ((Pessoa) tipoA.get(0)).nome ); // outra forma de mostrar

 

Ao usar o método add, get ou remove o elemento da lista deve existir, caso contrário irá gerar um erro a ser tratado: java.lang.IndexOutOfBoundsException.

 

Exemplo do uso de ArrayList

 

 
/**
* Síntese
*   Objetivo: mostrar o uso de ArrayList
*   Entrada: adiciona os valores no ArrayList
*   Saída: mostrar na console os resultados adicionados no ArrayList
*/
    import java.util.ArrayList;    // importação da classe ArrayList
  
    public class ArrayListDemo {
       // cria um ArrayList que conterá inteiros
       static ArrayList lista = new ArrayList();// cria objeto lista de ArrayList
 
       public static void main(String[] args){
          // adiciona itens na lista
          lista.add(34);
          lista.add(12);
          lista.add(8);
 
          // exibe os valores da lista na console
          for(int aux = 0; aux < lista.size(); aux++)
             System.out.println("Elemento na posição ["+aux+"]= "+lista.get(aux));
       }
    }

 

A execução do programa anterior resultaria na demonstração representada na figura a seguir:

   

Com intuito de demonstrar que estas estruturas homogêneas podem ser utilizadas em conjunto, não sendo excludentes entre elas, é apresentado um exemplo de programa em Java que usa estas estruturas em um mesmo código (programa).

 

Exemplo com estas estruturas de dados:

 

 
/**
* Síntese
*   Objetivo: guardar números, letras e nomes na memória
*   Entrada: sem entrada (todos dados atribuídos pelo programa)
*   Saída: mostra todos os dados guardados na memória em estruturas
*/
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Vector;
 
   public class EstruturasHomoDemo {
 
     public static void main(String[] args) {
        Vector numeros = new Vector();
        char letras[] = new char[26];
        List palavras = new ArrayList();
        int cont=0;
 
        // Atribui dados ao Vector numeros
        for(int aux = 0; aux < 10; aux++) {
           numeros.add(aux);
        }
 
        // Atribui dados ao Array letras
        for(char letra ='a'; letra <=  'z'; letra++) {
           letras[cont] = letra;
           cont++;
        }
 
        // Atribui dados ao ArrayList palavras
        palavras.add("Ana Júlia");
        palavras.add("Funciona");
        palavras.add("Luis Inácio Lula da Silva");
 
        /* Apresentação final dos dados na memória */
        // Mostra dados do Vector
        System.out.println("Números armazenados no Vector: ");
        for (int aux=0; aux < numeros.size(); aux++){
           System.out.print(numeros.get(aux)+" ");
        }
        // Mostra dados do Array
        System.out.println("\n_________________________________" +
                           "\n\nLetras armazenadas no Array: \n");
        for(char letra : letras) {
           System.out.print(letra+" ");
        }
 
        // Mostra dados do ArrayList
        System.out.println("\n_________________________________" +
                           "\n\nPalavras armazenadas no ArrayList: \n");
        for(Object palavra : palavras) {
           System.out.println(palavra);
        }
 
     }
   }

 

A execução do programa anterior esta representado na figura a seguir:

   

Com intuito de apoiar o aprendizado sobre Orientação a Objeto, sugere-se assistir a videoaula para o aperfeiçoamento no conhecimento deste conteúdo.

 

Atividade de Fixação

 

No intuito de fixar estes novos conteúdos abordados até o momento e verificar sua compreensão sobre os mesmos, são sugeridos alguns exercícios de fixação para serem resolvidos, por meio do seu clique no link de exercícios ao lado que permitirá o início da lista de exercícios. Bom trabalho!!