Artigos Java Visão geral da interface Collection em Java

Interface Collection

É a interface absoluta na hierarquia de coleções. Dela descendem as interfaces Set, Queue (filas) e List (listas) que formam a base das coleções genéricas da linguagem Java.

  • Set – define uma coleção que não contém valores duplicados.
  • Queue – define uma coleção que representa uma fila, ou seja, implementa o modelo FIFO (First-In, First-Out)
  • List - define uma coleção ordenada que pode conter elementos duplicados.

As classes e interfaces dessa estrutura de coleções são membros do pacote java.util.

Estrutura das coleções e mapas

Figura 1: Estrutura das coleções e mapas

Declarando uma coleção

Estrutura das coleções e mapas

Figura 2: Declaração interface Collection

No exemplo da Listagem 1, estamos declarando uma variável chamada colecao que somente irá armazenar tipos String nesse espaço. Nesse exemplo estamos instanciando a classe que implementa a interface, como descrito no diagrama da Figura 1.

Listagem 1: Declaração de Collections

    Collection<String> colecao = new ArrayList();

Apenas lembrando que tanto para declarar List como Collection será necessário importar os seguintes pacotes: java.util.ArrayList e java.util.Collection.

Veja agora alguns métodos da interface List implementados pela classe ArrayList.

Adicionando elementos

Para adicionar o elemento é invocado o método add que aceita um argumento do tipo definido, como mostrado na Listagem 2. Cada vez que invocamos esse método para a mesma coleção é adicionado um valor no fim da lista.

Listagem 2: Adiciona valores

    import java.util.Collection; 
    import java.util.ArrayList;
    
    public class MetodoAdd {
        public static void main(String[] args) {	
            Collection<String> nomes = new ArrayList();
            nomes.add("João");
            nomes.add("Maria");
            nomes.add("Eduardo");
            nomes.add("Silvana");
            nomes.add("Mário");
            
            System.out.println(“Lista de nomes: ”+nomes);
        }
    }
Método isEmpty

Verifica se os dados dentro de um List estão vazios, tendo como retorno valor booleano, true ou false.

Listagem 3: Verificando a existência de valores

    import java.util.Collection; 
    import java.util.ArrayList;
    
    public class Metodo_isEmpty {
        public static void main(String[] args) {
            Collection<String> letras = new ArrayList();
            letras.add("A");
            letras.add("B");
            letras.add("C");
            letras.add("D");
            letras.add("E");
            letras.add("F");
                    
            if(letras.isEmpty()){
                System.out.println("Lista Vazia!");
            }else{
                System.out.println("Contém valores -> "+letras);
            }
        }
    }

Nesse caso do exemplo da Listagem 3 a saída será a impressão das mensagens informando se a lista está vazia ou não, o que não ocorre, mas para testes poderia ser incluída uma ação para limpar essa lista através do método clear.

Removendo elementos

Para excluir uma ocorrência do valor especificado é usado o método remove.

Listagem 4: Removendo o elemento da posição 2

    import java.util.Collection;
    import java.util.ArrayList;
    
    public class MetodoRemove {
        public static void main(String[] args) {
            Collection<Integer> fila = new ArrayList();
            fila.add(255);
            fila.add(312);
            fila.add(883);
            fila.add(122);
            fila.add(9);
            
            System.out.println(“Valores da fila: ”+fila);
        
            fila.remove(312); //REMOVE OBJETO 312
        
            System.out.println(“Valores atualizados da fila:”+fila);
        }
    }

Limpando os elementos da lista

Para executar essa ação basta invocar o método clear que irá limpar todos os elementos da coleção referenciada.

Listagem 5: Usando o método clear

    import java.util.Collection; 
    import java.util.ArrayList;
    
    public class MetodoRemove {
        public static void main(String[] args) {
            Collection<String> livros = new ArrayList();
            livros.add("Java");
            livros.add("Php");
            livros.add("Python");
            livros.add("SQL");
            
            System.out.println("Listagem dos Livros: "+livros);
    
            livros.clear();
    
            System.out.println("Listagem após o clear: "+livros);
    
        }
    }

Verificando se existem dados

Quando precisar verificar a existência de certos elementos dentro de uma coleção, é possível fazer isso através do método contains.

Listagem 6: Verifica se contém um elemento

    import java.util.ArrayList;
    import java.util.Collection;
    
    public class VogaisColecao {
    
        public static void main(String[] args) {
            Collection<String> vogais = new ArrayList();
            vogais.add("A");
            vogais.add("E");
            vogais.add("I");
            vogais.add("O");
            vogais.add("U");
            
            System.out.println("Contém a vogal I ? "+vogais.contains("I"));
            System.out.println("Lista das vogais: "+vogais);
            
        }
    
    }

Adicionando elementos de outra coleção

O método addAll permite adicionar todo os elementos de uma lista no final de outra.

Listagem 6: Adiciona elementos de uma coleção em outra

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    
    public class Dois_Collections {
    
        public static void main(String[] args) {
            Collection<String> vogais = new ArrayList();
            vogais.add("A");
            vogais.add("E");
            vogais.add("I");
            
            Collection<String> vogais2 = Arrays.asList("O", "U");
            
            //RECEBE TODOS OS ELEMENTOS DA COLEÇÃO ADICIONANDO NA COLEÇÃO VOGAIS
            vogais.addAll(vogais2);
            
            System.out.println("Lista das Vogais: "+vogais);
            
        }
    
    }

Percorrendo Elementos

Para percorrer os elementos de uma coleção de forma prática, usamos a instrução foreach que permite acessar cada item individualmente.

Listagem 7: Percorre e imprime os elementos de uma coleção

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    
    public class Percorre_Collections {
    
        public static void main(String[] args) {
            Collection<String> vogais = new ArrayList();
            vogais.add("A");
            vogais.add("E");
            vogais.add("I");
            vogais.add("O");
            vogais.add("U");
    
            //PERCORRE TODOS OS ELEMENTOS DA COLEÇÃO VOGAIS
            for(String vog : vogais){
                System.out.println("Vogal: "+vog);
            }
        }
    }

Conclusão

Para mais informações sobre os métodos e conhecer mais sobre essa interface, acesse a documentação do Java através desse link: http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Collections.html

Espero que tenham gostado e até a próxima!

Leia também o artigo: LinkedLists: O que acontece por trás da interface

Links Úteis

Saiba mais sobre Java ;)

  • Curso básico de Java Aplicado:
    O objetivo do curso de Java Básico aplicado é apresentar os conceitos básicos da linguagem de programação Java, assim como da Orientação a Objetos, aplicados em exemplos simples e úteis, utilizados pela maioria dos desenvolvedores no dia a dia do desenvolvimento de software.
  • Básico de Java e Orientação a Objetos:
    O objetivo deste curso básico de Java e Orientação a Objetos é apresentar os conceitos básicos da linguagem de programação Java e a orientação a objetos (OO), visando ensinar usuários leigos, com pouca experiência em linguagem de programação a trabalhar com a plataforma Java.
  • Curso de Java: Técnicas Avançadas para Java SE:
    Neste curso de Java avançado iremos nos aprofundar em tópicos de programação que ajudam você a entender os conceitos mais avançados de Java. Isso significa que o programador já precisa ter conhecimentos prévios da linguagem Java, bem como dos seus recursos, lógica de programação, depuração de código, IDEs, dentre outros conceitos básicos de programação.