Geek: Java o Filme

Uma brincadeira com Java! Muito engraçado.
Faça suas próprias escolhas.




Vídeo indicado por meu amigo Ricardo Teixeira (não é o da CBF).

Abraços,

JAVA: Compactação de Arquivos

Para compactar um texto ou frase em formato .ZIP, usando tecnologia Java, é uma tarefa relativamente simples.

Primeiro, cria-se um objeto de escrita de bytes FileOutputStream, em seguida cria-se um ZipOutputStream passando o FileOutputStream como parâmentro. O ZipOutputStream é responsável por escrever os bytes de forma compactada.

Segue um exemplo de como compactar o conteúdo de uma variável String:

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipFile {

public static void main(String[] args) {

 String str = "Texto para ser compactado! teste.";

 try {
  // cria o arquivo zip
  String outFilename = "/tmp/outfile.zip";
  ZipOutputStream out = new ZipOutputStream(new FileOutputStream(
    outFilename));

  out.putNextEntry(new ZipEntry("file.txt"));

  // grava a string acima no arquivo zip
  out.write(str.getBytes(), 0, str.getBytes().length);
  out.closeEntry();

  // fecha a stream e completa o arquivo
  out.close();
 } catch (IOException e) {
 }

 System.out.println("Complete");
}
}

O código de exemplo cria uma aquivo compactado /tmp/outfile.zip. Dentro do arquivo zip será criado um arquivo chamado file.txt com o texto contido na String str.


Para mais informações:
http://java.sun.com/developer/technicalArticles/Programming/compression/

JAVA: Parse de arquivo XML com DOM

Esse post mostra como efetuar a leitura e o parse de um arquivo tipo XML usando JAVA e a API DOM.

É muito comum a troca de arquivos XML na web, entre aplicações ou mesmo simples feeds via RSS.
O JAVA possui uma API chamada DOM (Document Object Model), com as classes providas por essa API é possível efetuar a leitura de um arquivo XML, extrair informações para objetos.

Abaixo segue um exemplo básico de arquivo XML utilizado para ilustrar o exemplo:

data.xml

    
     8
     Eiti Kimura
     Development Team
     eiti@mycompany.com
    
    
     9
     José da Silva
     Human Resources
     jose@mycompany.com
    
    
     10
     Karoline Taylor
     Tecnology Team
     karoline@mycompany.com
    

A idéia principal seria, extrair dos dados dos empregados (employee) desse arquivo, e retornar uma lista de objetos empregado. Esses objetos podem ser manipulados de inúmeras maneiras, entretanto no nosso exemplo, iremos apenas imprimir os objetos no console para verificar a extração dos dados.

O arquivo XmlDomParser.java mostra como fazer a leitura do arquivo, o parser e a extração dos dados em forma de uma lista de objetos:

XmlDomParser.java

package com.opendevnotes.xml.dom;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.StringReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;

/**
* @author J.P. Eiti Kimura
* @author Thiago Medeiros dos Santos
*/
public class XmlDomParser {

   private String xml;

   public static void main(String[] args) {

       XmlDomParser parser = new XmlDomParser();

       // obtem o path do arquivo
       URL url = XmlDomParser.class.getResource("data.xml");

       // faz a leitura do arquivo e armazena em uma string
       File file = new File(url.getPath());
       parser.readFile(file);

       // faz o parser do arquivo retornando uma lista de employees
       List empList = parser.unmarshallEmployees();

       // escreve a lista no console
       for (Employee emp : empList)
           System.out.println(emp);
   }

   /**
    * Lê o arquivo do disco
    * @param file
    * @return retorna um objeto String com o texto do arquivo lido
    */
   public String readFile(File file) {
       try {

           BufferedReader inp = new BufferedReader(new FileReader(file));

           String line;
           StringBuilder sb = new StringBuilder();

           while ((line = inp.readLine()) != null) {
               sb.append(line).append("\n");
           }

           this.xml = sb.toString();
           return sb.toString();
       } catch (FileNotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }

       return null;
   }

   /**
    * Efetua o parser da String xml
    * @return Document
    */
   public Document parse() {
       try {
           DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
           DocumentBuilder builder = null;

           try {

               builder = factory.newDocumentBuilder();
           } catch (ParserConfigurationException ex) {
               ex.printStackTrace();
           }

           Document doc = builder.parse(new InputSource(new StringReader(this.xml)));
           return doc;
       } catch (Exception e) {
           e.printStackTrace();
       }

       return null;
   }

   /**
    * Retorna uma listade objetos Employee
    * @return
    */
   public List unmarshallEmployees() {

       List employeeList = new ArrayList();
       Document doc = this.parse();

       try {
           // obtem o primeiro nó filho, o nó raiz 
           Node root = doc.getFirstChild();

           // obtem todos os filhos desse nó 
           NodeList rootChildren = root.getChildNodes();

           // para cada  faz a leitura das propriedades
           for (int count = 0; count < node =" rootChildren.item(count);" emp =" new">
       NodeList rootChildren = root.getChildNodes();
       for (int count = 0; count < node =" rootChildren.item(count);">

Para testar os exemplos acima, os dois arquivos (java e xml), devem estar no mesmo pacote, esse exemplo o pacote criado foi: com.opendevnotes.xml.dom.

Dessa forma, pode-se utilizar o Java DOM para ler/parsear arquivos XML preenchendo objetos de interesse. No entanto, o DOM pode ter desempenho ruim com arquivos XML com volume de dados muito grande. Para aplicações de pequeno e médio porte essa solução é amplamente utilizada.

Agradecimentos ao meu amigo Thiago Medeiros dos Santos pela ajuda com o parser XML desse exemplo.

Referências:
http://www.roseindia.net/xml/dom/
http://java.sun.com/j2se/1.4.2/docs/api/org/w3c/dom/package-summary.html

Ajuste de Data/Hora do Java no RedHat Linux

Executando um sistema Java Web no sistema RedHat Enterprise 3, percebi que a hora atual que o Java me retornava era em torno de 5 horas atrasada com relação ao horário do sistema, ou seja, o horário do comando date. Tudo leva a crer que o sistema não está configurado para ler um locale que usa como separador o caractere _ (underscore).

Uma forma de contornar o problema é criar um link simbólico da localidade, no meu caso de America/Sao_Paulo, para America/Sao Paulo, e em seguida setar como a localidade padrão do sistema e reiniciar o relógio. Abaixo um exemplo de programa em java simples para exibir a data/hora atual do sistema, para testar as modificações:

public class TesteHorario {

 /**
  * @param args
  */
 public static void main(String[] args) {
  System.out.println(new Date());
 }
}

Para criar um link simbólico para a localidade e setar como padrão do sistema, basta executar:

ln -s /usr/share/zoneinfo/America/Sao_Paulo /usr/share/zoneinfo/America/Sao\ Paulo
ln -sf /usr/share/zoneinfo/America/Sao\ Paulo /etc/localtime

Ou então no caso de existir uma variável de ambiente setada:

ln -s $JRE_HOME/lib/zi/America/Sao_Paulo  $JRE_HOME/lib/zi/America/Sao\ Paulo
ln -sf $JRE_HOME/lib/zi/America/Sao\ Paulo /etc/localtime

Para atualizar a data e hora do sistema após a modificação (se necessário):
Exemplo: modificar a data atual para 31 de julho, 11:16, basta digitar no console (perceba que a hora é informada no formato de 24h)

date 07312316 

Para atualizar o hardware clock com a data/hora obtidas com o comando date, basta executar:

/sbin/hwclock --systohc

Essas alterações foram suficientes para que o JAVA passasse a exibir a mesma data/hora do sistema operacional (RedHat Enterprise 3)

Java: Ler Arquivo Texto

Essa dica é bastante trivial, porém é um código que sempre necessito consultar diversas vezes.
Resolvi publicar aqui no blog, quem sabe facilita para mais alguém.

A dica é simplesmente ler um arquivo de texto linha-a-linha.
Vamos ao código:

try {
     BufferedReader in = new BufferedReader(new FileReader("infilename"));
     String str;
     while ((str = in.readLine()) != null) {
         process(str);
     }
     in.close();
 } catch (IOException e) {
 }

Esse trecho de código, lê uma linha do arquivo por vez, foi retirado originalmente do The Java Developers Almanac 1.4. Essa é a forma mais simples que encontrei para ler arquivos de texto puro.

No meu caso, o arquivo de texto é composto por valores separados por vírgula, onde, o primeiro campo se refere ao número de identificação do usuário e o segundo seu nome. Por exemplo:

112344316, José da Silva
098987626, Marcia de Mello
981122154, Fabiane de Andrade

   /**
    * Carrega lista de telefones válidos para processamento
    */
   private void loadTextFile()
   {
      String filePath = "/tmp/usersList.txt";
     
       try {
          
           BufferedReader in = new BufferedReader(new FileReader(filePath));
           String str;
           while ((str = in.readLine()) != null) {
               String data[] = str.split(",");
               System.out.println("Nome: " + data[1] + " CPF.:" + data[0]);
           }
          
           in.close();
       } catch (Exception e) {
           e.printStackTrace();
           System.out.println("Erro ao ler arquivo de texto " + e.toString());
       }
   }

Esse código simples mostrou como ler e processar um arquivo de texto linha por linha.

JAVA: Converter Imagem para Escala de Cinza

Um exemplo básico de processamento de imagens em JAVA é a conversão de uma imagem colorida para escala de cinza.

Esse exemplo (MainClass) mostra como efetuar a leitura dos pixels de uma imagem, converter seus valores para RGBA (red, green, blue, alpha), modificar os pixels e gravar uma nova imagem.

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class MainClass {

 // converte pixels da imagem para tons de cinza
 public static int[] imageToGray(int image[]) {
  int grayimage[] = new int[image.length];

  for (int i = 0; i < image.length; i++) {
   // extrai a informação RGBA do valor inteiro
   int alpha = (image[i] >> 24) & 0xff;
   int red = (image[i] >> 16) & 0xff;
   int green = (image[i] >> 8) & 0xff;
   int blue = (image[i]) & 0xff;

   // média dos valores RGB para tranformar para
   // escala de cinza
   int mean = (red + green + blue) / 3;

   // converte a informação de rgb para inteiro
   int gray = ((0 << 24) & 0xFF000000) | ((mean << 16) & 0x00FF0000) | ((mean << 8) & 0x0000FF00) | (mean & 0x000000FF);

   // seta o pixel modificado na imagem
   grayimage[i] = gray;
  }

  return grayimage;
 }

 public static void main(String[] args) throws IOException {

  File inputFile = new File("/tmp/tux-ubuntu.jpg");
  BufferedImage buffImage = ImageIO.read(inputFile);

  int w = buffImage.getWidth();
  int h = buffImage.getHeight();

  int rgba[] = new int[w * h];
  // obtem pixels do bufferedImage
  buffImage.getRGB(0, 0, w, h, rgba, 0, w);

  // converte para tons de cinza
  int gray[] = imageToGray(rgba);
  // escreve no bufferedImage
  buffImage.setRGB(0, 0, w, h, gray, 0, w);

  // escreve nova imagem no disco
  ImageIO.write(buffImage, "JPG", new File("/tmp/tux-gray.jpg"));
 }
}

O exemplo de utilização da classe:

JAVA: Varargs

Uma característica muito legal das linguagens orientadas à objetos, em especial do JAVA é o overloading de métodos, onde um mesmo método pode ser invocado usando assinaturas diferentes. Por exemplo, um método com o mesmo nome, mas com uma variável quantidade de argumentos aceitáveis.
Um exemplo poderia ser:

Calc c = new Calc();

c.calcula(10, 35, 34);

c.calcula(3.4, 12);

c.calcula("Triângulo", 56, 23, 21);

No exemplo acima, foi instanciada uma classe chamada Calc, que efetua algum tipo de cálculo qualquer. O objeto c possui um método chamado calcula(), que pode ser chamado de três formas diferentes, onde o nome do método não muda, somente seus argumentos.

O Varargs (Variable Arguments), permite especificar que o método terá múltiplos argumentos do mesmo tipo, sem que haja necessidade de pre-determinar o número exato de argumentos(em tempo de compilação e/ou execução).

Para utilizar o varargs, fazemos uso da elipse (...), onde os três pontos são a chave (keyword) pra varargs. Vejamos e exemplo da classe VargsExample, esta por sua vez é composta de métodos que calculam a média de valores passados com o argumentos. Temos mean(float num1, float num2), que calcula a média de 2 argumentos, um overload do método anterior: mean(float num1, float num2, float num3, float num4); que calcula a média entre quatro argumentos, e por ultimo, temos a utilização de varargs: mean(float... numbers), que permite o cálculo da média para um número indefinido de argumentos, incluindo a passagem de parâmetro como um array primitivo do tipo float.

public class VargsExample {

// método que calcula a média
public float mean(float num1, float num2) {
return (num1 + num2) / 2.0f;
}

// overloading do método que calcula a média
public float mean(float num1, float num2, float num3, float num4) {
return (num1 + num2 + num3 + num4) / 4.0f;
}

// calculo da média usando varargs
public float mean(float... numbers) {
float sum = 0;

for (float n : numbers)
sum += n;

return sum / (float) numbers.length;
}

public static void main(String[] args) {

VargsExample calc = new VargsExample();
// Exemplos de chamadas de métodos

// método de calculo de média
calc.mean(10, 23);

// overloading
calc.mean(10, 20, 30, 40);

// usando varargs que recebe número indeterminado de argumentos
calc.mean(12);
calc.mean(new float[] {12, 45, 78, 34, 21, 34, 54, 8, 9, 12, 87});
calc.mean(0, 2, 1);
calc.mean(9, 5, 7, 10, 4);
}
}

O exemplo apresentado, mostra a flexibilidade que se consegue com o emprego de varargs em determinados métodos. Esse recurso foi introduzido na versão Tiger do JAVA: 1.5.

JAVA: Criando Threads

Podemos fazer analogia a um processo como sendo um programa em execução. Já uma Thread é conhecida como "processo leve" (lightweight process), é considerada leve pelo fato de rodar dentro do contexto do processo, aproveitando-se do compartilhamento dos recursos alocados para o ambiente do programa.

Há casos em que dentro da execução de um processo, verifica-se a necessidade de "disparar" uma thread que irá executar paralelamente ao processo a que pertence. Dessa forma, pode-se executar instruções sem que o processo principal fique em estado de espera "lock" até que um trecho de código seja executado.

Em JAVA pode-se herdar a classe Thread ou implementar a interface Runnable para se utilizar threads em seus processos. Exemplo de uma thread simples:

/**
*
* @author João Paulo Eiti Kimura Classe que estende uma tread simples
*/
public class SimpleThread extends Thread {

public SimpleThread(String str) {
super(str);
}

public void run() {

// qualquer processamento ...

// faz a thread dormir um número aleatório em (ms)
long sleepTime = (long) (Math.random() * 1000);
System.out.println(getName() + " sleeping for " + sleepTime + " ms");

try {
sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("finished: " + getName()); // finaliza a execuçao
}
}

No exemplo da classe SimpleThread, pode-se verificar que a classe herda características da classe Thread do java. Seu construtor default chama o construtor da classe mãe (Thread), no qual o parâmetro passado representa o nome da thread. O método principal da thread é o run, é nele que todo processamento é realizado. Com fins ilustrativos, o método run desse exemplo apenas aguarda um tempo em milissegundos.

Vejamos como executar a classe SimpleThread:

public class ExemploThread {

public static void main(String[] args) {

SimpleThread t1 = new SimpleThread("Thread 1");
SimpleThread t2 = new SimpleThread("Thread 2");
SimpleThread t3 = new SimpleThread("Thread 3");

t1.start();
t2.start();
t3.start();
}
}

Na classe ExamploThread, foram instanciados 3 objetos das classe SimpleThread. Para iniciar a execução da thread, fez-se a chamada ao método start() de cada objeto. Esse método executa o método run implementado na thread.
Resultado da execução da classe ExemploThread:

Thread 1 sleeping for 546 ms
Thread 3 sleeping for 580 ms
Thread 2 sleeping for 854 ms
finished: Thread 1
finished: Thread 3
finished: Thread 2

Dessa forma é possível executar tarefas em paralelo ao processo principal de um programa. Entretando, se sua classe já tiver herdado alguma outra classe não será possível herdar a classe Thread, ou qualquer outra, devido a natureza da linguagem que permite a herdar as características de apenas 1 classe. Especificamente para solucionar esse caso, faz-se uso da implementação da interface Runnable.

A classe que implementar a interface Runnable irá implementar o método run. Vamos a um exemplo de implementação desta interface:

public class ThreadInterface extends MyClass implements Runnable {

public void run() {

// qualquer processamento ...

// faz a thread dormir um número aleatório em (ms)
long sleepTime = (long) (Math.random() * 1000);
System.out.println(Thread.currentThread().getName() + "Thread sleeping for " + sleepTime + " ms");

try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("finished: " + Thread.currentThread().getName()); // finaliza a execuçao
}
}

Um exemplo de chamada e execução da classe que implementa a interface Runnable:

public class ExemploThreadInterface {

public static void main(String[] args) {

new Thread(new ThreadInterface(), "Thread1").start();
new Thread(new ThreadInterface(), "Thread2").start();
new Thread(new ThreadInterface(), "Thread3").start();
}
}

Resultado da execução:

Thread1Thread sleeping for 569 ms
Thread3Thread sleeping for 821 ms
Thread2Thread sleeping for 795 ms
finished: Thread1
finished: Thread2
finished: Thread3

Com a classe Thread e a interface Runnable é possível criar facilmente threads simples em Java, de forma a executar tarefas na execução de qualquer processo da aplicação.

Download dos códigos fonte dos exemplos: thread_src.zip

JAVA: Trabalhando com Data/Hora

Tive a necessidade de comparar datas em JAVA, uma forma rápida e fácil de fazer isso é usando classe Calendar.

A Calendar é uma classe abstrata, com ela pode-se modificar uma data/hora em dias, minutos, meses e etc. Segue um exemplo de como comparar duas datas usando a classe Calendar do java:

CalendarExemplo1.java

 import java.util.Calendar;
 import java.util.Date;

 public class CalendarExemplo1 {

  public static void main(String[] args) {

   Calendar data1 = Calendar.getInstance();
   data1.add(Calendar.DAY_OF_MONTH, 2);

   Calendar data2 = Calendar.getInstance();
   data2.add(Calendar.HOUR, 1);

   int result = data1.compareTo(data2);
   String msg = "";

   if (result == 0)
   {
    msg = "Data 1 é igual que Data 2";
   }
   else if (result > 0)
      msg = "Data1 é maior que Data 2";
   else
    msg = "Data 1 é menor que Data 2";

   System.out.println("Data/Hora Atual: " + new Date());
   System.out.println("Data 1 : " + data1.getTime());
   System.out.println("Data 2 : " + data2.getTime());
   System.out.println(msg);
  }
 }

Resultado:

Data/Hora Atual: Tue Sep 23 14:14:06 GMT-03:00 2008
Data 1 : Thu Sep 25 14:14:06 GMT-03:00 2008
Data 2 : Tue Sep 23 15:14:06 GMT-03:00 2008
Data1 é maior que Data 2

Os métodos mais utilizados da Calendar para modificar os valores das datas são o add e o roll.
Com método add pode-se somar ou subtrair unidades de tempo das datas. Exemplo:

CalendarExample2.java

 import java.util.Calendar;
 import java.util.Date;

 public class CalendarExemplo2 {

  public static void main(String[] args) {

      //atrasa em 1 horas e 30 minutos a hora atual
      Calendar cal = Calendar.getInstance();
      cal.add(Calendar.HOUR, -1);
      cal.add(Calendar.MINUTE, -30);

      //obtem a data e hora em milisegundos
      long d1= cal.getTimeInMillis();
         long d2= new Date().getTime();

         //calcula a diferença enter as datas
         long diff = (d2-d1);

         //converte de ms para min. (1ms/1000)/60
         long minute = (long)(diff*1e-3)/60;

         System.out.print("Dif. temporal (min): " + minute);
  }
 }

Observe que nas linhas 10 e 11 eu estou atrasando o horário atual em 1 hora e 30 minutos. O calculo da diferença temporal é feito em milisegundos (linha 18) e depois convertido em minutos para a exibição (linha 21).

Resultado:

Dif. temporal (min): 90

O resultado mostra a diferença entre as duas datas em minutos foi de 90 minutos.

O método roll faz a chamada "rolagem" da unidade de tempo, sem alterar as demais unidades. Por exemplo, pode-se pedir para que seja rolado 10 meses a frente, isso é feito alterando-se somente a unidade mês, o ano e o dia vão continuar os mesmos. Exemplo:

CalendarExample3.java

 import java.util.Calendar;

 public class CalendarExemplo3 {

  public static void main(String[] args) {

   Calendar cal = Calendar.getInstance();
   System.out.println(cal.getTime());

   //"rolagem" do mês em 5 unidades
   cal.roll(Calendar.MONTH, 5);
             System.out.print(cal.getTime());
  }
 }

Resultado:

Tue Sep 23 14:16:08 GMT-03:00 2008
Sat Feb 23 14:16:08 GMT-03:00 2008

A rolagem da unidade de tempo mês é feita na linha 11 do programa CalendarExample3.java. Perceba no resultado que a data iniciou no mês de setembro, contou-se 5 meses a frente, a data final foi para o mês de fevereiro, sem que o ano se modificasse.

Com a classe Calendar é possível fazer a diferenças entre datas e horas de forma fácil e intuitiva, bastando apenas indicar a unidade de tempo e o quando será adicionado ou retirado.

Download dos códigos fonte: calendar_src.zip

Para mais detalhes sobre as demais funcionalidades da classe Calendar, consulte o java doc no endereço: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Calendar.html

JAVA: Arrays Primitivos e a classe java.util.Arrays

A classe java.util.Arrays do Java versão 1.5 (Tiger), possui uma série de métodos estáticos para trabalhar com vetores unidimensionais e matrizes.

Nesse caso, mostrarei operações básicas sobre vetores unidimensionais, tais como exibir um vetor em tela, ordenar, comparar e buscar dados em um vetor utilizando a java.util.Arrays.

Nesse exemplo mostra como utilizar as funcionalidades da classe java.util.Arrays:

ArrayExamples.java

import java.util.Arrays;

public class ArrayExamples {

public static void main(String[] args) {

int arr1[] = {23,2,89,123,21,12,17,13,56,90,218,0};
int arr2[] = {23,2,89,123,21,12,17,13,56,90,218,0};
int arr3[] = {0,3,9,23,1,45,10,21,56,90,218,33};

String arrFrutas[] = {"maça", "banana", "abacate", "laranja", "manga"};

//converter array para string e exibir no console
System.out.println("array1: " + Arrays.toString(arr1));
System.out.println("array2: " + Arrays.toString(arr2));
System.out.println("array3: " + Arrays.toString(arr3));

//comparação entre arrays
System.out.println("arrays arr1 e arr2 são iguais? " +Arrays.equals(arr1, arr2));
System.out.println("arrays arr2 arr3 são iguais? " +Arrays.equals(arr3, arr2));

//ordenar array primitivo
Arrays.sort(arrFrutas);
System.out.println("arrFrutas ordenado:" + Arrays.toString(arrFrutas));

//busca binária em array primitivo
System.out.println("lanranja encontrada no índice: " + Arrays.binarySearch(arrFrutas, "laranja"));

}
}

Na classe ArrayExamples.java primeiramente, foram declarados 4 vetores, sendo 3 de valores primitivos do tipo inteiro (int) e 1 do tipo cadeia de caracteres (String).

Para exibir o array no console sem a necessidade de fazer um laço de repetição para isso foi utilizado o método Arrays.toString(). Para comparar 2 arrays foi utlizado o método Arrays.equals(). Na ordenação do array o método Arrays.sort() foi utilizado. Já para efetuar uma busca binária no array em questão, utilizou-se o método Arrays.binarySearch() que retorna o índice do valor procurado no vetor.

Resultado da execução do programa:

array1: [23, 2, 89, 123, 21, 12, 17, 13, 56, 90, 218, 0]
array2: [23, 2, 89, 123, 21, 12, 17, 13, 56, 90, 218, 0]
array3: [0, 3, 9, 23, 1, 45, 10, 21, 56, 90, 218, 33]
arrays arr1 e arr2 são iguais? true
arrays arr2 arr3 são iguais? false
arrFrutas ordenado:[abacate, banana, laranja, manga, maça]
lanranja encontrada no índice: 2

Muitos códigos podem ser optimizados utilizando essa classe uma vez que algoritmos de busca, ordenação e comparação já estão implementados.

JAVA: Copiar Arquivo

Esse pequeno trecho de código mostra como fazer cópias de arquivos em Java.

A classe FileCopy possui o método copy que tem como parâmetros o caminho do arquivo de origem (à ser copiado), e o caminho do arquivo de destino.

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class FileCopy {

public boolean copy(String infile, String outfile) {

try {

//abre as streams
InputStream in = new FileInputStream(infile);
OutputStream out = new FileOutputStream(outfile);

byte[] buf = new byte[1024];
int len;

//transfere os bytes da stream in para a out
while ((len = in.read(buf)) > 0) {
 out.write(buf, 0, len);
}

//fecha os arquivos
in.close();
out.close();
return true;

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

return false;
}


public static void main(String[] args) {
FileCopy file  = new FileCopy();
boolean res = file.copy("/tmp/tux-ubuntu.jpg", "/tmp/tux-ubuntu-copia.jpg");

System.out.println("File copied? " + res);
}
}

O método copy abre o arquivo de origem e transfere seus bytes para o arquivo de destino, criando assim uma cópia do arquivo. No código de exemplo, o arquivo tux-ubuntu.jpg será copiado para o arquivo tux-ubuntu-copia.jpg.

Resultado após executar o programa:










Download do código fonte: FileCopy.java

Configurar suporte ao Java no Firefox 3

Ao atualizar o Firefox da versão 3 beta para a final no ubuntu 8.04, notei que o suporte a java não estava mais configurado corretamente, eu não podia mais executar applets java no browser.

Para confgurar novamente o browser para suporte ao java, é necessário já ter o java instalado e configurado no sistema. Dessa forma é necessário:

Entrar no diretório de plugins do firefox:

$ cd /usr/lib/firefox-addons/plugins

Criar um link pra a lib do jre. No meu caso o diretório que eu instalei o java é: /opt/java

$ sudo ln -sf /opt/java/jre/plugin/i386/ns7/libjavaplugin_oji.so libjavaplugin.so

Reinicie o firefox para que as alterações entrem em vigor. Para verificar se a instalação do plugin foi efetuada com sucesso, vá até o menu Ferramentas->Complementos e clique na aba Plugins, lá você deve ver o plugin do java listado.

Para baixar a versão 3 do firefox, visite o endereço:
http://pt-br.www.mozilla.com/pt-BR/firefox/

Conversão de Caracteres para HTML Entities

Recentemente recebi um layout em HTML com os textos usando acentuação: á é í ó ç e etc. Quando colocado no browser tive problemas para exibir esses caracteres corretamente, eles apareciam de forma ilegível.

Como eu estou no linux, não tenho como usar os recursos de softwares proprietários dreamweaver, editplus e etc que já fazem a conversão dos caracteres especiais para os chamados HTML Entities. Procurando na rede, descobri um projeto open-source no sourceforge chamado HTMLEntities que consiste em um conjunto de classes em java para fazer esse tipo de conversão.

Para baixar os códigos fontes e o jar já compilado do projeto, visite o endereço: http://sourceforge.net/projects/htmlentities/

Depois de adicionar o jar do HTMLEntities no seu projeto Java, é possível acessar os recursos de conversão de caracters por meio de uma classe estática. Veja um exemplo simples de conversão de caracteres acentuados para HTML Entities (SimpleConvert.java):

package com.htmlentity;
import com.tecnick.htmlutils.htmlentities.HTMLEntities;

public class SimpleConvert {

 public static void main(String[] args) {
    String text = "substituição de caracteres: á é í ó ú ç";

    String html = HTMLEntities.htmlentities(text);

    System.out.println("Caracteres convertidos: " + html);
 }
}

O método htmlentities(String) da classe HTMLEntities é chamado estaticamente, reliza a corversão do texto passado como parâmetro e retorna o novo resultado (Linha 8 do código).

Essa conversão é util para desenvolvedores que necessitam colocar esse tipo de funcionalidade dentro de seus projetos java, ou mesmo webdesigners que precisam codificar seus textos em forma de HTML Entities.

Java: Medir tempo de execução de tarefas

Com a necessidade de medir o desempenho de uma determinada classe, criei um cronômetro simples. Acredito que seja um código facilmente encontrado na rede, mas esse é bem optimizado e de fácil utilização.

O cronômetro é uma classe estática chamada Chronometer.java:

/**
 * @author J.P. Eiti Kimura Classe para cronometrar
 * operações em Java
 */
public final class Chronometer {

 private static long startValue;
 private static long stopValue;
 private static long timeDiff;

 /**
  * Inicia a contagem temporal
  */
 public static void start() {
  startValue = System.currentTimeMillis();
  stopValue = 0;
  timeDiff = 0;
 }

 /**
  * Calcula a diferença temporal
  */
 public static void stop() {
  stopValue = System.currentTimeMillis();
  timeDiff = stopValue - startValue;
 }

 /**
  * Retorna o diferença de tempo medida
  * @return tempo em milisegundos
  */
 public static long elapsedTime() {
  return timeDiff;
 }
}

A classe é basicamente formada por métodos estáticos de inicio de contagem de tempo (linha 14), de termino da contagem e cálculo do tempo (linha 23), e por fim, um método que retorna o valor do tempo medido (linha 32).

Para exemplificar a utilização da classe Chronometer, vamos medir o tempo gasto para efetuar duas tarefas usando recursos diferentes.

Imagine uma situação onde se deseja concatenar uma cadeia de caracteres qualquer um número definido de vezes. Qual objeto java seria mais rápido para fazer essa tarefa, um simples String, ou um StringBuffer? Para responder essa questão vamos medir o desempenho com nossa classe de cronômetro.

ChonoTest.java

public class ChronoTest {

 public static void main(String[] args) {

  StringBuffer sb = new StringBuffer();
  String sValue = "";

  long time1 = 0;
  long time2 = 0;

  // mede tempo da primeira operação
  Chronometer.start();
  for (int i = 0; i < 5000; i++) {
   sb.append("It's measure time!");
  }
  Chronometer.stop();
  time1 = Chronometer.elapsedTime();

  // mede tempo da segunda operação
  Chronometer.start();
  for (int i = 0; i < 5000; i++) {
   sValue += "It's measure time!";
  }
  Chronometer.stop();
  time2 = Chronometer.elapsedTime();

  System.out.println("StringBuffer result:" + time1 + "ms");
  System.out.println("String       result:" + time2 + "ms");

 }
}

Note que inicialmente, utilizou-se a classe de cronômetro para a marcar o tempo gasto para concatenar 5000 vezes a frase "It's measure time!" (linha 12). Após a concatenação, o cronômetro é parado (linha 16) e o tempo é calculado (linha 17).

Executando a classe ChronoTest.java em um computador com processador Core2 Quad, com 2GB de memória RAM obtive o seguinte resultado:

StringBuffer result:16ms
String       result:7586ms

Esse pequeno exemplo mostra como é possível calcular o tempo gasto em determinadas operações, pode ser aplicado para verificar o tempo gasto do retorno de um conjunto de dados de um banco de dados por exemplo, e mesmo para identificar qual parte do processamento de uma tarefa é a mais custosa em tempo.