Maven e Eclipse ( m2e ).

Nesse tutorial mostrarei como utilizar o gerenciador de dependências Maven com o Eclipse, mostrarei o que é necessário e a criação de um projeto simples para ver o maven em funcionamento.

Maven

Maven é uma ferramenta para o gerenciamento de dependências do projeto, que utiliza um arquivo xml chamando POM (Project Object Model) para gerenciar as dependências do projeto. Em outras palavras você não vai mais precisar baixar arquivos .jar e ficar importando eles para o projeto, com o maven apenas adicionando algumas linhas dentro do arquivo pom.xml ele já se encarrega de fazer o download e adicionar na sua aplicação. 

No site Maven Repository http://mvnrepository.com/ você pode encontrar qual quer dependência que desejar para colocar no seu pom.xml.

M2E

É um pugin para o eclipse que torna a utilização do maven mais simples diretamente do eclipse.

Todos os libs baixados pelo m2e ficam dentro da pasta .m2/repository, com isso se mais de um projeto depender do mesmo lib ele não é baixado denovo.

Ferramentas
Eclipse Download
JDK Download
m2e (maven para o eclipse)

Instalando o m2e
Após abrir o Eclipse vá em Help -> Install New Software e coloque a http://download.eclipse.org/technology/m2e/releases

Após o termino da instalação reinicie o Eclipse e está na hora de iniciar a utilização do maven.

Vamos criar um maven project, vá em File -> New -> Other -> Maven Project.

Selecione Create a simple project, e clique em next,

Group Id: org.toca.maven

Artifact Id: maven-teste

Name: Maven Teste,

e clique em finish.

Sera criada a seguinte estrutura.

Veja que o arquivo pom.xml é onde colocaremos as dependências do nosso projeto de uma maneira bem simples.

Note que foram inseridas duas dependências no projeto log4j e javax.mail, no que no momento que você inserir a dependência e salvar o arquivo o eclipse começa automaticamente a baixar o .jar e o insere no projeto e está pronto para ser usado.

Caso você não queria mais por exemplo o log4j no seu projeto basta apagar as linhas da dependência do pom.xml que ao salvar o arquivo .jar sera removido do projeto.

Porque utilizar equals() e não == para comparar String

Uma pergunta bem básica e objetiva, é possível comprar String utilizando == ? Sim. Da certo 100% das vezes? Não.

Uma das primeiras coisas que aprendi quando comecei a programar em java foi JAMAIS utilizar == para comprar Strings, mais porque isso? Vamos a uma explicação técnica.

String é um objeto, o metodo equals(Object) vai retornar true se ambas as Strings tiverem o mesmo objeto. O operador == só ira retornar true se ambas referencias de String apontarem para a mesma referencia do objeto.

Quando criamos uma String de forma literal é criado um pool de Strings, quando criamos uma outra String literal com o mesmo valor a JVM procura se ja existe uma String com esse mesmo valor no pool de Strings, caso exista, faz sua variável apontar para o mesmo endereço de memória. Por este motivo, quando você testa a igualdade das variáveis a e b através do "==", ela retorna true.


String a = "abc";    //pool de string
String b = "abc";    /*ja existe uma string com o mesmo conteúdo no pool,
                                 vai para a mesma referencia na memória*/
String c = "dda";    //vai para uma nova referencia de memoria pois não existe no pool

Se você criar strings assim, você está criando um novo objeto em memória e se testar a igualdade das variáveis a e d com "==", ela retornará false, pois não apontam para o mesmo lugar na memória.

String d = new String("abc");     //Cria um novo objeto na memoria



String a = "abc";
String b = "abc";
String c = "dda";
String d = new String("abc");


a==b = true
a==c = false
a==d = false
a.equals(d) = true

Diferença entre Array e ArrayList

Um Array pode ser bem parecido com um ArrayList, muitas vezes usamos ArrayList por costume, porem existem algumas diferenças marcantes entre elas.

Modo de declaração

Array
int[] nomeDaVariavel = new int[10];


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

Na array criamos uma variável int e indicamos que ela é uma array colocando [] apos a declaração do tipo da variável, e iniciamos a variável falando que ela é uma array de tamanho 10, portanto o tamanho da array já está definida.

Na ArrayList criamos uma lista, indicamos que ela é do tipo int e iniciamos a lista falando que é um ArrayList.

Tamanho


Note que a 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 de 10 a arrayList tem o tamanho dinâmico.

Índice 


No array quando você deleta o índice 2 ele ficara vazio, já no ArrayList quando você deletar o índice 2 a próximo elemento da lista tomara o seu lugar e toda a lista ira "recuar", o elemento do índice 3 se tornara o 2, o elemento do índice 4 se tornara o 3 e assim por diante.

Collection, diferença entre Ordenado e Classificado

Continuando com alguns assuntos que fazem parte da prova SCPJ, nesse post vou falar sobre a diferença entre Ordenado e Classificado.

Ordenado (Ordered) - É a ordem em que os elementos do conjunto serão mostrados na tela ao ser iterado. Um ArrayList é ordenado pela posição do índice. LinkedHashSet mantem a ordem estabelecida pela posição, o ultimo elemento a ser inserido sera o ultimo elemento do conjunto, diferentemente do ArrayList que você pode inserir um elemento em um índice especifico. Alguns conjuntos mantém a ordem natural dos elementos, esses conjuntos não são apenas ordenados, mas também classificados.

Classificados (Sorted) - Um conjunto classificado significa que a ordem do conjunto está determinada por alguma(s) regra(s), conhecida(s) como ordem de classificação. Semelhante ao order by do SQL.
A classificação é feita com base em propriedades do próprio objeto. Na maioria das vezes a ordem é feita utilizando a ordem natural, que nada mais é que a ordem alfabética para String e ordem numérica crescente para objetos Integer, porem e para Objetos do tipo por exemplo Cliente? Não existe uma ordem naturam para esse objeto, pelo menos até que o desenvolvedor crie uma, por meio do Comparator ou Comparable (você pode saber mais sobre elas clicando aqui e aqui)

Validando hora com Hibernate

Digamos que em alguma entidade você tem um campo Hora, e por algum motivo você vai utilizar ele como String em vez de Date ( @Temporal ), o campo vai precisar ser validado para não ser inseridos horários inválidos como 55:87, para resolver esse problema basta inserir uma anotação hibernate e o problema esta resolvido.

public class Pedido{

   @Pattern(regex="^([0-1][0-9]|[2][0-3]):[0-5][0-9]$", message="Hora inválida")
   private String hora;

   //getters e setters

}

Criar projeto Seam do zero + Hello World

Nesse post vou mostrar como criar o ambiente Seam e como fazer um Hello World.

Requisitos:


Eclipse
JBoos tools   Tambem pode ser encontrado no Eclipse Market
JBoss Seam 2.2
JBoss Application Server 5.1
Postgres
Postgres JDBC

Primeiramente Instale o Postgres, após isso abra o Eclipse e entre no Eclipse Marketplace

No campo find procure por Jboss Tools e o instale, o download + instalação levara alguns minutos, após instalado reinicie o eclipse.
Descompacte o Jboss Seam e o Jboss Application Server, agora no eclipse clique em File > New > Other... , la procure por Seam Web Project.

Agora vamos ao que interessa, confugurar nosso projeto, em Project name coloque o nome do projeto, no meu caso vou usar o nome projeto, em Target runtime clique em New Runtime... , selecione o Jboss v5.0 e aperte em Next em Application Server Directory clique em Browser... e selecione o path da pasta do Jboss 5.1 Application Server, no meu caso H:/jboss-5.1.0.GA, após isso basta clicar em Finish.
Dynamic Web module version deixe 2.5
Target Server clique em new, escolha Jboss AS 5.1, next, Home directory coloque o path da pasta do Jboss 5.1 Application Server, no meu caso H:/jboss-5.1.0.GA, next, next, finish.

Deve ficar assim

de next, next, next, agora vamos configurar o Seam Facet, em Seam Runtime va em add..., browser e selecione o path da pasta do Seam, no meu caso H:\jboss-seam-2.2.2.Final, clique em finish.
Deploy as: marque EAR.
Database Type: PostgreSQL
Connection profile: New..., PostgreSQL, selecione o path onde foi salvo o postgres JDBC, coloque o username e o password no meu caso postgres / root, save password, Test connection para ver se esta conectando no banco normalmente, next, finish.
Pronto agora basta clicar em finish e esperar o projeto ser criado.
Deve ficar assim.

Serão criadas 4 pastas.

Vamos testar nosso projeto, inicie o jboss (hotkey ctrl + alt + r), com o servidor inicializado abra o browser e entre em http://localhost:8080/projeto/
Voce devera ver isso.

Agora vamos criar nosso Hello World

Clique em projeto > WebContent, botão direito new > Other... > xhtml page > coloque o nome de helloworld > finish


<html>
<head></head>
<body>
Hello world
</body>
</html>

Agora acesse http://localhost:8080/projeto/helloworld.seam
Pronto seu projeto Seam esta montado e seu Hello World criado.

Renderizar campos de acordo com o h:SelectOneRadio selecionado

Nesse post vou mostrar como você pode renderizar novos campos na tela de acordo com o botão Radio selecionado utilizando JSF e Seam.

Vamos criar o caso de um cliente que esta cancelando a assinatura de um serviço, e no formulário de cancelamento existe um radio com alguns motivos de cancelamento como preço, perdeu o interesse, conteúdo fraco, outro. Porem ao clicar em outro deve ser renderizado na tela um campo para ele inserir a justificativa, bem, vamos la.

Primeiro vamos criar um Enum para a justificativa.

public enum JustificativaEnum {
   PRECO, PERDEU_INTERESSE, CONTEUDO_FRACO, OUTRO;
}

Agora na nossa view é onde a magia acontece.


<a4j:region id="motivoRadio">
   <h:selectOneRadio id="cancelamento" value="#{cancelamento.motivoCancelamento}" required="true">
<s:convertEnum />
        <s:enumItem enumValue="PRECO" label="Sem preenchimento" />

        <s:enumItem enumValue="PERDEU_INTERESSE" label="Sem preenchimento" />

        <s:enumItem enumValue="OUTRO" label="Outro" />

<a4j:support event="onclick" reRender="jutificativaField" />

   </h:selectOneRadio>
</a4j:region>



<a4j:outputPanel id="jutificativaField">
<s:decorate rendered="#{cancelamento.motivoCancelamento == 'OUTRO' id="justificativa" template="/layout/edit.xhtml">

<ui:define name="label"> Justificativa </ui:define>
        <h:inputText id="justificativa" value="#{avisoTolerancia.ocorrenciaString}" />
</s:decorate>
</a4j:outputPanel>


Pronto, toda vez que for clicado em um radio é feito o reRender do <a4j:outputPanel> quando for clicado em  OUTRO a área para inserir a justificativa sera renderizada.

rich:pickList + Seam

Vou demostrar nesse post como utilizar de uma maneira muito simples o rich:pickList com o seam, vou fazer um exemplo de @OneToMany, digamos que um Aluno tem muitas Matérias, o primeiro passo é criar a entity Aluno.

@Entity
@Name("aluno")
public class Aluno implements Serializable {

   private static final long serialVersionUID = 1L;
 
   @Id
   private Integer idAluno;

   @Column(name = "nome")
private String nome;
 
  @OneToMany(fetch = FetchType.LAZY)
private List<Materia> materias = new ArrayList<Materia>();

       //getters and setters
}

@Entity
@Name("materia")
public class Materia implements Serializable {

   private static final long serialVersionUID = 1L;

   @Id
   private Integer id;

   @Column(name = "nome")
   private String nome;

}

Agora vamos popular o lado esquerdo do pickList, nesse caso vamos popular fazendo um Select de todos os Alunos do banco de dados

@Name("materialManagedBean")
@Scope(ScopeType.CONVERSATION)
public class MateriasManagedBean{
 
   private List<Material> origem = new ArrayList<Material>();

   @SuppressWarnings("unchecked")

   public List<Material> listarOrigem() {

origem = entityManager.createQuery("select m from Material m").getResultList();

return origem;

   }

}

Pronto agora temos uma lista de Alunos com todos os alunos do banco de dados, agora vou mostrar como utilizar no pickList para poder transferir de uma List para outra.

<rich:pickList value="#{aluno.materias}"

   <s:selectItems value="#{materialManagedBean.listarOrigem()}" var="_materias"
      label="#{_materias.nome}" />

<s:convertEntity />

</rich:pickList>

O que torna o trabalho mais fácil utilizar pickList no Seam é a presença da taglib do seam <s:selectItems> que já faz a conversão automática sem a necessidade de nenhuma programação extra no backbean o que aconteceria utilizando o convencional <f:selectItems>

Aumentando a produtividade de um framework de produtividade com Jrebel

Recentemente postei sobre o jboss Seam e sobre ele ser um framework de produtividade, porem uma coisa que o torna improdutivo é o fato de que toda vez que é feito qual quer mudança no código é necessário fazer o redeploy da aplicação, o que acaba tomando muito tempo no desenvolvimento.


Para resolver esse problema a empresa ZeroTurnaround desenvolveu o JRebel, que atualmente se encontra na versão 4, com ele é possível fazer alteração no código, salvar e dar refresh na pagina que as alterações são publicadas automaticamente, acabando com os inúmeros redeploys, aumentando a produtividade.


Recentemente tanto a empresa ZeroTurnaround e o JRebel foram indicados para a JAX Innovation Awards 2011 nas categorias companhia mais inovadora de java e tecnologia mais inovadora de java  respectivamente.


Na sua nova versão o jrebel oferece full suporte ao Seam e mais 35 frameworks, entre eles: Hibernate, EJB, Sping, Struts, groovy e outros.


Uma outra grande facilidade é que ele pode ser facilmente instalado e utilizado tanto em projetos em andamento inicial como em estagio avançado facilmente.


Para instalar o JRebel no Eclipse e utilizar em uma aplicação Seam é muito simples.


Faça download no site http://www.zeroturnaround.com/jrebel/current/
Para instalar bastar dar next, next, finish.

Agora instale o plugin do eclipse, va em help > Install new software e use a URL http://www.zeroturnaround.com/jrebel/current/

Após o download terminar reinicie o eclipse, para utilizar com o debug vá ate Java > Debug > Step Filtering, la adicione esses 2 filtros com.zeroturnaround.* e org.zeroturnaround.*

Agora vamos inserir o rebel.xml que indica quais pastas serão monitoradas se a mudanças, no Seam devemos colocalo em 2 lugares, um para monitorar as paginas JSF e outro para monitorar o EJB, clique em cima do projeto com o botao direito em cima do projeto e va em Generate rebel.xml e coloque na pasta WebContent\WEB-INF\classes para monitorar o JSF e clique com o botão direito na pasta Projeto-ejb, depois Generate rebel.xml e coloque na pasta \Projeto-ejb\ejbModule

Na configuração do server, basta dar duplo clique em cima do server e deixar as configurações como da foto a seguir

Pronto o JRebel esta instalado e pronto para ser usado, agora qualquer alteração feita no seu código, basta salvar e dar refresh na pagina web que ela será mostrada automaticamente.

Validado campo único com hibernate + Seam.

É possível validar que um campo seja único com o hibernate de uma maneira muito simples criando uma anotação hibernate, e a melhor parte é que depois de criado é possível utilizar de uma maneira muito simples para validar qualquer campo.

Vou mostrar como fazer isso utilizando o Hibernate + Seam.

Temos a nossa Entity com os seguintes campos.

@Entity
public class Cliente{

   private String nome;
   private Integer idade;

   //getters e setters
}

Queremos que o nosso campo Nome seja unico, não havendo 2 registros com o mesmo nome.
Para isso vamos criar uma anotação chamada @Unique.

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@ValidatorClass(UniqueImpl.class)
public @interface Unique {

   String message() default "Campo já existe";

   String classe();

   String campo();

}

Com a nossa annotation criada vamos criar nossa validação da anotação.

@Name("UniqueValidator")
public class UniqueImpl implements Validator<Unique>, PropertyConstraint {

   private String classe;
   private String campo;

   public void initialize(Unique arg) {
      targetEntity = ((Unique)arg).entityName();
      field = ((Unique)arg).fieldName();
   }

   public boolean isValid(Object obj) {
      EntityManager entityManager = (EntityManager) Component.getInstance("entityManager");
      Query query = entityManager.createQuery("select t from " + targetEntit + " t where t." + field + "  = :value");
      query.setParameter("value", obj);

   try {
      query.getResultList();
      return false;
   } catch (final NoResultException e) {
      return true;
   }
   }

   public void apply(Property arg0) {

   }
}

Vamos entender o que acontece na classe de validação da anotação.
É extendido as interfaces Validator<Unique>, PropertyConstraint e implementado os seus metodos.
No metodo initialize são passado os 2 parâmetros que devem ser passados para a anotação funcionar.
No metodo isValid é feito uma query com os 2 parâmetros que serão passados pela annotations (classe e campo)

A annotation esta criada, agora basta implementa-la na nossa entity.

@Unique(classe="org.domain.teste.entity.Cliente", campo="nome", message="Nome já existe")
public String getNome() {
   return nome;
}

E na nossa view

Nome

   
   inputWidth="200px;" id="nome" value="#{cliente.nome}"
  required="true" />
   
   

Pronto a annotations esta pronta e funcionando, e pode ser usada para validar a unicidade de qualquer campo.

Classificando com comparator

Assim como o comparable o comparator é outro modo de classificar uma coleção de uma série de modos diferentes, ao contrario da comparaple é possível classificar até mesmo classes que você não consegue modificar.

Um pequeno exemplo de como implementar o comparator classificando por nome.

public class Cliente{
   private String nome;
   private int idade;

   //Getters e Setters
}

public class NomeSort implements Comparator<Cliente>{
   public String compare(Cliente one, Cliente two){
      return one.getNome().compareTo(two.getNome());
   }
}


public class Teste {

public static void main(String[] args) {
List<Cliente> clientes = new ArrayList<Cliente>();

Cliente c1 = new Cliente();
c1.setNome("Xuxa");
clientes.add(c1);

Cliente c2 = new Cliente();
c2.setNome("Cristiano");
clientes.add(c2);

System.out.println("--- Antes de classificar ---");
for(Cliente c : clientes){
System.out.println(c.getNome());
}

NomeSort ns = new NomeSort();
Collections.sort(clientes, ns);
System.out.println("--- Depois de classificar ---");
for(Cliente c : clientes){
System.out.println(c.getNome());
}
}
}

Ambas interfaces são semelhantes, porem existe algumas diferenças entre elas.

Pacote
Comparable: java.lang.Comparable
Comparator: java.util.Comparator


Implementação
Comparable: int objOne.compareTo(objTwo)
Comparator: int compare(objOne, objTwo)

Retorna
Comparable: negativo se objOne < objTwo, zero se objOne == objTwo, positivo se objOne > objTwo
Comparator: mesmo que comparable

Implementação de classes
Comparable: Você precisa modificar qual a classe cujas instância deseja classificar.
Comparator: Você cria uma classe separada daquela cjas instancias deseja classificar.


Quantidade de seqüencias
Comparable: Só pode ser criada uma seqüencia de classificação.
Comparator: Podem ser criadas varias seqüencias de classificação.

Classificando Lista com Comparable

Nesse post mostrarei como classificar uma Collection (organizar em ordem alfabetica, etc).

Vamos começar com algo facíl, organizar uma lista de Strings, para isso a classe java.util.Collections nos fornece o método sort();



public class Teste {
public static void main(String[] args) {
List<String> nomes = new ArrayList<String>();
nomes.add("Zeca");
nomes.add("Cristiano");
nomes.add("Adriana");
nomes.add("Joao");
System.out.println("Não classificado: " + nomes);
Collections.sort(nomes);
System.out.println("Classificado: " + nomes);
}
}

Iremos ter como retorno

Não classificado: [Zeca, Cristiano, Adriana, Joao]

Classificado: [Adriana, Cristiano, Joao, Zeca]

Agora vamos começar a complicar um pouco.

Queremos classificar uma lista de Objectos de Clientes, pelo nome por exemple.

public class Cliente {

private String nome;

private Integer idade;

       //Getters e Setters

}

Se fizermos como fizemos com String teremos erro de compilação

public class Teste {

public static void main(String[] args) {

List<Cliente> clientes = new ArrayList<Cliente>();

Cliente c1 = new Cliente();

c1.setNome("Zeca");

c1.setIdade(24);

clientes.add(c1);

Cliente c2 = new Cliente();

c2.setNome("Cristiano");

c2.setIdade(22);

clientes.add(c2);

Cliente c3 = new Cliente();

c3.setNome("Joao");

c3.setIdade(43);

clientes.add(c3);

                Collections.sort(clientes);        //ERRO DE COMPILAÇÃO

}

Porque isso acontece?

Se você ler o método sort(), você vai ver que a Collection (no nosso caso o Cliente) deve implementar a interface comparable, a String implementa o comparable por isso conseguimos utilizar o sort() com ele, então é simples se você quer utilizar o sort() com o Cliente basta implementar o comparable na classe Cliente, vou mostrar como fazer isso.

public class Cliente implements Comparable<Cliente>{

private String nome;

private Integer idade;

        //Getters e Setters

       @Override

public int compareTo(Cliente o) {

return nome.compareTo(o.getNome());

}

}

Ao implementar o comparable devemos implementar na classe o método compareTo(), com isso estamos classificando nossa lista por nome (poderíamos fazer também com idade sem problemas). Agora podemos utilizar o Collections.sort(clientes) sem problemas que não teremos nenhum erro de compilação. Vou mostrar como fazer e como fica e ainda como fazer em ordem decrescente, basta utilizar o Cllections.reverse(clientes).

public class Teste {

public static void main(String[] args) {

List<Cliente> clientes = new ArrayList<Cliente>();

Cliente c1 = new Cliente();

c1.setNome("Zeca");

c1.setIdade(24);

clientes.add(c1);

Cliente c2 = new Cliente();

c2.setNome("Cristiano");

c2.setIdade(22);

clientes.add(c2);

Cliente c3 = new Cliente();

c3.setNome("Joao");

c3.setIdade(43);

clientes.add(c3);

System.out.println("---------\nNão Ordernado\n---------");

for (Cliente c : clientes) {

System.out.println("Nome: " + c.getNome());

System.out.println("Idade: " + c.getIdade());

}

System.out.println("---------\nOrdernado\n---------");

Collections.sort(clientes);

for (Cliente c : clientes) {

System.out.println("Nome: " + c.getNome());

System.out.println("Idade: " + c.getIdade());

}

                System.out.println("---------\nOrdernado Decrescente\n---------");

Collections.sort(clientes);

Collections.reverse(clientes);

for (Cliente c : clientes) {

System.out.println("Nome: " + c.getNome());

System.out.println("Idade: " + c.getIdade());

}

}

}

Teremos como resultado.

---------

Não Ordernado

---------

Nome: Zeca

Idade: 24

Nome: Cristiano

Idade: 22

Nome: Joao

Idade: 43

---------

Ordernado

---------

Nome: Cristiano

Idade: 22

Nome: Joao

Idade: 43

Nome: Zeca

Idade: 24

---------

Ordernado Decrescente

---------

Nome: Zeca

Idade: 24

Nome: Joao

Idade: 43

Nome: Cristiano

Idade: 22

No próximo post irei mostrar o Comparator e as diferenças entre Comparator e Comparable

Trabalhando com List e banco de dados

Nesse post irei demonstrar como trabalhar com List, mais especificamente ArrayList.
Para começar vou demonstrar como fazer um Select em uma tabela no banco de dados e armazenar em uma ArrayList.

Para começar vamos criar nossa classe para conecção com o banco de dados, estarei utilizando o mysql

public class ConnectionFactory {
 public static Connection getConnection(){
  Connection cnn = null;
   try{
    Class.forName("com.mysql.jdbc.Driver").newInstance();
    cnn = DriverManager.getConnection("jdbc:mysql://localhost/crud", "root", "root");
   } catch (Exception e) {
    e.printStackTrace();
   }
  return cnn;
 }
}

Temos a seguinte tabela no banco de dados, Cliente com os campo Nome e Idade, vamos implementa-la no java.

public class Cliente {
 
   private String nome;
   private Integer idade;

   //Getters e Setters

}

Insira alguns dados no banco de dados

Insert into Cliente values ('Cristiano', 22);

Insert into Cliente values ('Fabio', 15);

Insert into Cliente values ('Joao', 135);

Insert into Cliente values ('Pedro', 11);

Insert into Cliente values ('Maria', 53);

Agora vamos criar nossa classe que ira fazer o select e armazenar na ArrayList

public class ClienteCrud {
 
 public List<cliente> clientes = new ArrayList<cliente>();

 public void listar(){
  ResultSet rs = null;
  Connection cnn = ConnectionFactory.getConnection();
  try {
   PreparedStatement sql = cnn.prepareStatement("select * from cliente");
   rs = sql.executeQuery();
   while(rs.next()){
    Cliente cliente = new Cliente();
    cliente.setNome(rs.getString("nome"));
    cliente.setIdade(rs.getInt("idade"));
    clientes.add(cliente);
   }
  } catch (SQLException e) {
   e.printStackTrace();
  }
 }
}

Vamos entender o que acontece na classe ClienteCrud, é criar uma ArrayList de Cliente, isso significa que só é possível inserir objetos do tipo Cliente nessa lista.
No metodo Listar é criado um ResultSet para armazenar o resultado do select, é feito a connecção com o banco de dados, após isso fazemos o select, executamos a query  guardamos o resultado no ResultSet, agora vamos a parte em que armazenamos o resultado(s) no arrayList.
Fazemos um while(rs.next()) que significa que enquanto existir um próximo resultado ele vai continuar fazendo o loop, agora a parte que nos interessa, é criado um novo objeto Cliente setado o nome e a idade com o resultado do select e adicionado o Objeto Cliente a lista.

Agora vamos finalmente mostrar esse resultado na tela

public class ClienteView {

 public static void main(String[] args) {
  ClienteCrud cc = new ClienteCrud();
  cc.listar();
  System.out.println("--------\nSem Classificação \n--------");
  for (Cliente c : cc.clientes) {
   System.out.println(c.getNome());
   System.out.println(c.getIdade());
  }
 }
}

Iremos obter


--------
Sem Classificação
--------
Nome: Cristiano
Idade: 22
Nome: Fabio
Idade: 15
Nome: Joao
Idade: 135
Nome: Pedro
Idade: 11
Nome: Maria
Idade: 53

No proximo post irei demostrar como fazer a classificação dessa lista com Comparator e Comparable.