JSF 2.0: Componentes básicos

O nome da postagem se refere ao JSF 2.0, mas os componentes que serão mostrados também funcionam no JSF 1.2.
Para começar crie um projeto com o nome de ComponentesBasicos, dentro de pacotes de código-fonte crie um pacote com o nome de controle. Nossa base será um TesteBean.java que deverá ser criando dentro do pacote controle. Segue o código:

@Named
@javax.enterprise.context.RequestScoped
public class TesteBean {

    private boolean confirma;
    private String tipoPessoa;
    private List<String> cores;
    private List<String> coresSelecionadasCheckbox;
    private List<String> coresSelecionadasManyMenu;
    private String corSelecionadaOneMenu;

    public TesteBean() {
        cores = new ArrayList<String>();
        cores.add("Amarelo");
        cores.add("Azul");
        cores.add("Preto");
        cores.add("Vermelho");
    }
    
    //Gerar getters e setters
}

Veja que usamos o construtor para inicializar nossa lista de cores.

Para fazer esse exemplo vamos aproveitar a pagina index que é criada juntamente com o projeto. Então vamos começar a conhecer os componentes:
SelectBooleanCheckbox
Como o nome já diz, ele retorna um valor booleano (true ou false).
Exemplo:

Codigo:

<h:selectBooleanCheckbox value="#{testeBean.confirma}" />
<h:outputText value="Deseja receber mais informações desse blog?"/>

SelectOneRadio
Quanto a esse componente, entre as várias opções, apenas uma pode ser selecionada
Exemplo:

Codigo:

<h:selectOneRadio value="#{testeBean.tipoPessoa}">
    <f:selectItem itemLabel="Fisica" itemValue="F" />
   <f:selectItem itemLabel="Juridica" itemValue="J" />
</h:selectOneRadio>

SelectOneMenu
Este componente gera algo mais conhecido como um combobox. Mais detalhes...
Exemplo:

Codigo:

<h:selectOneMenu value="#{testeBean.corSelecionadaOneMenu}" >
    <f:selectItems value="#{testeBean.cores}" />
</h:selectOneMenu>

SelectManyCheckbox
Componente que permite selecionar vários objetos de uma vez só, marcando os checkbox.
Exemplo:

Código:

<h:selectManyCheckbox value="#{testeBean.coresSelecionadasCheckbox}" layout="pageDirection" >
    <f:selectItems value="#{testeBean.cores}" />
</h:selectManyCheckbox>

SelectManyMenu
Componente parecido com o SelectOneMenu, com a diferença que este permite selecionar vários objetos de uma vez, basta usar o CTRL e clicar nos objetos que deseja selecionar.
Exemplo:

Código:

<h:selectManyMenu value="#{testeBean.coresSelecionadasManyMenu}" style="height: 100px"  >
    <f:selectItems value="#{testeBean.cores}" />
</h:selectManyMenu>

Diferença entre usar f:selectItem e f:selectItems
f:selectItem - esta tag serve para definir valores estaticamente, ou seja diretamente na página, ele tem as propriedades itemLabel e itemValue, o primeiro é o que deve mostrar na página e o segundo é o valor que deve ser salvo em algum atributo do bean.
f:selectItems - este é mais claro, como está no plural já dá a entender que receberá uma lista de objetos.

Referência: Exadel - JSF tags

JavaEE 5: SelectOneMenu (comboBox) em JSF 1.2

Na postagem de hoje iremos fazer um SelectOneMenu ou como a maioria conhece ComboBox em JSF 1.2, numa mesma página teremos um dinâmico onde a lista vem de um bean e um estático onde os itens são definidos diretamente no código fonte da página. Segue a imagem:

Segue o código fonte do ClienteBean:

import java.util.ArrayList;
import java.util.List;
import javax.faces.model.SelectItem;

public class ClienteBean {
 private List< SelectItem > selectItemsClientes;
 private int codigoClienteSelecionado;

 public List< SelectItem > getSelectItemsClientes() {
  selectItemsClientes = new ArrayList< SelectItem >();
  selectItemsClientes.add(new SelectItem(1, "Andii"));
  selectItemsClientes.add(new SelectItem(2, "João"));
  selectItemsClientes.add(new SelectItem(3, "Maria"));
  return selectItemsClientes;
 }

 public void setSelectItemsClientes(List< SelectItem > selectItemsClientes) {
  this.selectItemsClientes = selectItemsClientes;
 }

 public int getCodigoClienteSelecionado() {
  return codigoClienteSelecionado;
 }

 public void setCodigoClienteSelecionado(int codigoClienteSelecionado) {
  this.codigoClienteSelecionado = codigoClienteSelecionado;
 } 
}

Nesse bean, temos um int que corresponde ao valor selecionado no combo, e uma lista de SelectItem (veja que o SelectItem pertence ao pacote javax.faces, sendo do próprio JSF) com valores que eu setei diretamente no bean(claro que poderiam ser valores do banco), aí vem a pergunta: mas essa lista não poderia ser de objetos mesmo, tipo List< Cliente >? A resposta é sim! Poderia ser uma lista com o objeto Cliente mesmo, porém, iria dar um trabalho muito grande para pegar esse valor, tendo que criar converter e ainda podendo enfrentar problemas de conversão! Para entender melhor, leia isso!

OBS: Lembre-se de mapear o ClienteBean no faces-config.xml, nesse exemplo usei o escopo session mesmo.

Agora segue o código fonte da página jsp que tem os comboBox:

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<html>
<f:view>
 <head>
  <title>Clientes</title>
 </head>
 <body>
  <h:panelGrid columns="1">
   <h:outputText value="SelectOneMenu com lista dinâmica" />
   <h:selectOneMenu value="#{clienteBean.codigoClienteSelecionado}">
    <f:selectItems value="#{clienteBean.selectItemsClientes}" />
   </h:selectOneMenu>
   
   <h:outputText value="SelectOneMenu com lista estática" />
   <h:selectOneMenu value="#{clienteBean.codigoClienteSelecionado}">
    <f:selectItem itemValue="1" itemLabel="Andii"/>
    <f:selectItem itemValue="2" itemLabel="João"/>
    <f:selectItem itemValue="3" itemLabel="Maria"/>
   </h:selectOneMenu>
  </h:panelGrid>
 </body>
</f:view>
</html>

Bom, para criar selectOneMenu dinâmico, usa-se o selectItems tendo como value a lista. Já para os casos estáticos, usa-se o selectItem setando o itemValue para o codigo do cliente(exemplo) e o itemLabel para o deverá aparecer na lista(exemplo: nome do cliente).

Aconselho dar uma olhada no link, tem vários outros componentes interessantes e úteis:  Mais componentes em JSF

Swing: Preenchendo um JComboBox

Nesse post iremos preencher um JComboBox com objetos, para isso vamos precisar de uma java.util.List.

Para exemplo vamos usar uma categoria. Então... precisamos de uma classe chamada Categoria.java

public class Categoria {

    private int codigo;
    private String nome;

    public int getCodigo() {
        return codigo;
    }

    public void setCodigo(int codigo) {
        this.codigo = codigo;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    @Override
    public String toString() {
        return this.nome;
    }

}

Perceba que o método toString() foi sobreescrito, isso é necessário para que ao mostrar os objetos no JComboBox, apareça o nome da categoria como referência no combo... para entender a importância disso, faça um teste: retire o método toString() e veja o resultado!

Continuando...

Crie um Formulário JFrame com o nome de ExemploCombo.java, e arraste para a tela, um JComboBox (cmbCategoria) e um JButton (btnEnviar) para testarmos.

A janela deverá ficar como a imagem abaixo:

No código-fonte crie um método carregaCombo(), com o seguinte código:

private void carregaCombo(){
        //assim como é feito numa JTable, temos o DefaultComboBoxModel que é o model do JComboBox
        DefaultComboBoxModel comboModel = (DefaultComboBoxModel) cmbCategoria.getModel();
        //removendo todos os elementos do combo
        comboModel.removeAllElements();
        //cria a lista: java.util.List
        List<Categoria> categorias = new ArrayList<Categoria>();
        //adicionando valores aleatorios a lista
        Categoria c1 = new Categoria();
        c1.setCodigo(1);
        c1.setNome("Compra");
        categorias.add(c1);

        Categoria c2 = new Categoria();
        c2.setCodigo(2);
        c2.setNome("Venda");
        categorias.add(c2);
        //percorrendo a lista para inserir os valores no combo
        for (int linha = 0; linha < categorias.size(); linha++)
        {
            //pegando a categoria da lista
            Categoria categoria = categorias.get(linha);
            //adicionando a categoria no combo
            comboModel.addElement(categoria);
        }
    }

Os comentários no código explicam o que acontece em cada linha.
Agora é necessário chamar este método no construtor da classe, logo depois de iniciar os componentes:

public ExemploCombo() {
        initComponents();
        carregaCombo();
    }

E para pegar o valor, vamos utilizar o evento do btnEnviar, para isso dê dois cliques no botão para abrir o evento:

private void btnEnviarActionPerformed(java.awt.event.ActionEvent evt) {                                         
        //pegando o objeto selecionado no combo
        Categoria categoria = (Categoria) cmbCategoria.getSelectedItem();
        //mostrando o nome da categoria em um dialogo
        JOptionPane.showMessageDialog(this, categoria.getNome());
    }

Para setar um objeto por padrão em um combo, segue o exemplo:

cmbCategoria.setSelectedItem(categoria);

Essa categoria que está sendo passada por parâmetro, seria uma categoria por exemplo pega de uma lista, ou de um outro objeto que possua uma categoria.

=)

JavaSE: Converter java.util.Date para String e vice-versa

Converter String para java.util.Date

Para converter uma String em java.util.Date, é necessário utilizar a classe java.text.SimpleDateFormat, passado uma String por parâmetro que se refere ao formato em que se encontra a String que será convertida:

SimpleDateFormat formataData = new SimpleDateFormat("dd/MM/yyyy");
Date dataEntrada = null;
try { 
    dataEntrada = formataData.parse("21/09/2010");
} catch (ParseException ex) {
    ex.printStackTrace();
}

Converter java.util.Date para String

Quando se tem um Date e quer transformar em String é só utilizar o mesmo SimpleDateFormat. O 'new Date()' pega a data atual do sistema, a String passada por parâmetro para SimpleDateFormat é o formato em que se deseja que a String seja formatada:

Date dataHoje = new Date();
SimpleDateFormat formataData = new SimpleDateFormat("dd/MM/yyyy");
String data = formataData.format(dataHoje);

Por se tratar de uma formatação onde não há riscos de ocorrer erros, não é necessário colocar a formatação dentro de um bloco 'try catch' como a conversão anterior.

JavaSE: CRUD em Swing

Neste post, iremos implementar parte do projeto do Hotel  da postagem: UML: Trabalhando com a diagramação . Este sistema será implementado em Java SE (para Desktop), com armazenamento em estruturas de dados (mais especificamente em java.util.List).

O sistema final terá a seguinte estrutura:

Obs: as classes do pacote model são as mesmas criadas na aula citada no link acima.

Mas, neste post será criado apenas o cadastro de Aposentos... então vamos lá!

Criando o projeto...

Neste projeto será utilizado o NetBeans, neste crie um novo projeto: Arquivo -  Novo Projeto - Java -  Aplicativo Java, e coloque o nome do projeto como: Hotel.

Criando o banco de dados...

Considerando que o pacote model já esteja implementado, vamos começar criando nossa classe que servirá de banco de dados, então dentro do pacote hotel, crie uma nova classe java chamada de BancoDados.java, com o seguinte codigo:

public class BancoDados {

    private static List<Aposento> aposentos = new ArrayList<Aposento>();
 
    /*
     * Aposentos
     */

    public static List<Aposento> getAposentos() {
        return aposentos;
    }

    public static void addAposento(Aposento aposento){
        aposentos.add(aposento);
    }

    public static void atualizaAposento(int linhaSelecionada, Aposento aposento){
        aposentos.set(linhaSelecionada, aposento);
    }

    public static void removeAposento(Aposento aposento){
        aposentos.remove(aposento);
    }
}

Perceba que nossos métodos são static, pois como instanciaremos apenas uma única vez nosso BancoDados, os mesmos precisarão ser acessados mas sem instanciar um novo BancoDados, isso será entendido melhor mais pra frente...

Tela inicial...
Ainda dentro do pacote hotel, crie um Formulário JFrame, chamado de Principal.java, este será nossa tela inicial do sistema. Por ser um JFrame o NetBeans dá a opção de criar a tela arrastando os componentes, então arraste um botão (JButton) para o formulário, este ficará com a seguinte aparência:

Chamando nossa tela principal...
Na classe Main.java que foi criada juntamente com o projeto, insira o seguinte codigo:

public class Main {

    public static void main(String[] args) {
       new BancoDados();

       JFrame principal = new Principal();
       principal.setVisible(true);
    }
}

perceba que nosso BancoDados está sendo instanciado, isso garante que ele seja inicializado junto com o sistema. E após ele, está sendo instanciado nosso formulário JFrame Principal.java, que é a tela inicial do sistema.
Para visualizar a aplicação, basta apertar a tecla F6 (padrão do NetBeans para executar a aplicação).

Criando a tela principal de aposentos
Agora crie um pacote chamado aposento, dentro do pacote hotel, naquele crie um novo formulário JFrame chamado Aposentos.java, arraste para a tela três botões (JButton) e uma tabela (JTable). Altere o nome das variáveis dos botões para: btnNovo, btnAlterar e btnRemover.

Para alterar os campos da tabela, clique nela com o botão direito e clique em conteúdo da tabela e vá na aba colunas, e edite as mesmas. Depois, clique novamente na tabela e vá em propriedades - aba código, e altere os modificadores de variáveis, o mesmo deve ficar como private static. Isso precisa ser feito para criamos um método estático de atualização da tabela, pois é o mesmo caso do BancoDados, mais pra frente precisaremos chamar este método sem instanciar um novo objeto Aposentos(). Então, no código fonte de Aposentos.java, insira o seguinte método(deve ficar dentro da classe):

public static void atualizaTabela(){
        DefaultTableModel tTabela = (DefaultTableModel) jTable1.getModel();
        tTabela.setNumRows(0);

        List<Aposento> aposentos = BancoDados.getAposentos();

        for (int linha = 0; linha < aposentos.size(); linha++)
        {
            Aposento aposento = aposentos.get(linha);

            tTabela.addRow(new Object[]{1});

            jTable1.setValueAt(aposento.getCodigo(), linha, 0);
            jTable1.setValueAt(aposento.getNumero(), linha, 1);
            jTable1.setValueAt(aposento.getDescricao(), linha, 2);
            jTable1.setValueAt(aposento.getValor(), linha, 3);
        }

    }

jTable1 é a minha tabela, caso esteja dando erro, verifique o nome da sua tabela.
Para que nossa tabela inicie atualizada, vamos chamar o método atualizaTabela() no construtor da classe Aposentos.java, ficando como o código abaixo:

public Aposentos() {
        initComponents();
        atualizaTabela();
    }

Agora iremos chamara tela de aposentos ao clicar no botão "Aposentos" na tela do frame Principal.java: então, em Principal.java de um duplo clique no botão "Aposentos" para que ele vá para o método do clique, onde será inserido o código para instanciar nosso frame Aposentos.java:

private void btnAposentosActionPerformed(java.awt.event.ActionEvent evt) {                                             
        JFrame aposentos = new Aposentos();
        aposentos.setVisible(true);
}    

No meu caso, eu alterei o nome da variável do meu botão para btnAposentos, por isso o nome do método inicia dessa forma.(isso vai ser de acordo com o nome dado ao botão aposentos)
Até este momento nossa aplicação já está abrindo a janela de aposentos ao clicar no botão "Aposentos" da tela inicial.

Tela de inserir aposento...
Dentro do pacote hotel.aposento crie um novo formulário JFrame com o nome de InserirAposento.java, crie a seguinte estrutura: quatro rótulos(JLabel), quatro campos de texto(JTextField) e dois botões (JButton)

Renomeie os nomes das variáveis dos campos de texto para: txtCodigo, txtNumero, txtDescricao, txtValor. E os botões para: btnOk, e btnCancelar.
Dê dois cliques no botão "Ok" para que ele vá para o método do clique do botão, e insira este codigo:

private void btnOkActionPerformed(java.awt.event.ActionEvent evt) {                                         
        int iCodigo = Integer.parseInt(txtCodigo.getText());
        int iNumero = Integer.parseInt(txtNumero.getText());
        String sDescricao = txtDescricao.getText();
        double dValor = Double.parseDouble(txtValor.getText());
        Aposento aposento = new Aposento();
        aposento.setCodigo(iCodigo);
        aposento.setNumero(iNumero);
        aposento.setDescricao(sDescricao);
        aposento.setValor(dValor);

        BancoDados.addAposento(aposento);
        Aposentos.atualizaTabela();
        this.dispose();
    } 

Este método pega os valores dos campos, seta no objeto Aposento, e insere no nosso BancoDados, veja que não foi instanciado nenhum BancoDados aqui, lembre que se instancia apenas no Main.java. Depois que ele inserir, ele atualizará a tabela de aposentos pelo codigo Aposentos.atualizaTabela() que é o mesmo caso do BancoDados, e depois disto ele fecha a janela com o código this.dispose().
Agora dê um duplo clique no botão de cancelar:

private void btnCancelarActionPerformed(java.awt.event.ActionEvent evt) {                                         
    this.dispose();
}

Observe que o botão de cancelar, apenas fechará nossa janela.
Agora, iremos no Aposentos.java para chamar o InserirAposento. Então, vá em Aposentos.java e dê um duplo clique no botão "Novo":

private void btnNovoActionPerformed(java.awt.event.ActionEvent evt) {                                         
    JFrame janela = new InserirAposento();
    janela.setVisible(true);
}

Assim, nossa aplicação já está inserindo e listando os aposentos!

Alterando um aposento...
Para facilitar nossa implementação, ao invés de criar um novo JFrame para alterar o aposento, vamos copiar o InserirAposento.java e colar no mesmo pacote em que este se encontra, renomeando ele para AlterarAposento.java (ele vai pedir pra refatorar, então refatore!)
Vá para o código fonte do AlterarAposento.java e lá nas declarações dos atributos, declare os seguintes:

private Aposento aposento;
private int linhaSelecionada;

Logo abaixo do construtor do AlterarAposento.java, crie um novo construtor, passando um int por paramêtro, este int será a linha selecionada da tabela de Aposentos, que corresponde ao índice do aposento que foi selecionado na lista.

public AlterarAposento(int linhaSelecionada){
    initComponents();

    this.linhaSelecionada = linhaSelecionada;
    aposento = BancoDados.getAposentos().get(linhaSelecionada);
    codigo.setText(String.valueOf(aposento.getCodigo()));
    numero.setText(String.valueOf(aposento.getNumero()));
    descricao.setText(aposento.getDescricao());
    valor.setText(String.valueOf(aposento.getValor()));
}

Veja que estou setando a linhaSelecionada recebida por parâmetro na linhaSelecionada declarada na classe, pois esta será utilizada para setar o índice do objeto que será alterado na lista. A próxima linha: busca na lista do BancoDados o objeto Aposento daquela determinada linha. E quanto ao restante do código, estes setam os valores nos campos, para que ao abrir a janela, os campos estejam com os valores.
Agora dê um duplo clique no botão de Ok de AlterarAposento, perceba que este já está implementado pois foi copiado do inserir, então substitua o código pelo código a seguir:

private void btnOkActionPerformed(java.awt.event.ActionEvent evt) {                                         
    int iCodigo = Integer.parseInt(codigo.getText());
    int iNumero = Integer.parseInt(numero.getText());
    String sDescricao = descricao.getText();
    double dValor = Double.parseDouble(valor.getText());
    aposento.setCodigo(iCodigo);
    aposento.setNumero(iNumero);
    aposento.setDescricao(sDescricao);
    aposento.setValor(dValor);

    BancoDados.atualizaAposento(linhaSelecionada, aposento);
    Aposentos.atualizaTabela();
    this.dispose();
}

Deixe a implementação do botão "Cancelar" como ele está.
Vá para o JFrame Aposentos.java e dê um duplo clique no botão "Alterar", implemente o mesmo da seguinte forma:

private void btnAlterarActionPerformed(java.awt.event.ActionEvent evt) {                                         
    int linhaSelecionada = jTable1.getSelectedRow();

    if (linhaSelecionada >= 0){
        JFrame janelaAlterar = new AlterarAposento(linhaSelecionada);
        janelaAlterar.setVisible(true);
    }
    else{
        JOptionPane.showMessageDialog(this, "É necessário selecionar um aposento", "Aposento", JOptionPane.INFORMATION_MESSAGE);
    }        
}     

Analisando o código: nosso int linhaSelecionada está recebendo o valor da linha selecionada da tabela. Aí esta linha é verificada, para não ocorrer de abrir a janela de alterar aposento sem ter uma linha selecionada na tabela, por isso do if e else, caso a linhaSelecionada seja maior ou igual a 0, significa que tem uma linha selecionada na tabela, então será aberto a janela de AlterarAposento passando por parâmetro o valor desta linha, senão, abre uma janela dizendo que é necessário selecionar um aposento para alterar!

Removendo um aposento...
Para o remover aposento não será necessário um novo JFrame, iremos criar um JOptionPane. Então dê um duplo clique no botão "Remover" e insira o seguinte código:

private void btnRemoverActionPerformed(java.awt.event.ActionEvent evt) {                                         
    int linhaSelecionada = jTable1.getSelectedRow();

    if (linhaSelecionada >= 0){
        int resposta = JOptionPane.showConfirmDialog(this, "Deseja excluir o aposento?");
        if (resposta == JOptionPane.YES_OPTION){
            Aposento aposento = BancoDados.getAposentos().get(linhaSelecionada);
            BancoDados.removeAposento(aposento);

            atualizaTabela();
        }
    }
    else{
        JOptionPane.showMessageDialog(this, "É necessário selecionar um aposento", "Aposento", JOptionPane.INFORMATION_MESSAGE);
    }
}

Analisando  o código: Veja que parte do código é bem parecida com o evento do botão "Alterar", mas ao invés de chamar um novo JFrame, é criada uma janela de diálogo, que recebe um valor inteiro que em seguida é verificado, caso tenha clicado em Yes, o código para a remoção do aposento é executado!
E assim termina nosso cadastro de aposento =)

Collections: Estruturas de dados

São tipos de dados compostos, diferentemente dos tipos: int, double, float, entre outros que são tipos de dados primitivos. As estruturas de dados são formas de armazenamento de dados ou objetos.
Por exemplo, os arrays são estruturas de dados lineares e estáticas para armazenar dados, porém com capacidade limitada, ou seja deve-se inicializá-lo com um tamanho. Para aumentar essa capacidade durante a execução da aplicação teria que haver um algoritmo que aumente a capacidade de informações do array.

Código-fonte:

System.out.println("-------------------Arrays-------------------");
 //inicializando array com 3 posições
 String[] array = new String[3];

 //inserindo elementos
 array[0] = "A";
 array[1] = "B";
 array[2] = "C";

 //ou
 // inicializando array com 3 elementos
 String[] array2 = { "A", "B", "C" };

 //percorrendo o array para fazer a listagem dos dados
 for (int i = 0; i < array2.length; i++){
     System.out.println(array2[i]);
 }

Resultado:

-------------------Arrays-------------------
A
B
C

Estruturas de dados Java

As estruturas de dados Java se encontram no pacote java.util. As operações básicas dessas estruturas são: adição, remoção, acesso e pesquisa. Podemos tratar uma estrutura de dados como uma coleção, pois este permite armazenar vários objetos. Os tipos de coleções estudados serão: Listas, Conjuntos e Mapas.

Listas As listas são estruturas de dados dinâmicas. Os elementos são arrumados numa ordem linear, ou seja, os elementos possuem sucessor (com exceção do ultimo elemento) e antecessor (com exceção do primeiro elemento). Alguns tipos de listas são: LIFO  e FIFO Exemplo de lista: java.util.List Pilhas (LIFO): Last in, First out [Ultimo que entra, primeiro que sai] Os elementos de uma pilha são adicionados ao topo e removidos do topo também. Exemplo: java.util.Stack
Código Fonte:

System.out.println("-------------------Pilhas-------------------");
        //criando a pilha
        Stack pilha = new Stack();
        //inserindo valores na pilha
        pilha.push("A");
        pilha.push("B");
        pilha.push("C");
        pilha.push(12.6);
        //pegando o topo da pilha
        System.out.println("Topo: " + pilha.peek());
        //percorrendo a pilha
        for (int i = 0; i < pilha.size(); i++){
            System.out.println(pilha.get(i));
        }
        //removendo um elemento, e por ser uma pilha
        //ele removerá o elemento que foi inserido por ultimo
        pilha.pop();
        System.out.println("Depois de remover um elemento:");
        //percorrendo a pilha novamente
        for (int i = 0; i < pilha.size(); i++){
            System.out.println(pilha.get(i));
        }

Resultado:

-------------------Pilhas-------------------
Topo: 12.6
A
B
C
12.6
Depois de remover um elemento:
A
B
C

Filas (FIFO): First in, First out [Primeiro que entra, primeiro que sai] Os elementos de uma pilha são adicionados ao final da fila e removidos do topo da mesma. Exemplo: java.util.Queue
Código Fonte:

System.out.println("-------------------Filas-------------------");
        //criando a fila, Queue é apenas uma interface,
        //então utilizaremos a implentação LinkedList
        Queue fila = new LinkedList();
        //inserindo elementos na fila
        fila.add("A");
        fila.add("B");
        fila.add("C");
        fila.add(12.6);
        //pegando o topo da fila
        System.out.println("Topo: " + fila.peek());
        //percorrendo a fila, este é outra forma de percorrer uma lista
        //o Object é o tipo do elemento, o obj é o elemento e a fila é nossa lista
        // o obj corresponderia ao get(i) da pilha
        for (Object obj : fila){
            System.out.println(obj);
        }
        //removendo um elemento, e por ser uma fila
        //ele removerá o elemento que foi inserido por primeiro
        fila.remove();
        System.out.println("Depois de remover um elemento:");
        //percorrendo a fila novamente
        for (Object obj : fila) {
            System.out.println(obj);
        }

Resultado:

-------------------Filas-------------------
Topo: A
A
B
C
12.6
Depois de remover um elemento:
B
C
12.6

Para entender melhor o funcionamento de pilha e fila, compare o resultado dos exemplos, pois os dois códigos fazem a mesma coisa, porém de formas diferentes.

Conjuntos

Os conjuntos não permitem que seja inseridos elementos duplicados num mesmo conjunto, e também não tem uma ordem dos elementos como nas listas, assim como os conjuntos matemáticos.

Exemplo: java.util.Set Mapas

Um mapa armazena pares (chave, valor), essa chaves e valores podem ser de qualquer tipo. A chave é utilizada para achar um elemento rapidamente. Um mapa normalmente implementada como “Tabela Hash”. Exemplo: java.util.Map

Tabela Hash

Também chamada de: Tabela de dispersão ou tabela de espalhamento ou tabela hashing. É uma estrutura de dados especial, que associa chaves de pesquisa a valores. O objetivo é, a partir de uma chave simples, fazer uma busca rápida e obter o valor desejado.

Java Collection Framework 

"Desde a versão 1.2 do JDK (depois que o renomearam para Java 2 SDK), a plataforma J2SE inclui um framework de coleções (a Collections Framework). Uma coleção é um objeto que representa um grupo de objetos. Um framework de coleções é uma arquitetura unificada para representação e manipulação de coleções, permitindo que elas sejam manipuladas independentemente dos detalhes de sua implementação."

Mais informações sobre o framework: http://javafree.uol.com.br/artigo/847654/

Estrutura do framework:

Collection: Interface base para todos os tipos de coleções.

Set: Contém apenas os métodos herdados de Collection e adiciona a restrição de que elementos duplicados não são permitidos.

Exemplo:java.util.Set
Codigo-fonte:

System.out.println("---------------Collection----------------");
       System.out.println("-------------------Set-------------------");
       //criando um set, como Set é interface, vamos utilizar a implementação HashSet
       Set< String > set = new HashSet< String >();
       //inserindo elementos
       set.add("A");
       set.add("B");
       set.add("C");
       set.add("A");
       //removendo elemento "C"
       set.remove("C");
       //percorrendo a coleção
       for (String obj : set){
           System.out.println(obj);
       }

Resultado:

---------------Collection----------------
-------------------Set-------------------
A
B

SortedSet:Usaremos implementações de SortedSet para situações onde desejarmos ordenar os elementos.

Exemplo: java.util.SortedSet
Codigo-fonte:

System.out.println("-------------------SortedSet-------------------");
       //criando um set ordenado, como SortedSet é interface, vamos utilizar a implementação TreeSet
       SortedSet< String > setOrdenado = new TreeSet< String >();
       //inserindo elementos
       setOrdenado.add("B");
       setOrdenado.add("A");
       setOrdenado.add("C");
       setOrdenado.add("A");
       //percorrendo o conjunto
       for (String obj : setOrdenado){
           System.out.println(obj);
       }

Resultado:

-------------------SortedSet-------------------
A
B
C

List: É uma coleção ordenada que pode conter valores duplicados. Além disso, temos controle total sobre a posição onde se encontra cada elemento de nossa coleção, podendo acessar cada um deles pelo índice.

Exemplo:java.util.List Codigo-fonte:

System.out.println("-------------------List-------------------");
       //criando um list, como List é interface, vamos utilizar a implementação ArrayList
       List< String > list = new ArrayList< String >();
       //inserindo elementos na lista
       list.add("A");
       list.add("C");
       list.add("E");
       //perconrrendo a lista
       System.out.println("Lista Atual");
       for (String obj: list){
           System.out.println(obj);
       }
       //inserindo um elemento numa determinada posição da lista
       list.add(1, "B");
       //perconrrendo a lista
       System.out.println("Lista com novo elemento");
       for (String obj: list){
           System.out.println(obj);
       }
       //substituindo o elemendo de uma determinada posição
       list.set(3, "D");
       //perconrrendo a lista
       System.out.println("Lista com elemento substituido");
       for (String obj: list){
           System.out.println(obj);
       }

Resultado:

-------------------List-------------------
Lista Atual
A
C
E
Lista com novo elemento
A
B
C
E
Lista com elemento substituido
A
B
C
D

Queue: Normalmente utilizamos esta interface quando queremos uma coleção do tipo fila (FIFO).

Exemplo: java.util.Queue Codigo-fonte e resultado já apresentado em Filas.

Map: 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.

Exemplo: java.util.Map
Codigo-fonte:

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"));

Resultado:

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

SortedMap: Usaremos SortedMap para situações onde desejarmos ordenar os elementos, esses elementos são ordenados pela chave e não pelo valor.

Exemplo: java.util.SortedMap
Codigo-fonte:

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 chave é uma String, a ordenação da mesma será por ordem alfabética

Resultado:

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

Obs: para executar os exemplos, crie uma classe com um método main e para executar no Netbeans utilize : Shift + F6
Exemplo:

public class Collections {

    public static void main(String[] args) {
        //Código-fonte aqui.!
    }
}

Referências: http://www.dsc.ufcg.edu.br/~jacques/cursos/p2/html/ed/colecoes.htm http://download.oracle.com/javase/tutorial/collections/index.html