Debugando com Java

Em uma apresentação recente discutimos as técnicas de debugging utilizando Java e a IDE do Eclipse. Vejam os slides abaixo:

Básico sobre Debugging com Java from jesuinoPower

É possível também assistir a abertura do encontro do JUG Vale, logo após foi transmitida a palestra sobre debug com Java que usou os slides acima:

Algoritmos com Java: BubbleSort e geração de caso de testes para o URI 1388

Os algoritmos de ordenação mais lentos são bem conhecidos: selection sort, bubble sort entre outros. Nessa postagem vamos compartilhar uma implementação do BubbleSorte e, de quebra, um gerador de caso de testes para o problema 1388 do URI.

Que vergonha ainda não resolvi 100%!

Para quem não conhece, o URI Online Judge é uma plataforma espetacular cheia de algoritmos para encontrar uma solução e enviar para avaliação no servidor deles.

O problema 1388 do URI é de nível 6, um dos mais altos! E ele é sobre fazer uma engenharia reversa no Bubble Sort. Há dois problemas com esse problema (hehe):

1. Os casos de teste são escassos, são só três! Você nunca cobre todos os casos de entrada com 3 casos de teste...
2. A forma mais óbvia de resolver, que é desordenar um vetor fazendo o bubble sorte ao contrário até que ele pegue uma ordem que satisfaça a entrada, é custosa e dá erro de Time Limit Exceed. 

Logo você precisa de uma forma que resolva pegando atalhos, de preferência elegantes, sem gambiarras. Por isso é legal que você teste bem, pois o URI só vai falar que você não cobriu todos os casos de teste, se houve erro de runtime, se excedeu o tempo e por aí vai. Nesse exato momento criei o pequeno código abaixo que está me auxiliando. É java 8 puro. Para compilar: javac GeraCasoTeste1388.java e rodar: java GeraCasoTeste1388

Será que tá gerando caso de teste certos?

Você pode até passar o tamanho do array que você quer ver gerado Só um pequeno adendo. Faça sempre testes de mesa, pois pode haver mais de uma sequência que satisfaz a condição. Leia com atenção o URI que você vai entender!. Enfim,segue o código.

Algoritmos com Java: Busca Binária

Na série "Algoritmos com Java" iremos compartilhar alguns algoritmos que implementamos com Java. Segue abaixo uma implementação de Busca Binária. Notem que há bastante uso de Java 8 na parte que tratamos a entrada do usuário.

Aqui está um exemplo de uso:

Para rodar copiem o código acima em um arquivo chamado BuscaBinaria.java, compilem com Java 8 usando javac e executem usando java passando a lista de números separados por vírgula e o que deve ser buscado separado por um espaço.
Notem que essa é uma possível implementação, há outras formas que não iremos discutir nem comparar. Os tópicos de algoritmos ficarão aqui sempre tentando apimentar um pouco o algoritmo principal com Java 8 e 9, mas a implementação principal ficará sempre em um método separado, assim separamos a API da linguagem do algoritmo.
Em breve teremos mais algoritmos com Java!

Usando CDI em uma aplicação Java SE

CDI é uma API Java que permite que você delegue as relações entre as classes para um container. Dessa forma você não instancia classes manualmente, mas um container o faz trazendo flexibilidade e performance para a sua aplicação. É também conhecido como uma API de costura entre as camadas de uma aplicação.

No blog Aprendendo JavaEE fizemos uma aplicação muito simples com CDI.

Na versão 2.0 é possível usar CDI em uma aplicação que só tem a API padrão do Java, o chamado Java SE. Nessa postagem vamos mostrar como fazemos isso. 

Configuração do projeto

Vamos usar Maven. No diretório src/main/resources criamos mais um chamado META-INF com um arquivo chamado beans.xml. Esse arquivo permite declarar os beans do CDI, mas vamos deixar ele vazio para que simplesmente o CDI reconheça essa aplicação como uma aplicação CDI.

No pom.xml declaramos só uma dependência, veja:

A aplicação de teste

Vamos criar uma interface muito simples que faz uma saudação:

Imagine que poderíamos ter diversas implementações dela fazendo diversos tipo de saudações, mas vamos criar uma classe de implementação muito simples:

Agora vamos usar a mesma interface em uma classe que não vai ter nenhuma referência para a implementação. Quem vai fazer essa ligação é o CDI. Veja a classe App que usa a Greeter:

O último passo é inicializar o container CDI e pegar uma instância de App para que possamos utilizar, veja:

Ao rodar o código podemos ver que o método foi executado com sucesso:

É isso! Mostramos como se usa CDI em uma aplicação padrão do Java. O código está em nosso github. Um outro recurso para aprender é esse vídeo do Adam Bien (em inglês):

Controlando o arduino a partir do Java usando JArduino

Quando queremos integrar Java com Arduino geralmente utilizamos a porta serial como desmonstrado no livro JavaFX 8: Introduction by Example no capítulo sobre Arduino.O problema com essa abordagem é que teremos que programar em duas linguagens e ainda definir a forma de comunicação.

Outra possibilidade é usar JArduino, que possibilita o uso de código Java para diretamente interagir com o Arduino. O que você precisa fazer é seguir o tutorial do README da página do JArduino. Uma vez usando Java podemos utilizar qualquer API já bem conhecida

Problemas

O seguinte erro me tomou alguns minutos:

java.lang.UnsatisfiedLinkError: no rxtxSerial64 in java.library.path thrown while loading gnu.io.RXTXCommDriver

Ele vem por causa da falta da API nativa RxTx. Simplesmente baixe a API para o seu sistema aqui aqui e colocou na lib da sua JDK. No meu caso o diretório que usei foi: /usr/lib/jvm/java-8-openjdk-amd64/jre/lib/amd64

Lendo um sensor de luz (LDR) a partir do Java

 

O "olá mundo" do mundo arduino é fazer um led piscar. Eu queria começar com algo mais interativo, então criei uma aplicação simples que lê uma entrada analógica conectada a um LDR, como descrito nesse tutorial. Coisas para se notar sobre o código

• A classe JArduino imita um código Arduino. Você simplesmente estende a classe JArduino e implementa suas coisas no método loop e configura as portas no método setup;
• Eu estou usando maven e tive que adicionar alguns repositórios no meu pom.xml pois algumas dependências não estão disponíveis na central do Maven;
• A única coisa que precisamos fazer no lado do arduino é subir o código provido pelo JArduino. Lembre-se de usar a porta certa na sua classe;
•  O circuito é o mesmo do tutorial Using an LDR Sensor with Arduino: A Tutorial for Beginners, a diferença aqui é que uso o Garagino:

Aqui está o código:

O resultado é simplesmente a intensidade da luz no console:

Agora em breve no blog Aprendendo JavaFX iremos postar algo visual. Até mais!

Organizar execução de threads no Java com join

Nessa outra postagem rápida nós vamos mostrar como organizar a execução de Threads no java com join.

Para entender o ponto dessa postagem, imagine que várias threads estão fazendo um processamento e você vai querer somente o valor mais atual desse processamento ou disparar uma ação depois que todas as threads tenham terminado. Bem, uma forma muito simples é usar join, que vai parar a thread atual até que a thread iniciada tenha concluído a execução.

Claro que no exemplo que vamos mostrar isso não é muito útil, pois as threads estão sendo executados de forma sequencial! Mas o exemplo ser para ilustrar como pode ser utilizado esse método. Com certeza que você ao conhecer esse método, fará uso mais criativo e úteis!

Vamos direto ao ponto, então temos a aplicação abaixo onde diversas threads atualizam o mesmo mapa com o tempo em milis atual e queremos saber o valor mais recente.


O código da classe AtualizadorMapa vai dar xabu sim ou com certeza?
Vai sim, terems um resultado como o seguinte:

Thread 1 - 1482988764969
Último valor do mapa: null
Thread 3 - 1482988764969
Thread 2 - 1482988764969
Thread 0 - 1482988764969
Thread 4 - 1482988764969

As vezes vai funcionar. Sim, as vezes as coisas vão sair no lugar, mas nem sempre. Agora imagine a dor de cabeça que implementações concorrentes não dão em produção!

Uma forma simples (inútil, diriam alguns) de resolver é usando o join. Talvez a única vantagem seja, mesmo perdendo a execução paralela, o fato que se uma thread lançar exceção, o problema principal não é afetado e outras threads poderão executar em seguida. Mas lembrem-se, o que temos aqui é um exemplo simples, há muitos possíveis para o join e meu objetivo hoje é somente apresentar esse método. Veja agora o código da classe AtualizadorMapaSincronizadoComJoin e notem que adicionar um join logo após iniciarmos a thread que criamos. Isso garante que a thread principal, a thread da classe, só vai continuar depois que nossa thread terminar o processamento. Como resultado, temos sempre o valor mais atual no mapa após o for...

O nosso objetivo aqui foi somente apresentar esse interessante método. Ah, se você ficou perdido com a forma que declaramos o Runnable ali, veja nosso artigo sobre Java Funcional com Lambdas.

Lendo e escrevendo arquivos usando Java 8

Ler arquivo em Java já foi um pouco complicado, pois o desenvolvedor tinha que ter conhecimento da API do Java I/O (InputStream, BufferedReader e por aí vai). Nessa postagem breve vou mostrar algumas formas incrivelmente fáceis de lidar com arquivos no Java 8.

Paths e Files

Essas classes contém métodos estáticos que permitem lidar com arquivos de forma mais fácil.

• Paths contém só dois métodos que permitem converter uma String (ou uma URI) com o caminho de um arquivo(ou de um diretório) em um objeto do tipo Path, que representa um caminho no sistema operacional. Notem que Files usa o objeto Path em muitos de seus métodos;
• Files é uma classe cheia de métodos utilitários para trabalharmos com arquivo e com o sistema de arquivos em Java.

Agora vamos  mostrar simples exemplos de como abrir arquivos. Se você usa Java 8, vai ver como está mais do que simples lidar com arquivos.

1) Ler os bytes do arquivo

Ler os bytes de um arquivo é essencial se quisermos trabalhar com imagens e outros tipos de arquivos. Mas também é util se queremos passar o conteúdo de um arquivo texto para uma String. Veja:


byte[] bytesArquivo = Files.readAllBytes(p);
String textoArquivo = new String(bytesArquivo);
System.out.println(textoArquivo);

2) Ler as linhas de um arquivo em uma lista

Caso você queria ter linha a linha de um arquivo sem ter que ler ele inteiro para "picar" em linhas, você pode! Simplesmente use o método Files.getAllLines passando o Path do arquivo e salve o retorno em uma lista(java.util.List):


List<String> linhasArquivo = Files.readAllLines(p);
for (String l : linhasArquivo) {
    System.out.println("Linha: " + l); 
}  
3) Ler as linhas de um arquivo em um Stream

Já falamos aqui das facilidades de um Stream e com uma linha de código a gente pode passar todas as linhas de dentro um arquivo de texto para um java.util.Stream, e nele fazer transformações, filtros, etc. Veja como é fácil:

Files.lines(p).forEach(System.out::println);

O que o método acima faz é pegar linha a linha de um arquivo e chamar o método System.out.println. Note que não preciso chamar o método em sí, mas sim passar a referência.

4) Escrever em um arquivo

Escrever em um arquivo é também assunto de chamar um método só! Chamados o método Files.write e passamos os bytes que queremos escrever:

String linhaNova = "Linha criada em " + new java.util.Date().toString();
Files.write(p, linhaNova.getBytes());

Conclusão

 
Mostramos as facilidades de lidar com arquivo no Java 8. Vejam o código completo baixo. Ele está pronto para ser compilado com javac e executado com java, mas lembre-se de criar um arquivo dados.txt no mesmo diretório onde estará o seu .class