Coleções em Java



A linguagem Java possui um conjunto de classes que servem para armazenar na memória vários objetos. Tais classes não possuem a necessidade de saber previamente a quantidade exata de elementos que será armazenado, como ocorre no caso de arrays. E em alguns casos, nem mesmo o tipo é necessário saber previamente.

Uma coleção é uma estrutura de dados, na realidade um objeto, que pode armazenar ou agrupar referências a outros objetos. As classes e interfaces da estrutura de coleções são membros do pacote java.util.

A tabela a seguir mostra os pacotes mais comuns utilizados em Java e suas funcionalidades:

Pacote Funcionalidade
Java AW Criação de gráficos e imagens básicos além de interfaces com o usuário.
Java Swing Criação de componentes de interface com o usuário mais sofisticadas.
Java Basic I/O Utilização de streams de dados.
Java Networking Desenvolvimento de aplicações de rede.
Java Utilities Para trabalhar com coleções, modelo de eventos e componentes de data e hora.
Java Language Para utilizar as classes e interfaces core da linguagem Java.


Interface Descrição
Collection Interface base que determina quais operações as classes armazenam coleções de objetos deve possuir.
Set Estende a interface Collection não permitindo a repetição de elementos.
SortedSet Estende a Interface Set para manter os elementos ordenados.
List Estende a interface Collection representando uma lista de elementos.
Map Interface base para classes que armazenam elementos associados a uma chave.
SortedMap Estende a interface Map para armazenar os elementos ordenados pela chave.


Classe Descrição
Collections Possui métodos estáticos para realizar operações sobre coleções, tais como : copia, valor máximo e mínimo, pesquisa, ordenação, etc.
Stack Representa a estrutura de dados Pilha.
Vector Coleção de objetos, os quais podem ser acessados através do índice.
HashTable Estrutura de dados Hashtable armazenado pares de objetos (chave + dados), não permite chaves repetidas. Os objetos armazenados devem implementar os métodos hashcode e equals. Os valores podem ser recuperados pela chave.
TreeMap Árvore que armazena pares de objetos (chave + dados), armazenado-os em ordem ascendente de chaves. Garante acesso em ordem de complexidade Log(n).
TreeSet Conjunto de objetos armazenado em ordem ascendente e sem repetição. Garante acesso em ordem de complexidade Log(n).


O organograma acima mostra as principais interfaces que compõem o framework de coleções do Java. Há duas hierarquias, uma com a interface java.util.Collection (possui um parâmetro, chamado E) e a outra inicia pela interface java.util.Map (possui dois parâmetros de tipo, chamados K e V, o primeiro representa o tipo das chaves e o segundo o tipo dos valores que são manipulados pela coleção). Todas as interfaces são genéricas.

A interface java.util.Collection define os métodos que deverão ser implementados por todas as coleções representadas pelas interfaces. Não há nenhuma implementação direta para esta interface no framework de coleções do Java. Apenas os métodos que são comuns a todos os tipos de coleções que são utilizados.




A tabela a seguir detalha as classes e interfaces da Java Collection Framework.  


Interface Implementações Descrição
List ArrayList, LinkedList, Vector Estruturas de dados baseadas em acesso posicional.
Map HashMap, HashTable, LinkedHashMap, TreeMap Estruturas de dados que mapeiam chaves a valores.
Set HashSet, LinkedHashSet, TreeSet Estruturas baseadas em elementos únicos (sem repetição).
Queue

ii

PriorityQueue Filas que ordenam elementos de forma First In First Out. Filas de prioridade ordenam elementos de acordo com um comparador dado.

Várias outras classes e interfaces residem no pacote java.util. Funcionalidades de data e hora representadas pelas classes Date, Calendar, e TimeZone. Regiões geográficas são representadas pela classe Locale. A classe Currency representa unidades monetárias padronizadas pela ISSO 4217. Um gerador de números randômicos é fornecido pela classe Random. E a classe StringTokenizer desmembra strings de texto em pedaços menores chamados tokens.

Declaração de uma coleção:


Há 3 (três) tipos principais de objetos Java definidos para esse fim:

1. Set: representa a mesma ideia de conjuntos da matemática, ou seja, um grupo de objetos sem ordem definida, porém, únicos. Como mostra a figura abaixo:


Figura 1: conjunto de objetos

Não se pode prever a ordem com a qual serão apresentados os elementos. Para alguns problemas, isso não tem importância.

Os sets possuem uma característica importante em relação às buscas de objetos em seu interior, pois não precisam percorrer todos eles.

O principal representante dos Set é a classe HashSet:

Exemplo 1:

import java.util.*;

public class Program
{
    public static void main(String[] args)
    {
        // Populate a HashSet with three integers.
        HashSet hs = new HashSet();
        hs.add(new Integer(1));
        hs.add(new Integer(2));
        hs.add(new Integer(2));
        hs.add(new Integer(3));

        // Determine the size of the HashSet.
        System.out.println("The HashSet contains " +
            hs.size() + " elements.");

        // Iterate over the contents of the HashSet.
        Iterator iter = hs.iterator();
        while (iter.hasNext())
        {
            System.out.println(iter.next().toString());
        }

        // Determine if an element exists, and if it does,
        // remove it.
        if (!hs.isEmpty())
        {
            Integer toRemove = new Integer(2);
            if (hs.contains(toRemove))
            {
                if (hs.remove(toRemove))
                {
                    System.out.println("Successfully removed element " +
                        toRemove.toString());
                }
            }
        }
    }
}
run:
The HashSet contains 3 elements.
1
2
3
Successfully removed element 2


Exemplo 2:

import java.util.*;

public class Program2 {

    public static void main(String[] args) {
        //criando o objeto Set
        Set cores = new HashSet(0);
//adicionando elementos ao objeto
        cores.add("azul");
        cores.add("amarelo");
        cores.add("verde");

//criando o objeto iterator para poder percorrer o Set
        Iterator it = cores.iterator();

//imprimindo os objetos
        while (it.hasNext()) {
            String cor = (String) it.next();
            System.out.println(cor);
        }
    }
}

run:
verde
amarelo
azul

Definição de Set

Interface que define uma coleção, ou conjunto, que não contém duplicatas de objetos. Isto é, são ignoradas as adições caso o objeto ou um objeto equivalente já exista na coleção. Por objetos equivalentes, entenda-se objetos que tenham o mesmo código hash (retornado pelo método hashCode()) e que retornem verdadeiro na comparação feita pelo método equals().
Não é garantida a ordenação dos objetos, isto é, a ordem de iteração dos objetos não necessariamente tem qualquer relação com a ordem de inserção dos objetos. Por isso, não é possível indexar os elementos por índices numéricos, como em uma List.


2. Coleções em Java - List

Uma coleção indexada de objetos às vezes chamada de sequência. Como nos vetores, índices de List são baseados em zero, isto é, o índice do primeiro elemento é zero. Além dos métodos herdados de Collection, List fornece métodos para manipular elementos baseado na sua posição (ou índice) numérica na lista, remover determinado elemento, procurar as ocorrências de um dado elemento e percorrer sequencialmente (ListIterator) todos os elementos da lista. A interface List é implementada por várias classe, incluídas as classes ArrayList (implementada como vetor), LinkedList e Vector.
Na lista de interfaces da estrutura de coleções destacam-se os conjuntos, listas, filas e mapas:
Uma lista é uma coleção ordenada de elementos do mesmo tipo, conhecida por seqüência. Os elementos de uma lista podem ser acessados pela sua posição, isto é, seu índice. O primeiro elemento de qualquer lista tem índice 0 (zero).

As listas são derivadas da interface java.util.List<E>, que por sua vez, estende a interface Collection.

As listas podem receber elementos iguais, ou seja, dois objetos obj1 e obj2, onde obj1.equals(obj2) retorna verdadeiro, além de múltiplos null.

Demonstração da utilização dos métodos da classe ArrayList na manipulação de vetores ou arrays dinâmicos.

Observe que:

List<String> words = new ArrayList<String>();

é diferente de:

ArrayList<String> words = new ArrayList<String>();

Não é exatamente a mesma coisa (usar o ArrayList), porém funciona. ArrayList tem, no mínimo, os mesmos métodos e funcionalidade que a List, mas o contrário não é necessariamente verdadeiro.

Se existe uma interface para os objetos que você manipula, é aconselhável utilizar sempre referência para as interfaces e não para as implementações.

Imagina algum método que receba uma lista como parâmetro ou que devolva uma lista, já pensou se você marca o parâmetro ou retorno como sendo do tipo ArrayList ao invés de List, você vai obrigar todo mundo a ter que utilizar a classe ArrayList, isso não é compatível com o conceito de reutilidade de código.

E se tiver uma própria implementação de List, que não é um ArrayList, como é que fica?
Não precisa nem ser uma implementação de List feita pelo usuário, basta ter algum código que utilize outras implementações de List como por exemplo Vector ou LinkedList.

Lembre-se, se uma classe implementa alguma interface, procure referenciar sempre essa interfaces.

A classe ArrayList (ou ArrayList<E> se usada com Genérics) é uma implementação da interface List. Objetos desta classe se comportam como arrays redimensionáveis e permitem a inserção de todos os tipos de dados, incluindo o valor null.

Adicionando elementos

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

No Exemplo abaixo, foram implementados trechos de códigos que demonstram a utilização da classe ArrayList para criar, manter e percorrer uma lista de contatos. As seguintes funcionalidades foram implementadas: a) declarando e instanciando um objeto agenda; b) usando o método add() para gravar 4 contatos na agenda; c) mostrando os "n" contatos da agenda (usando o índice); d) removendo o i-ésimo elemento da agenda; e) mostrando os "n" contatos da agenda (usando for-each); e, f) mostrando os "n" contatos da agenda (com iterator).

Metodos:

boolean add(Object element) Adiciona o elemento especificado no final da lista
void add(int index, Object element) Insere o elemento especificado na posição indicada da lista
void clear() Remove todos os elementos da lista
boolean contains(Object element) Retorna verdadeiro se a lista contém o elemento especificado e falso caso contrário
Object get(int index) Retorna o i-ésimo elemento da lista
int indexOf(Object element) Retorna a posição da primeira ocorrência do elemento especificado na lista
boolean isEmpty() Retorna verdadeiro se a lista estiver vazia e falso caso contrário
int lastIndexOf(Object element) Retorna a posição da última ocorrência do elemento especificado na lista
Object remove(int index) Remove o i-ésimo elemento da lista
Object set(int index, Object element) Substitui o i-ésimo elemento da lista pelo elemento especificado
int size() Retorna o número de elementos da lista

Exemplo:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
 
public class Lista1 {
 
  public static void main(String[] args) {
    Scanner ler = new Scanner(System.in);
 
    // [ A ] declarando e instanciando uma agenda de contatos
    ArrayList<String> agenda = new ArrayList();
 
    // [ B ] usando o método add() para gravar 4 contatos na agenda
    agenda.add("Maria Gonzalves;11 1234-3456");
    agenda.add("Pedro Lira;22 11 2376-6754");
    agenda.add("Carla Vieira;11 2332-8976");
    agenda.add("Clarice Matias;11 2765-4567");
 
    int i;
 
    // [ C ] mostrando os "n" contatos da agenda (usando o índice)
    // número de elementos da agenda: método size()
    System.out.printf("Percorrendo o ArrayList (usando o índice)\n");
    int n = agenda.size();
    for (i=0; i<n; i++) {
      System.out.printf("Posição %d- %s\n", i, agenda.get(i));
    }
 
    System.out.printf("\nInforme a posição a ser excluída:\n");
    i = ler.nextInt();
 
    try {
      // [ D ] remove o i-ésimo contato da agenda
      agenda.remove(i);
    } catch (IndexOutOfBoundsException e) {
        // exceção lançada para indicar que um índice (i)
        // está fora do intervalo válido (de 0 até agenda.size()-1)
        System.out.printf("\nErro: posição inválida (%s).",
          e.getMessage());
    }
 
    // [ E ] mostrando os "n" contatos da agenda (usando for-each)
    System.out.printf("\nPercorrendo o ArrayList (usando for-each)\n");
    i = 0;
    for (String contato: agenda) {
      System.out.printf("Posição %d- %s\n", i, contato);
      i++;
    }
 
    // [ F ] mostrando os "n" contatos da agenda (com iterator)
    System.out.printf("\nPercorrendo o ArrayList (usando iterator)\n");
    i = 0;
    Iterator<String> iterator = agenda.iterator();
    while (iterator.hasNext()) {
      System.out.printf("Posição %d- %s\n", i, iterator.next());
      i++;
    }
  }
}
Execução no Netbeans:

run:
Percorrendo o ArrayList (usando o índice)
Posição 0- Maria Gonzalves;11 1234-3456
Posição 1- Pedro Lira;22 11 2376-6754
Posição 2- Carla Vieira;11 2332-8976
Posição 3- Clarice Matias;11 2765-4567

Informe a posição a ser excluída:

0 (foi digitado zero e teclado enter)

Percorrendo o ArrayList (usando for-each)
Posição 0- Pedro Lira;22 11 2376-6754
Posição 1- Carla Vieira;11 2332-8976
Posição 2- Clarice Matias;11 2765-4567

Percorrendo o ArrayList (usando iterator)
Posição 0- Pedro Lira;22 11 2376-6754
Posição 1- Carla Vieira;11 2332-8976
Posição 2- Clarice Matias;11 2765-4567


Exemplo 1, utilização do método add:
Classe: Adiciona.java

import java.util.Collection;
import java.util.ArrayList;
public class Adiciona {
    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);
    }
}

run:
Lista de nomes: [João, Maria, Eduardo, Silvana, Mário]

Exemplo 2, utilização do método isEmpty, que verifica se os dados dentro de um List estão vazios, tendo como retorno valor booleano, true ou false.

Classe: EstaVazia.java

import java.util.Collection;
import java.util.ArrayList;
 
public class EstaVazia {
    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);
        }
    }
}

run:
Contém valores -> [A, B, C, D, E, F]

Exemplo 3, para excluir uma ocorrência de um valor especificado é usado o método remove:

Classe: Remover.java

import java.util.Collection;
import java.util.ArrayList;
 
public class Remove {
    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 o objeto 312
        System.out.println(“Valores atualizados da fila:”+fila);
    }
}

run:
Valores da fila: [255, 312, 883, 122, 9]
Valores atualizados da fila:[255, 883, 122, 9

Exemplo 4, do método clear que irá limpar todos os elementos da coleção referenciada.
Classe: Limpar.java

Para excluir uma ocorrência do valor especificado é usado o método remove. - See more at: http://www.devmedia.com.br/visao-geral-da-interface-collection-em-java/25822#sthash.G03NVkvD.dpuf

package listas;
import java.util.Collection;
import java.util.ArrayList;
public class Limpar {
    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);
    }
}


run:
Listagem dos Livros: [Java, Php, Python, SQL]
Listagem após o clear: []

Exemplo 5, verificando a existência de um elementos dentro de uma coleção co o método contains:
Classe: Verifica.java

package listas;
import java.util.ArrayList;
import java.util.Collection;
public class Verifica {
    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);  
    }
 }

run:
Contém a vogal I ? true
Lista das vogais: [A, E, I, O, U]


Exemplo 6, adicionando elementos de uma lista em outra:

Classe: AdicionaDiferente.java

package listas;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class AdicionaDiferente {
    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);
    }
}

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.

- See more at: http://www.devmedia.com.br/visao-geral-da-interface-collection-em-java/25822#sthash.G03NVkvD.dpuf

Exemplo 7, a instrução foreach (para cada) que permite acessar cada item individualmente.
Classe: VerificaUmPorUm.java

package listas;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class VerificaUmPorUm {
    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);
        }
    }
}
run:
Vogal: A
Vogal: E
Vogal: I
Vogal: O
Vogal: U


Exemplo 8:
Classe: Exemplo.java

package listas;
import java.util.*;
public class Exemplo {
  public static void main(String[] args) {
    List l = new ArrayList();
    Map m = new TreeMap();
    Set s = new TreeSet();
    
    l.add(new Integer(1));
    l.add(new Integer(4));
    l.add(new Integer(3));
    l.add(new Integer(2));
    l.add(new Integer(3));
    
    m.put(new Integer(1), "A");
    m.put(new Integer(4), "B");
    m.put(new Integer(3), "C");
    m.put(new Integer(2), "D");
    m.put(new Integer(3), "E");
    
    System.out.println("Adding to Set");
    System.out.println("Adding 1: " + s.add(new Integer(1)));
    System.out.println("Adding 4: " + s.add(new Integer(4)));
    System.out.println("Adding 3: " + s.add(new Integer(3)));
    System.out.println("Adding 2: " + s.add(new Integer(2)));
    System.out.println("Adding 3: " + s.add(new Integer(3)));
   
    System.out.println("List");
    Iterator i = l.iterator();
    while (i.hasNext()) System.out.println(i.next());
    
    System.out.println("Map using keys");
    i = m.keySet().iterator();
    while (i.hasNext()) System.out.println(m.get(i.next()));
    
    System.out.println("Map using entries");
    i = m.entrySet().iterator();
    while (i.hasNext()) System.out.println(i.next());
    
    System.out.println("Set");
    i = s.iterator();
    while (i.hasNext()) System.out.println(i.next());
  }
}

run:
Adding to Set
Adding 1: true
Adding 4: true
Adding 3: true
Adding 2: true
Adding 3: false
List
1
4
3
2
3
Map using keys
A
D
E
B
Map using entries
1=A
2=D
3=E
4=B
Set
1
2
3
4

Exemplo 9:

package listas;
import java.util.*;
public class UseComparable {
  public static void main(String[] args)
                     throws java.io.IOException {
    String[] names = { "Sue", "Bill", "Tom", "Dave", "Andy",
                       "Mary", "Beth", "Bill", "Mike" };
    TreeSet sl = new TreeSet(Arrays.asList(names));
    Iterator it = sl.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
  }
}

run:
Andy
Beth
Bill
Dave
Mary
Mike
Sue
Tom

Exemplo 10:

package listas;
import java.util.*;
public class UseComparator {
  public static void main(String[] args) throws java.io.IOException {
    String[] names = { "Sue", "Bill", "Tom", "Dave", "Andy",
                       "Mary", "Beth", "Bill", "Mike" };
 
    TreeSet s2 = new TreeSet(new ReverseComparator());
    s2.addAll(Arrays.asList(names));
     
    Iterator it = s2.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
  }
}
 
class ReverseComparator implements Comparator {
  public int compare(Object o1, Object o2) {
    if (o1 instanceof String && o2 instanceof String)
      return -((String)o1).compareTo((String)o2);
    else throw new ClassCastException("Objects are not Strings");
  }
}

run:
Tom
Sue
Mike
Mary
Dave
Bill
Beth
Andy

Exemplo 11:

package listas;
import java.util.*;
public class UseComparableAndComparator {
 
  public static void main(String[] args) throws java.io.IOException {
    String[] names = { "Sue", "Bill", "Tom", "Dave", "Andy",
                       "Mary", "Beth", "Bill", "Mike" };
 
    TreeSet sl = new TreeSet(Arrays.asList(names));
    Iterator it = sl.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
 
    TreeSet s2 = new TreeSet(new ReverseComparator());
    s2.addAll(Arrays.asList(names));
    
    it = s2.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
  }
}

run:
Andy
Beth
Bill
Dave
Mary
Mike
Sue
Tom
Tom
Sue
Mike
Mary
Dave
Bill
Beth
Andy

Exemplo 11:

package listas;

import java.util.*;
 
public class GenericCollectionsTest {
  
  public static void main(String[] args) {
 
    List<String> ls = new ArrayList<String>();
    
    ls.add("Hello");
    ls.add("how");
    ls.add("are");
    ls.add("you");
    ls.add("today");
    
    // using iterator
    StringBuffer result = new StringBuffer(); 
    Iterator<String> is = ls.iterator();
    while (is.hasNext())
      result.append(is.next().toUpperCase()).append(' ');
    result.append('?');
    System.out.println(result);
    
    // using for-each loop
    result = new StringBuffer();
    for (String s : ls) result.append(s.toLowerCase()).append(' ');
    result.append('?');
    System.out.println(result);
 
    // old way
    List l = new ArrayList();
    
    l.add("Hello");
    l.add("how");
    l.add("are");
    l.add("you");
    l.add("today");
    
    // using iterator
    result = new StringBuffer();
    Iterator i = l.iterator();
    while (i.hasNext())
      result.append(((String)i.next()).toUpperCase()).append(' ');
    result.append('?');
    System.out.println(result);
    
    // using for-each loop
    result = new StringBuffer();
    for (Object o : l)
      result.append(((String)o).toLowerCase()).append(' ');
    result.append('?');
    System.out.println(result);
 
  }
}
run:
HELLO HOW ARE YOU TODAY ?
hello how are you today ?
HELLO HOW ARE YOU TODAY ?
hello how are you today ?


Exemplo 12:

package listas;
import java.awt.Color;
import java.util.*;
import javax.swing.JOptionPane;
public class TesteColecao {
    private String colors[] = {"vervelha", "branca", "azul"};
    // cria um ArrayList, adiciona objetos e manipula
    public TesteColecao() {
        ArrayList list = new ArrayList();
        String var = "";

        // Adiciona um objeto para lista
        list.add(Color.magenta); // Adiciona um objeto color

        for (int count = 0; count < colors.length; count++) {
            list.add(colors[ count]);
        }

        list.add(Color.cyan); // Adiciona um objeto color

        // saída do conteúdo da lista
        var = "ArrayList: \n\r";

        for (int count = 0; count < list.size(); count++) {
            var += list.get(count) + "\n\r ";
        }

        JOptionPane.showMessageDialog(null, var, "ArrayList", JOptionPane.INFORMATION_MESSAGE);
        // remove todos os objetos String
        removeStrings(list);
        // saída do conteúdo da lista
        var = "ArrayList depos da chamada remove Strings: \n\r";

        for (int count = 0; count < list.size(); count++) {
            var += list.get(count) + "\n\r ";
        }
        JOptionPane.showMessageDialog(null, var, "ArrayList", JOptionPane.INFORMATION_MESSAGE);
    }
    // remove objetos String objects da Coleção
    public void removeStrings(Collection collection) {
        // recebe iterator
        Iterator iterator = collection.iterator();

        // laço de repetição while na coleção verifica item
        while (iterator.hasNext()) {
            if (iterator.next() instanceof String) {
                iterator.remove(); // remove objeto String
            }
        }
    }
    // executa aplicação
    public static void main(String args[]) {
        new TesteColecao();
    }
} // fim da classe TesteColecao



Exemplo 13:

package listas;
import java.util.*;
import javax.swing.JOptionPane;

public class TesteList {
    private String colors[] = {"preta", "amarela", "verde",
        "azul", "violeta", "prata"};
    private String colors2[] = {"ouro", "branca", "marrom",
        "azul", "cinza", "prata"};

    // atribuir e manipular objetos LinkedList
    public TesteList() {
        LinkedList link = new LinkedList();
        LinkedList link2 = new LinkedList();

        // adiciona elementos para cada lista
        for (int count = 0; count < colors.length; count++) {
            link.add(colors[ count]);
            link2.add(colors2[ count]);
        }

        link.addAll(link2); // concatena lista
        link2 = null; // release resources
        imprimeLista(link);
        uppercaseStrings(link);
        imprimeLista(link);

  JOptionPane.showMessageDialog(null, "Deletando elementos de 4 a 6...", "Lista", JOptionPane.INFORMATION_MESSAGE);

        removeItems(link, 4, 7);

        imprimeLista(link);
    }

    // saida conteudo List
    public void imprimeLista(List list) {

        String var = "";
        var = "lista: \n\r";

        for (int count = 0; count < list.size(); count++) {
            var += list.get(count) + "\n\r";
        }

        JOptionPane.showMessageDialog(null, var, "Lista", JOptionPane.INFORMATION_MESSAGE);
    }

    // objeto String local e converte para uppercase
    public void uppercaseStrings(List list) {
        ListIterator iterator = list.listIterator();

        while (iterator.hasNext()) {
            Object object = iterator.next(); // get item

            if (object instanceof String) // check for String
            {
                iterator.set(
                        ((String) object).toUpperCase());
            }
        }
    }

    // obtem sublista e usa metodo clear para deletar od itens
    public void removeItems(List list, int start, int end) {
        list.subList(start, end).clear(); // remove items
    }

    // executa aplicação
    public static void main(String args[]) {
        new TesteList();
    }
}


Exemplo 14:

package listas;
import java.util.*;
import javax.swing.JOptionPane;
public class TesteSet {

    private String colors[] = {"vermelha", "branca", "azul",
        "verde", "cinza", "laranja", "bronze", "branca", "cinza",
        "pesego", "ciza", "laranja"};

    // Cria e imprime ArrayList
    public TesteSet() {
        ArrayList list;

        list = new ArrayList(Arrays.asList(colors));
        String var = "";
        JOptionPane.showMessageDialog(null, list, "ArrayList", JOptionPane.INFORMATION_MESSAGE);
        imprimeNaoDuplicados(list);
    }

    // cria um conjunto de array para eleiminar duplicados
    public void imprimeNaoDuplicados(Collection collection) {
        // cria um HashSet e obtem iterator
        HashSet set = new HashSet(collection);
        Iterator iterator = set.iterator();
        String var = "Não duplicados: \n\r";

        while (iterator.hasNext()) {
            var += iterator.next() + "\n\r";
        }
        JOptionPane.showMessageDialog(null, var, "HashSet", JOptionPane.INFORMATION_MESSAGE);
    }
    // executa aplicação
    public static void main(String args[]) {
        new TesteSet();
    }
} // fim da classe TesteSet




Exemplo 15:

package listas;
import java.util.*;
import javax.swing.JOptionPane;

public class TesteOrdenacaoSet {
    private static String names[] = {"amarela", "verde", "preta",
        "pesego", "cinza", "branca", "laranja", "vermelha", "verde"};
    private String var = "";

    // cria uma coleção ordenado do TreeSet, e manipula-o
    public TesteOrdenacaoSet() {
        TreeSet tree = new TreeSet(Arrays.asList(names));
        var = "Coleção total \n\r";

        imprimeConjunto(tree);

        // pega a base da coleção sobre "laranja"
        var = "headSet (\"laranja\") \n\r";
        imprimeConjunto(tree.headSet("laranja"));

        // pega o final da coleção sobre "lararanja"
        var = "tailSet (\"laranja\") \n\r";
        System.out.print("tailSet (\"laranja\"): ");
        imprimeConjunto(tree.tailSet("laranja"));

        // pega o primeiro e o último elemento
        var = "primeiro: " + tree.first() + "\n\r";
        var += "ultimo : " + tree.last();
        JOptionPane.showMessageDialog(null, var, "TreeSet", JOptionPane.INFORMATION_MESSAGE);
    }

    // imprime a coleção
    public void imprimeConjunto(SortedSet set) {
        Iterator iterator = set.iterator();

        while (iterator.hasNext()) {
            var += iterator.next() + "\n\r ";
        }

        JOptionPane.showMessageDialog(null, var, "TreeSet", JOptionPane.INFORMATION_MESSAGE);
        System.out.println();
    }

    // executa a aplicação
    public static void main(String args[]) {
        new TesteOrdenacaoSet();
    }
} // fim da classe TesteOrdenacaoSet



Exemplo 16:

package listas;

import java.util.*;
import javax.swing.JOptionPane;

public class TesteMap {

    private static String names[] = {"um", "dois", "tres",
        "quatro", "cinco", "seis", "sete", "dois", "dez", "quatro"};
    private String var = "";

    // constroe um HashMap e imprime conteudo
    public TesteMap() {
        HashMap map = new HashMap();
        Integer i;

        for (int count = 0; count < names.length; count++) {
            i = (Integer) map.get(
                    new Character(names[ count].charAt(0)));

            // se chave não esta no map então é dado um valor e
            // do contrário incrementa este valor em 1
            if (i == null) {
                map.put(
                        new Character(names[ count].charAt(0)),
                        new Integer(1));
            } else {
                map.put(
                        new Character(names[ count].charAt(0)),
                        new Integer(i.intValue() + 1));
            }
        }

        var = "Número de palavras iciadas com cada letra: \n\r";

        imprimetMap(map);
    }

    // saí­da do conteúdo do map
    public void imprimetMap(Map mapRef) {
        var += mapRef.toString() + "\n\r";
        var += "tamanho: " + mapRef.size() + "\n\r";
        var += "É vazio: " + mapRef.isEmpty() + "\n\r";
        JOptionPane.showMessageDialog(null, var, "Teste Map", JOptionPane.INFORMATION_MESSAGE);
    }

    // executa a aplicação
    public static void main(String args[]) {
        new TesteMap();
    }
} // fim classe Teste Map



A interface List possui um iterator especial, o ListIterator, que permite o início da iteração em qualquer ponto da lista. Toda coleção possui um iterator, que é usado para percorrer os elementos dela.

List possui os seguintes novos métodos (além dos que “vieram” de Collection):

void add(int i, E elemento) » adiciona um elemento do tipo E à lista, na posição i;

boolean addAll(int i, Collection<? extends E> c) » adiciona todos os elementos de uma coleção c à lista, na posição i;
    E get(int i) » retorna o elemento do tipo E, que está na posição i; int indexOf(Object o) » retorna a posição do primeiro objeto o da lista - se ele não existir, retorna -1;
    Iterator<E> iterator() » retorna um iterator, que será usado para percorrer todos os elementos da lista;  int lastIndexOf(Object o) » retorna a posição do último objeto o da lista - se ele não existir, retorna -1;

    ListIterator<E> listIterator() » retorna um iterator específico para listas, que será usado para percorrer todos os elementos da mesma;
    ListIterator<E> listIterator(int i) » retorna um iterator específico para listas, que será usado para percorrer todos os elementos da mesma, a partir da posição i;
    boolean remove(int i) » remove o elemento que está na posição i da coleção;

    E set(int i, E elemento) » substitui o elemento que está na posição i pelo emento que foi passado como argumento - o elemento antigo é retornado pelo método;
    List<E> subList(int inicio, int fim) » retorna uma lista com todos os elementos da lista original, compreendidos entre inicio (inclusive) e fim (exclusive);

OBS.: Collection<? extends E> c quer dizer: objeto c, do tipo Collection, que contém elementos do mesmo tipo da coleção que está executando o método

 

3. Queue (fila):


Uma coleção utilizada para manter uma "fila" de elementos. Existe uma ordem linear para as filas que é a "ordem de chegada". As filas devem ser utilizadas quando os itens deverão ser processados de acordo com a ordem "PRIMEIRO-QUE-CHEGA, PRIMEIRO-ATENDIDO". Por esta razão as filas são chamadas de Listas FIFO, termo formado a partir de "First-In, First-Out".

Exemplo 1:

package colecoes;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {

        Queue<String> qe = new LinkedList<String>();

        qe.add("b");
        qe.add("a");
        qe.add("c");
        qe.add("e");
        qe.add("d");

        Iterator it = qe.iterator();
        System.out.println("Initial Size of Queue :" + qe.size());

        while (it.hasNext()) {
            String iteratorValue = (String) it.next();
            System.out.println("Queue Next Value :" + iteratorValue);
        }
        // get value and does not remove element from queue
        System.out.println("Queue peek :" + qe.peek());

        // get first value and remove that object from queue
        System.out.println("Queue poll :" + qe.poll());
        System.out.println("Final Size of Queue :" + qe.size());
    }
}

run:
Initial Size of Queue :5
Queue Next Value :b
Queue Next Value :a
Queue Next Value :c
Queue Next Value :e
Queue Next Value :d
Queue peek :b
Queue poll :b
Final Size of Queue :4


Exemplo 2:

package colecoes;

import java.util.LinkedList;
import java.util.Queue;

public class MainDemo {
    public void queueExample() {
        Queue queue = new LinkedList();

        queue.add("Java");
        queue.add("DotNet");

        queue.offer("PHP");
        queue.offer("HTML");

        System.out.println("remove: " + queue.remove());
        System.out.println("element: " + queue.element());
        System.out.println("poll: " + queue.poll());
        System.out.println("peek: " + queue.peek());
    }
    public static void main(String[] args) {
        new MainDemo().queueExample();
    }
}

run:
remove: Java
element: DotNet
poll: DotNet
peek: PHP

4. Map e SortedMap (mapa):

Uma mapa armazena pares, chave e valor, chamados de itens. As chaves não podem ser duplicadas e são utilizadas para localizar um dado elementos associado. As chaves podem ser mantidas ordenadas (SortedMap) ou não. Map não é uma Collection pois uma Collection não trabalha com chaves. Utilizada em relações de chave-valor entre os elementos. Cada chave pode conter apenas um único valor associado.

Usa-se SortedMap para situações onde se deseja ordenar os elementos, esses elementos são ordenados pela chave e não pelo valor.

Exemplo 1:

package colecoes;
import java.util.HashMap;
import java.util.Map;

public class Map1 {
    public static void main(String[] args) {
        System.out.println("-------------------Map-------------------");
        //criando um mapa, Map é interface, HashMap é a implementação
        Map< String, String> mapa = new HashMap< String, String>();
        //inserindo elementos no mapa: ex: a -> chave ; Letra A -> valor
        mapa.put("a", "Letra A");
        mapa.put("b", "Letra B");
        mapa.put("c", "Letra C");
        //removendo pela chave
        mapa.remove("a");
        //listando os elementos do mapa
        System.out.println("Listagem: " + mapa);
        //pegando um valor a partir do mapa
        System.out.println("Pegar a partir chave b: " + mapa.get("b"));
    }
}

run:
-------------------Map-------------------
Listagem: {b=Letra B, c=Letra C}
Pegar a partir chave b: Letra B

Exemplo 2:


package colecoes;

import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

public class ShortedMap1 {
    public static void main(String[] args) {
        System.out.println("-------------------SortedMap-------------------");
        //criando um mapa ordenado
        SortedMap< String, String> mapaOrdenado = new TreeMap< String, String>();
        //inserindo elementos no mapa
        mapaOrdenado.put("um", "11111");
        mapaOrdenado.put("dois", "222222");
        mapaOrdenado.put("tres", "33333");
        //listando os elementos do mapa
        System.out.println("Listando: " + mapaOrdenado);
        //como a
    }
}

run:
-------------------SortedMap-------------------
Listando: {dois=222222, tres=33333, um=11111}


5. Diferença entre Array e ArrayList

Modo de declaração:

Array

int[] nomeDaVariavel = new int[10];

Foi criado uma variável cuja elementos são do tipo int e foi indicado que ela é uma array colocando [] após a declaração do tipo da variável, e também foi idicado que o tamanho é 10.

ArrayList

List<int> nomeDaVariavel = new ArrayList<int>();

Foi declarada uma lista do tipo int e a lista foi iniciada como um ArrayList.

Na array ao ser criada foi definida o tamanho 10, já a ArrayList não foi definido nenhum tamanho pois a arrayList tem um tamanho dinâmico, enquanto a array tem o tamanho fixo igual a 10.

Se no array for deletado o índice 4 ele ficara vazio, já no ArrayList se for deletado o índice 4 o  elemento da lista de in dice 5 recuará e ficará com o ídice 4 e toda a lista ira "recuar", o elemento de índice 6 passa para 5, e assim sucessivamente.