Antes de qualquer coisa temos de baixar o driver e para isso basta baixá-lo da área de drivers do site do MongoDB e adicioná-lo ao seu classpath.

Conectar ao MongoDB é bastante simples, basta instanciar a classe Mongo e depois selecionar o banco.

Mongo m = new Mongo();
// ou
Mongo m = new Mongo( "localhost" );
// ou
Mongo m = new Mongo( "localhost" , 27017 );

DB db = m.getDB( "meu_banco" );

Acredito que a parte mais complicada é transformar um documento no estilo JSON em um objeto BasicDBObject que a maioria dos métodos da API recebe. Vamos fazer um exemplo:

{
	nome : "Rodrigo",
	sobrenome : "Aramburu",
	telefone : "1234-5678",
	endereco : {
				rua : "Rua Fulano",
				numero : "221B",
				bairro : "Centro"
			}
}

Convertendo este objeto JSON para objeto Java ficaria assim:

BasicDBObject pessoa = new BasicDBObject();
pessoa.put("nome", "Rodrigo");
pessoa.put("sobrenome", "Aramburu");
pessoa.put("telefone", "1234-5678");

BasicDBObject end = new BasicDBObject();
end.put("rua", "Rua Fulano");
end.put("numero","221B");
end.put("bairro", "Centro");

pessoa.put("endereco", end);

Na linha 1 criamos um objeto BasicDBObject, na linhas 2 , 3 e 4 adicionamos os campos nome, sobrenome e telefone e seus valores. O campo endereco é um campo que o valor é um objeto incorporado então antes de adicionarmos ele devemos criar este objeto(linha 6) e incluir seus campos(linhas 7, 8 e 9). Com o objeto endereco podemos inserir no campo endereco do objeto pessoa.

Se você se perguntou e se tivesse vários telefones? Simples!

String[] tels = { "1234-5678","9898-9898" };
pessoa.put("telefone", tels);

Com o Objeto criado, inserir no MongoDB é muito simples :

DBCollection colecaoPessoas = db.getCollection("pessoas");
colecaoPessoas.insert(pessoa);

Bom depois de inserir sempre é bom buscar então vamos lá:

DBCursor cursor = coll.find();
while( cursor.hasNext() ){
        BasicDBObject pessoa = (BasicDBObject) cursor.next();
        System.out.println( "Nome: "+pessoa.getString("nome") );
        System.out.println("Sobrenome: "+pessoa.getString("sobrenome") );
        System.out.println("Telefone: "+pessoa.getString("telefone") );

        BasicDBObject end = (BasicDBObject) pessoa.get("endereco");
        System.out.println( "Rua: "+end.getString("rua") );
        System.out.println( "Numero: "+end.getString("numero") );
        System.out.println( "Bairro: "+end.getString("bairro") );
        System.out.println( "======================================" );

}

Para fazer uma consulta se utiliza o método find que retorna um DBCursor que permite iterar sobre o resultado, os métodos mais importantes são hasNext() que retorna true se tiver o próximo documento e falso se não tiver mais. E o método next() que retorna o próximo DBObjetc do qual utilizamos o método getString(“nome_campo”) ou getInteger(“nome_campo”) , getBoolean(“nome_campo”), getDouble(“nome_campo”) para pegar os dados.

E como colocamos alguns critério de busca?

BasicDBObject query = new BasicDBObject();
query.put("telefone","9898-9898");

DBCursor cursor = coll.find(query);

Para filtrar basta passar por parâmetro um objeto BasicDBObject para o método find() e podemos utilizar todos os tipos de filtros, “$in”, “$lte”, “$gt”, “$or”, “$regex”, etc…

BasicDBObject query = new BasicDBObject();

query.put("idade", new BasicDBObject().append("$gt", 18));

DBCursor cursor = coll.find(query);

O interessante no filtro $in é que podemos utilizar uma coleção:

BasicDBObject query = new BasicDBObject();
List<Integer> list = new ArrayList<Integer>();
list.add(9);
list.add(10);
query.put("idade", new BasicDBObject().append("$in", list));

Bom agora vamos deletar

BasicDBObject obj = new BasicDBObject();
obj.put("_id", new ObjectId( "4e827ca3d6340373c65e4e99" )  );
colecaoPessoas.remove(obj);

Normalmente eu prefiro deletar pelo _id e o valor deste campo é um objeto do tipo ObjectId(“id”), criar um objeto BasicDBObject para depois passá-lo de parâmetro para o método remove().

Só falta atualizar

BasicDBObject ant = new BasicDBObject();
ant.put("_id", new ObjectId( "4e8279f7d63465f846d5cea9" )  );
BasicDBObject novo =  new BasicDBObject();
novo.put("$set",  new BasicDBObject().append("idade", 16));

colecaoPessoas.update(ant, novo);

Bom era isso, até mais e obrigado pelos peixes!!!

Foi utilizada a linguagem Java já que é a que utilizamos no componente de Desenvolvimento.

O Problema foi o clássico janken-pon(Pedra Papel e tesoura) ou como chamamos “JokenPO” (pura preguiça de buscar o nome certo).

Vamos então para a retrospectiva;

PRÓS

trabalho em equipe
todo mundo participou
aula sem piadas idiotas(quase)

CONTRAS

o projetor
a mancha do projetor

Para complementar segue o código produzido

public class TesteJokenPO {

        JokenPO joken = new JokenPO();

     @Test
     public void quandoPedraPapel() {
         String retorno = joken.vencedor("pedra", "papel");
         assertEquals("papel", retorno);
     }

     @Test
     public void quandoPedraTesoura() {
         String retorno = joken.vencedor("pedra", "tesoura");
         assertEquals("pedra", retorno);
     }

     @Test
     public void quandoPapelTesoura() {
         String retorno = joken.vencedor("papel", "tesoura");
         assertEquals("tesoura", retorno);
     } 

     @Test
     public void quandoTesouraPedra(){
         String retorno = joken.vencedor("tesoura", "pedra");
         assertEquals("pedra", retorno);
     }

     @Test
     public void quandoTesouraPapel() {
         String retorno = joken.vencedor("tesoura", "papel");
         assertEquals("tesoura", retorno);
     }
     @Test
     public void quandoPapelPedra() {
         String retorno = joken.vencedor("papel", "pedra");
         assertEquals("papel", retorno);
     }
}

public class JokenPO {

    public String vencedor(String j1,String j2){

        if (((j1 == "pedra")&&(j2 == "papel"))||
            ((j1 == "papel")&&(j2 == "pedra" )))
               return "papel";  

        if(((j1 == "tesoura")&&(j2 == "pedra"))||
           ((j1 == "pedra") && (j2=="tesoura")) )
               return "pedra";  

        if(((j1 == "tesoura")&&( j2== "papel"))||
           ((j1 == "papel")&&( j2== "tesoura")))
              return "tesoura";        

              return "";

    }
}

Bom pessoal espero que esse o primeiro de muitos. Andei vendo que um pessoal esta fazendo Dojo Online quem sabe dá para fazer algo assim.

Java o Filme!!! from charlesmessias on Vimeo.

Eu sei que é meio antigo mas só hoje que fui achar um com legenda

Como você pode ver no titulo deste post vamos utilizar expressões regulares para validar nossos dados, mas que diabos é uma expressão regular? Simplificando uma expressão regular é uma série de caracteres capaz de descrever outras séries de caracteres. Complicado? Um pouco no inicio talvez, mas vamos com calma analisando um exemplo simples, um telefone por exemplo

3412-1234

Como podemos ver este dado é composto somente de caracteres numéricos e é formatado com quatro caracteres numéricos, um caractere “-” e mais quatro caracteres numéricos. Vejamos como ficaria a expressão regular que expressaria essa regra:

\d{4,4}-\d{4,4}

Esta expressão poderia descrever diversos telefones que seguirem esta regra de formatação, por exemplo os telefones abaixo:

3414-4974
9698-1101
3412-1234

e não encontraria os seguintes.

12902398
13244-54452
asdf-hjkl

Então vamos destrinchar a expressão

\d: É um meta caractere do tipo representante, que no caso representa um caractere numérico, ou seja de 0-9
{4,4}: É um quantificador ele representa quantas vezes o caractere anterior pode ser repetido, no caso no minimo quatro e no máximo quatro.
- : o caractere “-” mesmo!

Meta caractere, quantificador?

Calma não criemos pânico! Um representante é um caractere que representa uma série de outros caracteres.

Meta caracteres

\d: Um dígito
\s: Um caractere de espaço em branco
\w: Um caractere de palavra(letras, dígitos ou “_”)
. : Qualquer caractere

Um aviso importante é que para utilizá-los em uma aplicação dentro de uma String devemos escapar as barras com mais uma barra. Então para validar um número inteiro devemos utilizar a seguinte expressão:

"\\d"

Se nos interessar pesquisar por um grupo limitado de caracteres podemos especificar uma lista através de colchetes. Por exemplo a lista [abc] irá somente encontrar os caracteres “a”, “b” ou “c”

“[bcf]aixa” irá encontrar as seguintes palavras “baixa”, “caixa” e “faixa”

“Texto[1234]” irá encontrar as seguintes palavras “Texto1”, “Texto2”, “Texto3”

Também podemos especificar um intervalo de valores utilizando um hífen dentro do colchete.

“[a-z]teste” irá encontrar as seguintes palavras “ateste”, “dteste”, ”oteste”, “pteste”

Bom até agora vimos como encontrar um caractere, mas se quisermos que este caractere pudesse ser repetido inúmeras vezes? Utilizaríamos um quantificador, que é um caractere que informa quantas vezes um meta caractere pode/deve ser repetido.

Quanificadores

?: Pode se repetir 0 ou 1 vez
*: Pode se repetir uma ou várias vezes
+: Pode se repetir uma ou várias vezes
{n,m}: Pode se repetir de n até m vezes

Agora podemos criar algumas expressões um pouco mais rebuscadas, como uma para validar placas de carros:

“[a-zA-Z]{3,3}-\\d{4,4}”

Vamos analisar a expressão, temos entre colchetes duas listas que informam que só será aceito caractere de “a” até “z” tanto maiúsculo como minusculo que podem ser repetido no minimo 3 vezes e no máximo 3 vezes. Seguido deve possuir um traço e após um caractere numérico que pode se repetir no minimo 4 vezes e no máximo 4 vezes.

Agora vamos ao código Java para validar:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ValidaPlaca {

    public static void main(String args[]){
        Pattern pattern = Pattern.compile("[a-zA-Z]{3,3}-\\d{4,4}");
        Matcher matcher = pattern.matcher("ETE-1234");

        if( matcher.find() ){
            System.out.println("Encontrou");
        }else{
            System.out.println("Não encontrou");
        }
    }
}

Na linha 8 criamos um objeto Pattern que é responsável por armazenar uma expressão regular que será utilizado pelo objeto Matcher que é responsável pelas buscar.

O método find()(linha 11) retorna true se encontrar o padrão de caracteres especificado pelas expressões regulares na String passada na linha 12.

O objeto Matcher pode buscar várias ocorrências do padrão em sua String possuindo métodos para retornar estas ocorrências e e suas posições. Veja o exemplo abaixo:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ValidaPlaca {

    public static void main(String args[]){
        Pattern pattern = Pattern.compile("[a-zA-Z]{3,3}-\\d{4,4}");
        Matcher matcher = pattern.matcher("ETE-1234 ZXC-4567 cdr-0987");

        boolean b = false;
        while( b = matcher.find() ){
            if( b ){
                System.out.println( matcher.group()+" - Posição: "+matcher.start() );
            }else{
                System.out.println("Não encontrou");
            }
        }
    }
}

Você pode fazer mais uns teste com outras expressões como:

CEP

"^\\d{5,5}-?\\d{3,3}$"

E-mail(não está 100% mas dá para ter uma idéia)

"^[a-zA-Z0-9_\\.-]+@([a-zA-Z0-9]\\.)*([a-zA-Z0-9])*\\."

Uma ótima referência para aprender mais é através do Expressões Regulares – Guia de Consulta Rápida por Aurélio Marinho Jargas

Date(java.util.Date)

A classe Date armazena uma data e hora, que internamente é armazenada com um inteiro long que é o numero de milissegundos que se passou desde 01/01/1970.

Esta classe é bem simples de se trabalhar, mas muitos de seus métodos foram depreciados por não trabalhar muito bem com internacionalização e etc.

Para obter a data atual se basta criar um objeto Date sem nenhum parâmetro.

Date d = new Date();

Calendar(java.util.Calendar)

A classe Calendar sendo uma classe abstrata não pode ser instanciada com o operador new, ela deve ser criada utilizando um operador estático sobrecarregado getInstance(). Na maioria das vezes você vai receber uma instância de Java.util.GregorianCalendar.

Calendar c = Calendar.getIntance();

Com a instância de Calendar devemos configurar uma data e podemos fazer isso de duas formas:

Métodos set

c.set(ano,mes,dia);
c.set(ano,mês,dia,hora,minuto);
c.set(ano,mês,dia,hora,minuto,segundo);

Método setTime

c.setTime(new Date() );

A classe Calendar também nos fornece várias constantes que utilizaremos para manipular uma data entre elas.

Com a data devidamente configurada podemos realizar diversas operações com a data:

Para adicionar ou subtrair um dia, hora, mês ou ano utilizamos o método add. O método add aceita dois parâmetros, sendo o primeiro um constante inteira que representa a unidade da data que queremos modificar(dia, mês , ano, etc…) e o segundo quantas vezes será adicionada/subtraída esta unidade.

A unidade é informada utilizando constantes fornecidas pela classe Calendar que pode ser:

Dia:

Calendar.DAY_OF_MONTH
Calendar.DAY_OF_WEEK
Calendar.DAY_OF_YEAR

Mês:

Calendar.MONTH

Ano:

Calendar.YEAR

Hora:

Calendar.HOUR
Calendar.HOUR_OF_DAY

Segundos:

Calendar.SECOND

Veja o exemplo abaixo:

Date d= new Date();
Calendar c = Calendar.getInstance();
c.add(Calendar.DAY_OF_YEAR,5 );//adicionamos 5 dias a data aual
c.add(Calendar.MONTH,3 );//adicionamos 3 mêses a data atual
c.add(Calendar.YEAR,1 );//adicionamos 1 ano a data atual

DateFormat(java.text.DateFormat)

Bom agora sabemos como manipula datas, agora precisamos formatar a data para apresentação. A classe DateFormat nos fornece uma maneira simples de formatá-la e permite a internacionalização a partir da classe Locale.

        Date d = new Date();
        Calendar c = Calendar.getInstance();
        c.setTime(d);

        DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
        System.out.println( df.format(c.getTime()) );

Para obtermos uma String da data utilizamos o método format que retorna uma String no formato especificado no método getDateInstance(). A saída do exemplo acima será algo como 03/04/10.

A classe DateForma nos fornece vários tipos de formato para data como:

Dateformat.SHORT // 03/04/10
Dateformat.MEDIUM // 03/04/2010
Dateformat.LONG //3 de Abril de 2010
Dateformat.FULL //Sábado, 3 de Abril de 2010

Embora para muitos casos estes formatos serão suficientes algumas vezes necessitamos de uma formato vem personalizado. Isso pode ser feio através de um subclasse de DateFormat a SimpleDateFormat.

        Date hoje  = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
        System.out.println( sdf.format(hoje));

O construtor de SimpleDateFormat recebe uma String que representa o formato da data. Os símbolos utilizados para cada campo da data pode ser visto na tabela abaixo abaixo:

Como vimos o dia da semana pode ser escrito por extenso, que língua ele será utilizada? Normalmente o inglês, mas se quisermos que seja na língua de um local diferente?

Para isso utilizaremos a internacionalização com a classe Locate que recebe em seu construtor a língua e o país que queremos utilizar:

Locale brasil = new Locale("pt","br");//portugues do brasil
Locale japao = new Locale("ja");// japao

O objeto locale de Locale pode ser utilizado tanto com a classe DateFormat quanto com a classe SimpleDateFormat.

Date hoje  = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("E dd ",new Locale("pt","br"));
System.out.println( sdf.format(hoje));

DateFormat df = DateFormat.getDateInstance(DateFormat.FULL,new Locale("pt","br"));
System.out.println( df.format(hoje));

Para finalizar como covertermos uma String em um objeto Date

        Date d  = new Date();
        SimpleDateFormat df = new SimpleDateFormat("DD/MM/yyyy");
        try {
            d = df.parse("25/03/2010");
        } catch (ParseException ex) {
            ex.printStackTrace();

        }
        System.out.println( df.format(d));

O métdo parse da classe DateFormat e recebe uma string e convertepara um objeto Date

O HSQLDB é um SGDB de código aberto, escrito totalmente e Java o que torna-o portável. Em termos de desempenho, segurança e recursos não podemos compará-lo a outro bancos de dados como Oracle, Postgres e Microsoft SQL, mas para aplicações pequenas em desktop pode ser uma excelente pedida.

Uma das vantagens do HSQLDB é sua simplicidade, a capacidade de poder ser rodado em modo cliente-servidor ou standalone, armazenando os dados em memória, arquivo de texto ou banco de dados.

Veremos agora então como executar, criar um banco de dados e acessá-lo:

Primeiramente baixamos o HSQLDB depois basta descompactá-lo. Depois de descompactado teremos desde o código fonte até alguns scripts, mas que nos interessa é o arquivo hsqldb.jar que é o pacote do HSQLDB que possui desde o driver JDBC até ferramentas para o gerenciamento do banco de dados.

Antes de começarmos a trabalhos com o HSQLDB devemos adicioná-lo ao CLASSPATH:

CLASSPATH = %CLASSPATH%;C:/hsqldb/lib/hsqldb.jar

A interface de gerenciamento em Swing pode ser aberta pelo comando:

java org.hsqldb.util.DatabaseManagerSwing

Ok, agora vamos conectar/criar um banco standalone para ser armazenado na pasta “c:\banco” com o nome do banco “dbteste”

Parâmetros para a conexão

Agora vamos criar nossa tabela:

CREATE TABLE  usuarios(
        id IDENTITY PRIMARY KEY,
        nome VARCHAR(50),
        email VARCHAR(50)
);

O HSQLDB aceita os comando básicos de SQL, com algumas pequenas diferenças, por exemplo o tipo de dado inteiro auto-incrementável é IDENTITY e ele começa a contar de 0(atenção). Com a tabela criada vamos inserir alguns dados:

INSERT INTO usuarios(nome,email) VALUES('Boteco Digital','blogbotecodigital@gmail.com');
INSERT INTO usuarios(nome,email) VALUES('Rodrigo','rodrigo@algumacoisa.com');
INSERT INTO usuarios(nome,email) VALUES('Thiago','thiago@algumacoisa.com');
INSERT INTO usuarios(nome,email) VALUES('Joao','joao@algumacoisa.com');

** DETALHE IMPORTANTE **
Antes de fechar o gerenciador lembre-se de executar o seguinte comando:

SHUTDOWN;

Para os dados serem gravados corretamente.

Para conferir se os dados foram inseridos com êxito execute o seguinte comando:

SELECT * from usuarios

Nosso banco está criado e populado agora basta conectá-lo pelo Java:

try{
    Class.forName("org.hsqldb.jdbcDriver");
    Connection con = DriverManager.getConnection("jdbc:hsqldb:file:/banco/dbteste", "sa", "");

    Statement stm= con.createStatement();
    ResultSet rs = stm.executeQuery("SELECT * FROM usuarios");

    while(rs.next()){
        String nome = rs.getString("nome");
        String email = rs.getString("email");

        System.out.println(nome+" - "+email);
    }
    stm.execute("SHUTDOWN");
}catch(ClassNotFoundException e){
    System.out.println("Erro ao carregar o driver JDBC. ");
}catch(SQLException e){
    System.out.println("Erro de SQL: "+e);
    e.printStackTrace();
}

Na linha 2 carregamos o driver JDBC, este driver está no no pacote hsqldb.jar então não esqueça de colocá-lo no seu CLASSPATH.

Na linha criamos uma conexão através da String “jdbc:hsqldb:file:/banco/dbteste”. Esta String contém as seguintes informações de conexão:

• jdbc tipo de driver a ser utilizado para conexão
• hsqldb este é o driver que utilizaremos para conectar. Ele já foi carregado na memória através da instrução “Class.forName(“org.hsqldb.jdbcDriver”);”<;li>
• file informa que o banco está armazenado em arquivo(standalone)
• /banco/dbteste ando nosso banco está armazendo, no caso na em um pasta na raiz de diretório chamada banco, que terá arquivox com o nome de dbteste.( c:\banco)

Na linha 5 criamos um objeto Statment para realizar um consulto, na linha 6 executamos a consulta e recuperamos seu retorno.

Da linha 8 até 13 iteramos pelo resultado da consulta e exibimos os valores na tela. Na linha 14 executamos o comando SHUTDOW.

Como vimos este exemplo cria uma banco de dados standalone para uma aplicação local. O HSQLDB também pode funcionar no modo servidor para isso temos que executá-lo através do seguinte comando.

java org.hsqldb.Server -database.0 dbteste2 -dbname.0 dbteste2

Detalhe importante: ele irá criar o banco de dados dentro da pasta que foi executado o comando acima!

Para conecta-lo pelo Java utilizamos o seguinte código:

Connection con = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/dbteste2", "sa", "");

Bom isso é tudo pessoal!

Mas você deve estar se perguntando para que isso me serve? Bom tecnicamente você pode fazer com iteração tudo o que você pode fazer com recursão, mas para alguns problemas computacionais as soluções recursivas tornam-se mais simples. Em geral quando você pode simplificar um problema, sem deixar de ser o mesmo problema, até que ele se torne menor e de mais fácil resolução é um problema que pode ser resolvido com recursão.

Um exemplo clássico de Recursão é a Seqüência de Fibonacci que é uma seqüência que se obtém somando os dois últimos números da seqüência para chegar ao próximo. Vejamos uma implementação recursiva do problema onde mostramos na tela o 6º elemento da seqüência.

class Fibonacci{

    public static int fiboRecursivo(int n){
        if( n <= 2){
            return 1;
        }else{
            return Fibonacci.fiboRecursivo(n - 1) + Fibonacci.fiboRecursivo(n - 2);
        }
    }

    public static void main(String args[]){
        int i = Fibonacci.fiboRecursivo(6);
        System.out.println(i);
    }

}

O problema da seqüência de Fibonacci pode ser resolvido pela fórmula F(n-1)+F(n-2) sendo que n é posição do elemento dentro da seqüência. Como sabemos o primeiro e o segundo elementos da seqüência são 1 chegamos a seguinte simplificação do problema.

• SE a posição for menor ou igual a 2 retornamos 1
• SENÂO simplificamos o problema, tentamos descobrir os dois elementos anteriores ao elemento que queremos, fazemos isso
  chamando o método fiboRecursivo e somamos suas saídas.

Ok, o código fica simples, mas e ai? Como ele é executado?

Toda chamada de um método é empilhada em um estrutura de pilha (memória Stack) que isola a área de memória de cada método. Quando fazemos uma chamada a um método a seqüência de execução é parada e passa a executar as instruções que o método chamado contem. O método chamado é empilhado na memória Stack(pilha) e após sua execução é retirado da memória Stack e seqüência de execução volta ao método que o chamou e a execução prossegue normalmento. Note que o método que está sendo executado sempre estará no topo da memória Stack.

Quando utilizamos chamadas recursivas estamos colocando métodos na memória Stack, para cada chamada ao método fiboRecursivo() uma “cópia” dele é colocada na memória e só será retirada quando as chamadas do topo da pilha parar de chamar o métodos e retornar algum valor.

Essa “cópia” é totalmente independente das outras, tem seu próprio escopo, variáveis locais e como qualquer método podem manipular atributos.

Um outro exemplo(mais prático) em que podemos utilizar a recursão é para listar os arquivos de um diretório e de seus subdiretórios como no exemplo abaixo.

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;

public class Diretorios {

    private ArrayList<File> arquivos = new ArrayList<File>();

    public void leDiretorio(File dir){
        File[] names = dir.listFiles();
        if( names != null){
            for(int i=0 ; i <names.length;i++){
                if( !names[i].isDirectory() ){
                    this.arquivos.add(names[i]);
                }else{
                    leDiretorio(names[i] );
                }

            }
        }
    }

    public static void main(String args[]){
        Diretorios d = new Diretorios();
        File f= new File("teste");
        d.leDiretorio(f);

        Iterator i = d.arquivos.iterator();
        while(i.hasNext()){
            System.out.println( i.next() );
        }

    }
}

O código do método leDiretorio faz o seguinte, ele recebe por parâmetro um File que deve ser um diretório, após isso ele lê todos os arquivos do diretório com o método listFiles(), após isso ele verifica se foi retornado algum arquivo(File), se sim ele percorre esse array testando se o arquivo não é um diretório ele armazena em um ArrayList se for ele faz chama uma chamada ao próprio método passando por parâmetro esse diretório.

Recursão é uma ferramenta bastante poderosa que pode simplificar muita coisa, embora tenha um custo computacional um pouco mais elevado permite a criação de códigos mais simples e por conseqüência de mais fácil manutenção.

Uma dica é que recursão é uma boa saída para percorrer qualquer estrutura no formato de árvore.

Bom pesquisando, descobri que a API do JAVA não fornece métodos para escrever no console utilizando cores, para isso é preciso inserir códigos de cor que pode variar conforme o S.O. ou mesmo de terminal para terminal.

Isto obviamente não é uma solução portável, então não é condizente com JAVA.

A solução que achei foi utilizar uma biblioteca Enigma Console que nada mais é do que um console feito em JAVA utilizando Swing.

Primeiramente vamos baixar a biblioteca Enigma Console. Descompacte o arquivo em uma pasta de sua escolha e adicione à variável de ambiente CLASSPATH o caminho absoluto para a biblioteca Enigma Console por exemplo:

Variavél de ambiente CLASSPATH

.;c:\enigma\enigma-all_en_US.jar;

Agora basta utiliza-la no código como no exemplo abaixo:

import java.awt.Color;
import enigma.console.*;
import enigma.core.Enigma;

public class Cor{

    public static void main(String[] args){
        Console s_console = Enigma.getConsole();
        TextAttributes attrs;
        attrs = new TextAttributes(new Color(96,223,79), new Color(76,62,175));
        s_console.setTextAttributes(attrs);
        System.out.println("Fundo azul com letras verdes");

        attrs = new TextAttributes(new Color(255,90,90), new Color(234,255,90));
        s_console.setTextAttributes(attrs);
        System.out.println("Fundo amarelo com letras vermelhas");

    }
}

Na linha 1 à 3 importamos os objetos que iremos utilizar tanto o objeto do console como a classe Color para podermos definir as cores.

Na linha 8 é onde chamamos o método que cria um novo console e muda a saída padrão para ele, ou seja a partir de agora tudo que escrevermos na saída padrão( System.out ) será escrito no novo console!

Na linha 10 é onde definimos os atributos do nosso texto, ou seja, a cor de fundo e a cor do texto, o construtor os parâmetros nesta mesma ordem. Note que utilizamos objetos Color para representar as cores, o construtor deste objeto recebe 3 valores inteiros de 0-255 no sistema RGB(Vermelho,Verde,Azul) para representar a cor, se precisar use um editor de imagem para descobrir os valores da cor que você deseja.

Na linha 11 configuramos o console com as configurações feitas na linha 10. A partir de agora todo texto escrito no console terá as cores definidas.

Para mudar as cores novamente basca configurar o console novamente com as novas cores desejadas.

Veja como vai ficar o exemplo acima:

E por hoje é só pessoal!

O passeio do cavalo é um problema matemático envolvendo o movimento da peça do cavalo no tabuleiro de xadrez. Coloca-se o cavalo em uma das posições de um tabuleiro de xadrez vazio e deve-se movimentar o cavalo seguindo as regras do xadrez, ou seja, movimentar o cavalo em “L” para que ele passe por todas as 64 casas do tabuleiro sem repetir nenhuma.

Existem dois tipos de Passeio do Cavalo o passeio aberto, onde o cavalo para em qualquer casa do tabuleiro e o passeio fechado onde o cavalo para em uma casa em que, no próximo movimento, pare na casa onde começou.

Aqui você pode fazer o download do código que eu criei em Java de um passeio aberto, ele segue um heurística de acessibilidade que consta no livro do Deitel que pode ser vista abaixo.

A heurística de acessibilidade consiste em que quanto mais no canto o cavalo está mais difícil é move-lo, então estas casas devem ser passadas primeiro, como vemos na imagem da heurística acima, as casas dos quatro cantos permitem somente dois movimentos, enquanto as casas centrais permitem todos os oito.

Foi isso então, se alguém quiser modificar o código(que não está muito elegante) fique a vontade, só pesso que deixe um comentário com o código ou me envie por e-mail para mim anexar ao post.