Java 7 - Notação binária

O Java 7 incorpora uma notação bastante interessante e importante para expressar bits. Esta notação é chamada de Binary Literals e tem como prefixo 0b. Desde antes, o Java já suportava a notação hexadecimal (0x) e octal (0).

Como a maioria já sabe, todos os dados computacionais são bits em sua forma bruta. O tipo de uma variável é uma formatação dos bits para torná-los inteligíveis à nós.

Gostei desta notação porque me pouparia de acessar a calculadora científica (agora do programador) para converter uma máscara de bits em decimal ou hexadecimal. Espero ter a oportunidade de usufruir deste recurso no futuro.

Vamos explorar agora algumas possibilidades de uso do Binary Literals ou Notação Binária em Java 7:

Obs.: Aproveitei para usar "_" (underscore ou underline) para melhorar a leitura dos bits grandes, mas não interfere no resultado.

char A = 0b0000000001000001;

char B = 0b0000000001000010;

char C = 0b0000000001000011;

char D = 0b0000000001000100;

char E = 0b0000000001000101;

short numberShort_16bits = 0b0000000000000011;

int numberInt_32bits = 0b01000000_10000000_10000000_10000000;

long numberLong_64bits = 0b001000000_10000000_10000000_10000000_01000000_10000000_10000000_10000000L;

float numberFloat_32bits = 0b001000000_10000000_10000000_10000000;

double numberDouble_64bits = 0b001000000_10000000_10000000_10000000_01000000_10000000_10000000_10000000L;

char arrayOfChar [] = {0b0000000001000001, 0b0000000001000010, 0b000000000100001};

short arrayOfnumberShort_16bits [] = {0b0000000000000011, 0b0000000100000111};

int arrayOfnumberInt_32bits [] = {0b01000000_10000000_10000000_10000000, 0b01000000_10000000_10000000_10000000};

long arrayOfnumberLong_64bits [] = {0b001000000_10000000_10000000_10000000_01000000_10000000_10000000_10000000L,
        0b001000000_10000000_10000000_10000000_01000000_10000000_10000000_10000000L};

float arrayOfnumberFloat_32bits [] = {0b001000000_10000000_10000000_10000000_01000000_10000000_10000000_10000000L,
        0b001000000_10000000_10000000_10000000_01000000_10000000_10000000_10000000L};

double arrayOfnumberDouble_64bits [] = {0b001000000_10000000_10000000_10000000_01000000_10000000_10000000_10000000L, 0b001000000_10000000_10000000_10000000_01000000_10000000_10000000_10000000L};


Até a próxima.

Java - Bufferizar dados

Após algumas vezes programar rotinas para capturar bytes vindos de conexão socket ou porta serial, armazenar estes bytes e em seguida processá-los para extrair a informação original, percebi logo a complexidade disso.

Qualquer um que já tenha programado um client ou server socket em Java, C++ e C ANSI sabe o que digo, pois utilizar um byte array para armazenar (bufferizar) dados recebidos antes de enquadrar uma informação significativa é uma maneira arcaica e dispensiosa.

Certo dia, resolvi simplificar esta situação com a criação de um mecanismo chamado WTByteBuffer bastante simples para prover apenas dois métodos, um método de escrita e outro de leitura a partir do ByteBuffer do Java NIO.

O método de escrita armazena os bytes lidos e o método de leitura consome os bytes. Desta forma, o programador Java será poupado de todo o trabalho discutido anteriormente para bufferizar e consumir dados recebidos.

WTByteBuffer - Classe para bufferizar


import java.nio.ByteBuffer;

public class WTByteBuffer {

    public static final int DEFAULT_MAX_SIZE = 1024 * 65;

    private volatile ByteBuffer buffer;
    private int size;
    private int bufferMaxSize;

    public int getSize() {
        return this.size;
    }

    public ByteBuffer getBuffer() {
        return this.buffer;
    }
   
   
    public WTByteBuffer() {
        this(WTByteBuffer.DEFAULT_MAX_SIZE);
    }

    public WTByteBuffer(int bufferMaxSize) {
        this.bufferMaxSize = bufferMaxSize;
        this.buffer = ByteBuffer.allocate(bufferMaxSize);
        buffer.position(0);
        this.size = 0;
       
    }

    public synchronized void write(byte[] bytes) {

        if (this.buffer == null)
            System.out.println("Buffer nulo : W");
       
        this.buffer.put(bytes);
        this.size = this.buffer.position();
       
    }

    public synchronized int read(byte[] bytes) {

        int target, position, newPosition, capacity;
        byte[] completeBuffer = null;
        byte[] remainingBuffer = null;

        if (bytes == null || bytes.length == 0) {
            return 0;
        }

        if (this.buffer == null)
            System.out.println("Buffer nulo : R");

        target = bytes.length;
        position = this.buffer.position();
        capacity = this.buffer.capacity();

        if (target > position) {
            target = position;
        }

        newPosition = position - target;
        completeBuffer = new byte[position];
        remainingBuffer = new byte[newPosition];
       
        this.buffer.flip();
        this.buffer.get(completeBuffer, 0, position);
        System.arraycopy(completeBuffer, 0, bytes, 0, target);

        this.buffer = null;
        this.buffer = ByteBuffer.allocate(capacity);
       
        if (newPosition > 0) {
            System.arraycopy(completeBuffer, target, remainingBuffer, 0, newPosition);
            this.buffer.put(remainingBuffer);
        }
   
        this.size = this.buffer.position();
   
        return target;

    }
   
    public synchronized void clear() {
       
        if (this.buffer != null) {
            this.buffer.clear();
            this.buffer = null;
        }
        this.buffer = ByteBuffer.allocate(bufferMaxSize);
        buffer.position(0);
        this.size = 0;

    }   
 
}

Testando um buffer

Este exemplo cria uma instância de WTByteBuffer com 100 bytes de capacidade, escreve a série de bytes de um texto qualquer e recupera de um em um byte. Depois repete o teste recuperando de dois em dois bytes do texto bufferizado.

        WTByteBuffer buffer = new WTByteBuffer(100);
        String text = "ABXYZ-0123456-abc";
       
        byte[] read = new byte[2];
        byte[] serialized = text.getBytes();
        int size = 0;

        System.out.println("-----------------------------------------");

        buffer.write(serialized);

        System.out.format("Texto guardado em buffer: %s\n", text);
       
        System.out.println("Recupera texto de 1 em 1 byte...");
       
        while (buffer.getSize() > 0) {

            read = new byte[1];

            size = buffer.read(read);

            System.out.format("1 byte lido: %s\n", new String(read));

        }

        System.out.format("Bytes guardados: %d\n", buffer.getSize());

        System.out.println("-----------------------------------------");

        buffer.write(serialized);

        System.out.format("Texto guardado em buffer: %s\n", text);
       
        System.out.println("Recupera texto de 2 em 2 byte...");
       
        while (buffer.getSize() > 0) {

            read = new byte[2];

            size = buffer.read(read);

            System.out.format("%d byte(s) lido(s): %s\n", size, new String(read));

        }
       
        buffer = null;


Numa situação real a capacidade deste buffer deverá ser maior do que 100. Caso desejar aumentar o tamanho, faça isso ao construir o WTByteBuffer ou então utilize o construtor padrão para iniciar com o tamanho padrão de reserva máxima.

A classe abordada ainda provê métodos adicionais para controle e acesso ao buffer central.

Boa sorte.

Alerta de ameaça - Plugin Java para navegadores

Foi detectada recentemente uma falha no plugin do Java para navegadores e está sendo explorada por um malware difundido pela rede.

O malware é capaz de conceder acesso completo ao sistema de seu computador que poderá ser controlado por servidores já preparados para isso.

A recomendação é desativar o plugin do Java de seus navegadores enquanto a falha na segurança é corrigida.

Caso você não saiba como desabilitar o plugin em seu navegador, consulte um especialista para te ajudar.

Fontes:
http://g1.globo.com/tecnologia/noticia/2012/08/java-tem-falha-critica-e-codigo-de-exploracao-ja-circula-na-web.html
http://tecnoblog.net/111640/java-falha-zero-day/

Eclipse - Failed to create Java Virtual Machine

Recentemente meu Eclipse Indigo se atualizou como de costume e após reiniciá-lo recebi a mensagem "Failed to create the Java Virtual Machine".

A razão do problema é que o Eclipse teve seu arquivo de inicialização modificado de maneira errada por alguma atualização.

Foi necessário editar o arquivo Eclipse.INI  e reorganizar as informações e o Eclipse voltou a funcionar:

Atenção: Faça um backup do seu Eclipse.INI antes de alterá-lo, porque os pacotes JAR do seu INI original devem ser preservados.

-startup
plugins/org.eclipse.equinox.launcher_1.2.0.v20110502.jar
--launcher.library
plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.1.100.v20110502
-product
org.eclipse.epp.package.rcp.product
--launcher.defaultAction
openFile
--launcher.XXMaxPermSize
256M
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
--launcher.defaultAction
openFile
-vm
C:\Program Files\Java\jdk1.6.0_27\bin\javaw.exe
-vmargs
-Dosgi.requiredJavaVersion=1.5
-Xms40m
-Xmx1024m
 
Fonte: http://wiki.eclipse.org/Eclipse.ini

Java - Leitura de XML com a SAX

Ao ler um arquivo XML você pode utilizar duas maneiras, SAX e a DOM.

A SAX é prove uma forma direta de acessar elementos de um XML por seu identificador e não requer leitura de uma hierarquia para isso. Diferente da SAX, a DOM é uma maneira de ler o XML também, mas por meio de uma hierarquia.

No entanto, este artigo apresenta um exemplo de leitura de XML via SAX na linguagem Java.

Documento XML

Crie o arquivo cesta.xml. No exemplo, este arquivo foi criado no diretório c:\temp. Preencha com o conteúdo a seguir:

<cesta loja="Papelex">

   <caneta>Caneta BIC</caneta>
   <caneta>Caneta Kilometrica</caneta>
   <caneta>Caneta Faber</caneta>
   <caneta>Caneta Helios</caneta>
   <caneta>Caneta Ferrari</caneta>
   <caneta>Caneta Pentec</caneta>

   <lapis>Caneta BIC</lapis>
   <lapis>Caneta Kilometrica</lapis>
   <lapis>Caneta Faber</lapis>
   <lapis>Caneta Helios</lapis>
   <lapis>Caneta Ferrari</lapis>
   <lapis>Caneta Pentec</lapis>

</cesta>
 

Classe de leitura do XML

Crie a classe de leitura do XML chamada TestaXML.java.

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;

public class TestaXML {

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

        File f = new File("c:/temp/cesta.xml");
       
        SAXBuilder sb = new SAXBuilder();
       
        Document doc = sb.build(f);

        Element cesta = doc.getRootElement();

        System.out.println("CESTA:");   
        System.out.println("Loja: " + cesta.getAttributeValue("loja"));   
        System.out.println("-------------------------------------------------");   
       
        List<Element> canetas = cesta.getChildren("caneta");

        for (int i = 0; i < canetas.size(); i++) {
           
            Element caneta = canetas.get(i);

            System.out.println("CANETA:");   
            System.out.println("Modelo: " + caneta.getValue());   
        }
        System.out.println("-------------------------------------------------");   
       
        List<Element> lapis = cesta.getChildren("lapis");

        for (int i = 0; i < lapis.size(); i++) {
           
            Element umLapis = lapis.get(i);

            System.out.println("LÁPIS:");   
            System.out.println("Modelo: " + umLapis.getValue());   
        }

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


Observe que entre as tags <cesta> e </cesta>, foram colocadas tags <caneta> e <lapis> muitas vezes. Logo, foram acessadas separadamente os elementos do tipo caneta e lápis pela função getChildren.

TDC 2012

No próximo dia 4 até 8/07/2012, ocorrerá em São Paulo, na Universidade Anhembi Morumbi a sexta edição TDC (The Developers Conference), evento organizado pela GlobalCode para profissionais e estudantes iniciantes em tecnologia.

Você pode se inscrever e selecionar uma trilha de palestra por dia. Por exemplo, se na segunda-feira você decidir participar da trilha sobre Java, passará o "dia inteiro" de palestra vendo somente Java. Além do Java, outras tecnologias atuais serão palestradas com Ruby, Python, PHP, C/C++, Scala, .NET, Arduino, Testes, Marketing Digital, Robótica, Banco de Dados, Android, iOS, WindowsPhone e muito mais.

As inscrições já estão abertas no site do evento.

Para mais informações, acesse:

Java - Clonagem de objetos

Durante sua vida um programador pode lidar com a necessidade de manter um objeto matriz e reproduzir cópias deste objeto para fins de alterar estas cópias sem perder a originalidade da matriz.

Posso descrever uma situação onde tive uma rotina de envio de mensagem para um determinado host, mas esta rotina alterava propriedades da minha mensagem original porque seu comportamento normal era este. Foi desenhado para envio de mensagem sempre para um destinatário. Efeito:

  d - Destino da mensagem (host).

  m.o. - Mensagem original.

  m.a. - Mensagem alterada.

  send_to_some (d, m.o. -> m.a.) - Função de envio para d onde m.o. passa a ser m.a. ao final do processamento.

Acrescentei ao sistema uma função a mais para enviar a mensagem destinada para mais de um host através de clonagem para preservar a original. Efeito:

  m.o. - Mensagem original.

  m.c. - Mensagem clonada.

  m.a. - Mensagem alterada.

  send_to_all (m.o. -> m.a.) - Função de envio para todos m.c. passa a ser m.a. ao final do processamento, mas m.o. é preservado.

Após implementar send_to_all, simplismente esta função passou a varrer a lista ativa de conexões de hosts e para cada iteração clona a mensagem original e passa o clone como parâmetro de send_to_some.

Vamos para a prática!

WTByteArrayInputStream

Esta classe representa um mecanismo para transformar uma série de bytes em um objeto. Será utilizada no processo de clonagem.

import java.io.InputStream;

public class WTByteArrayInputStream extends InputStream {

    protected byte[] buf = null;

    protected int count = 0;

    protected int pos = 0;

    public WTByteArrayInputStream(byte[] buf, int count) {
        this.buf = buf;
        this.count = count;
    }

    public final int available() {
        return count - pos;
    }

    public final int read() {
        return (pos < count) ? (buf[pos++] & 0xff) : -1;
    }

    public final int read(byte[] b, int off, int len) {
        if (pos >= count)
            return -1;

        if ((pos + len) > count)
            len = (count - pos);

        System.arraycopy(buf, pos, b, off, len);
        pos += len;
        return len;
    }

    public final long skip(long n) {
        if ((pos + n) > count)
            n = count - pos;
        if (n < 0)
            return 0;
        pos += n;
        return n;
    }

}

WTByteArrayOutputStream

Esta classe representa um mecanismo para transformar um objeto em uma série de bytes e oferece uma função para obter uma conexão com os bytes do objeto.

import java.io.InputStream;
import java.io.OutputStream;

public class WTByteArrayOutputStream extends OutputStream {

    protected byte[] buf = null;
    protected int size = 0;

    public WTByteArrayOutputStream() {
        this(5 * 1024);
    }

    public WTByteArrayOutputStream(int initSize) {
        this.size = 0;
        this.buf = new byte[initSize];
    }

    private void verifyBufferSize(int sz) {
        if (sz > buf.length) {
            byte[] old = buf;
            buf = new byte[Math.max(sz, 2 * buf.length )];
            System.arraycopy(old, 0, buf, 0, old.length);
            old = null;
        }
    }

    public int getSize() {
        return size;
    }

    public byte[] getByteArray() {
        return buf;
    }

    public final void write(byte b[]) {
        verifyBufferSize(size + b.length);
        System.arraycopy(b, 0, buf, size, b.length);
        size += b.length;
    }

    public final void write(byte b[], int off, int len) {
        verifyBufferSize(size + len);
        System.arraycopy(b, off, buf, size, len);
        size += len;
    }

    public final void write(int b) {
        verifyBufferSize(size + 1);
        buf[size++] = (byte) b;
    }

    public void reset() {
        size = 0;
    }

    public InputStream getInputStream() {
        return new WTByteArrayInputStream(buf, size);
    }

}

WTCloneObject

Esta classe é a própria rotina de clonagem.

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class WTCloneObject {

    public static Object copy(Object orig) {

        Object obj = null;

        try {

            WTByteArrayOutputStream fbos = new WTByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(fbos);

            out.writeObject(orig);
            out.flush();
            out.close();

            ObjectInputStream in = new ObjectInputStream(fbos.getInputStream());
            obj = in.readObject();

        }
        catch(IOException e) {
            e.printStackTrace();
        }
        catch(ClassNotFoundException cnfe) {
            cnfe.printStackTrace();
        }
        return obj;
    }

}

DadosPessoais

Esta classe é um bean muito simples que auxiliará apenas o teste. Como será o tipo do objeto para clonar em nosso teste, esta deve implementar a interface Serializable. Observe a palavra-chave transient no parâmetro senha_Bancaria, pois indica que o atributo não será gravado quando o objeto de DadosPessoais for serializado em bytes. Esta mesma técnica pode ser utilizada se um dos atributos for tão complexo ou fechado que não te permite fazer suas classes ou sub-classes implementarem a interface Serializable.

import java.io.Serializable;
 
class DadosPessoais implements Serializable {

    private String nome;
    private int idade;
    private String telefone;
    private String sexo;
    private transient String senha_Bancaria;

    public String getNome() {
        return nome;
    }

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

    public int getIdade() {
        return idade;
    }

    public void setIdade(int idade) {
        this.idade = idade;
    }

    public String getTelefone() {
        return telefone;
    }

    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }

    public String getSexo() {
        return sexo;
    }

    public void setSexo(String sexo) {
        this.sexo = sexo;
    }

    public String getSenha_Bancaria() {
        return senha_Bancaria;
    }

    public void setSenha_Bancaria(String senha_Bancaria) {
        this.senha_Bancaria = senha_Bancaria;
    }

    @Override
    public String toString() {
        return "DadosPessoais [nome=" + nome + ", idade=" + idade
                + ", telefone=" + telefone + ", sexo=" + sexo
                + ", senha_Bancaria=" + senha_Bancaria + "]";
    }

}

Testando

Crie uma classe de teste com um método main para testar a clonagem:

        DadosPessoais matriz = new DadosPessoais();

        matriz.setNome("Jose");
        matriz.setIdade(30);
        matriz.setTelefone("+55 11 88888888");
        matriz.setSexo("M");
        matriz.setSenha_Bancaria("123#%!");

        System.out.println("Esta é a matriz");
        System.out.println(matriz.toString());
        System.out.println("");

        for (int i = 0; i < 10; i++) {
           
            DadosPessoais clone = (DadosPessoais) WTCloneObject.copy(matriz);

            System.out.println("Este é o clone id = " + i);
            System.out.println(clone.toString());
            System.out.println("");
           
        }

Fique atento, a senha não foi clonada em nenhum momento porque foi marcada como transient na classe DadosPessoais.

Até a próxima.