Translate

segunda-feira, 7 de abril de 2014

Manipulando Strings em JAVA usando StringBuilder

Quando precisamos trabalhar com objetos do tipo String uma excelente dica é utilizar os métodos da classe java.lang.StringBuilder. 

A documentação oficial da classe StringBuilder pode ser encontrada AQUI.

As classses StringBuilder e StringBuffer possuem os mesmos métodos e características, apenas com a diferença que a primeira não é segura para Threads. 

Abaixo, código simples de concatenação de String de forma dinâmica, melhor prática em relação à concatenação de String utilizando o operador "+=" 



    
        StringBuilder sb = new StringBuilder();


        sb.append("Teste");
        sb.append(" ");
        sb.append("Somente");

        
        /**
         * Retorna o valor concatenado 
         * através do metodo toString()
         */
        System.out.println(sb.toString());


Note que ao final, recuperamos o valor utilizando o metodo toString() da classe StringBuilder. 

    


       Teste Somente


Abaixo, outro exemplo de utilização de outros métodos da classe StringBuilder; acrescentando a linha: 


    
 sb.reverse();
Obtemos o texto invertido:
  

       etnemoS etseT

domingo, 6 de abril de 2014

Leitura de Arquivos Texto com JAVA

Para realizar a leitura de arquivo texto em disco, (indiferente à extensão) podemos utilizar o método abaixo descrito.

O método lerArquivo() é capaz de verificar a existência do arquivo, e retornar uma String com o conteúdo do arquivo lido. 

O código abaixo realiza a leitura de arquivos em disco: 





    public String lerArquivo() throws Exception {

        File arquivo;
        FileInputStream fis = null;
        String saida = null;
        try {

            arquivo = new File("exemplo.txt");

            /**
             * Verifica se o arquivo existe, caso contrário, lança exceção
             */
            if (!arquivo.exists()) {

                throw new Exception("Arquivo não existe.");

            }

            fis = new FileInputStream(arquivo);

            int ln;

            /**
             * Para cada linha lida do Arquivo, concatena à variáel 'saida'
             */
            while ((ln = fis.read()) != -1) {
                saida += (char) ln;
            }



        } catch (Exception ex) {

            throw new Exception("Erro ao ler arquivo. " + ex.getMessage());

        } finally {
            /**
             * Se o FileInputStream não estiver instanciado, 
             * não há necessidade de fechá-lo
             */
            if (fis != null) {
                fis.close();
                
            }
        }

        return saida;

    }

sábado, 5 de abril de 2014

Gerando Números Aleatórios com Math.random() em JAVA

Muitas vezes precisamos de valores aleatórios em nossas aplicações. 

Em JAVA, a poderosíssima classe java.lang.Math (mais informações AQUI) é capaz de realizar diversas operações com números e ainda nos disponibiliza o método random() que retorna um numero pseudo-aleatório em forma de um valor do tipo primitivo double com sinal positivo entre 0.0 e 1.0.

O Código abaixo demonstra a utilização do metodo random(): 
//
        
        double valorAleatorio = Math.random();
        
        
        //Exibe na Tela
        System.out.println(valorAleatorio);

//


Note que pelos valores serem entre 0.0 e 1.0, por vezes faz-se necessário convertê-los em um inteiro, usando o processo de cast como no código abaixo: 



//

        int valorInt = (int)(Math.random()*100);
        
        
        /**
         * Exibe na Tela
        */
        System.out.println(valorInt);
        

//
Atenção que torna-se necessário multiplicarmos por 100 (como no exemplo, para obtermos valores entre 0 e 100) pois senão obteríamos somente o valor 0. 

sexta-feira, 4 de abril de 2014

Display 7 segmentos com Arduino


Começaremos através deste artigo, nosso primeiro post com soluções para Arduino. 

Neste rápido tutorial, mostraremos como acionar um display de 7 segmentos utilizando a plataforma Arduino. 

Nosso projeto difere-se dos demais, pois utiliza o circuito integrado CD 4511 (datasheet disponível aqui).

O objetivo de se utilizar este CI, é economizar portas de saída do Arduino, pois com  o CD 4511, necessitamos apenas de 4 portas do Arduino, para acionar os 7 segmentos deste display.

Abaixo vídeo demonstrando o circuito em funcionamento:



Note que foi adicionado o efeito de fader para desvanecimento do digito. Para isso, apenas ligamos no pino 10  o anodo comum do display, e variamos a intensidade do brilho, baseado no tempo.

No código, geramos o BCD (para entrada do 4511) usando um array bidimensional onde colocamos todos os dígitos a serem exibidos (de 0 a 9) e  o valor a ser colocado nos 4 pinos de saída do Arduino (1 ou 0) . 

O código ainda exibe na saída serial, a tabela verdade do dígito exibido.

Abaixo o código: 





/*

 Display de 7 segmentos ligado atravs do circuito integrado
 CD 4511
 
 */



const int pinA = 6;   //LSB bit MENOS significativo
const int pinB = 7; 
const int pinC = 8; 
const int pinD = 9;   //MDB bit MAIS significativo

                       //  D C B A
byte digitos[10][4] ={   { 0,0,0,0 },  // = 0
                         { 0,0,0,1 },  // = 1
                         { 0,0,1,0 },  // = 2
                         { 0,0,1,1 },  // = 3
                         { 0,1,0,0 },  // = 4
                         { 0,1,0,1 },  // = 5
                         { 0,1,1,0 },  // = 6
                         { 0,1,1,1 },  // = 7
                         { 1,0,0,0 },  // = 8
                         { 1,0,0,1 }   // = 9
                         };

const int faderPin = 10;



void setup(){

  pinMode(pinA, OUTPUT);   
  pinMode(pinB, OUTPUT);   
  pinMode(pinC, OUTPUT);   
  pinMode(pinD, OUTPUT);  
  
  pinMode(faderPin, OUTPUT);  
  
  Serial.begin(9600);
}  

void loop(){

     
//  CONTAGEM CRESCENTE
//
    for (byte count = 0; count < 10; ++count) {
    
     imprimeBCD(count);
     fadeOut(); 
     delay(500); 
    
   
  }
 
 
  Serial.print("*****************\n\n");
  delay(2000);


}

void imprimeBCD(byte digit) {
  
  byte pin = 9; // pino do MSB bit mais significativo 
  
  Serial.print(digit);Serial.print(",\n ");
                Serial.print("D  C  B  A \n");
  for (byte segCount = 0; segCount < 4; ++segCount) {


    imprimeTabelaVerdade(pin,  digitos[digit][segCount]);
    
    digitalWrite(pin, digitos[digit][segCount]); //envia BCD para 4511
    --pin; // decrementa pino do bit

  }   
   fadeIn(); 


  Serial.print("\n\n");
  
}

void imprimeTabelaVerdade(int p, int estado){

  switch (p) {

  case 6: 

    Serial.print(" ");

    Serial.print(estado);
    Serial.print(" ");
    break;
  case 7: 
    Serial.print(" ");

    Serial.print(estado);
    Serial.print(" ");
    break;
  case 8: 

  
    Serial.print(" ");

    Serial.print(estado);
    Serial.print(" ");
    break;
  case 9: 

   
    Serial.print(" ");

    Serial.print(estado);  
    Serial.print(" ");  
    break;

  }
}


void fadeOut(){

  for(int i = 0; i < 255; ++i)
  {
    analogWrite(faderPin, i);
    delay(5);
  }
  
  digitalWrite(faderPin, HIGH); 

}


void fadeIn(){


   for(int i = 255; i > 0; --i)
  {
    analogWrite(faderPin, i);
    delay(5);
  }
  
    digitalWrite(faderPin, LOW); 
}


Gravação de Arquivos com JAVA

Demonstraremos neste breve tutorial como a tarefa de realizar a Leitura e Gravação de arquivos, utilizando JAVA é relativamente simples. 

Primeiramente veremos o método de gravação.

Este recebe como parâmetro uma String e realiza a gravação da mesma em um arquivo com a extensão .txt. 

Esta extensão é sugerida, porém não obrigatória. Sinta-se à vontade para colocar o nome do arquivo como preferir. 

O código abaixo, demonstra o método gravaArquivo(): 
 public void gravaArquivo(String entrada) throws IOException {

        FileOutputStream fos = null;

        try {

            /**
             * Executa Verificação para garantir que o valor de entrada não é nulo
             */
            if (entrada == null || entrada.trim().isEmpty()) {
                throw new IOException("Impossível gravar! Conteúdo Vazio ou nulo");
            }

            
            /**
             * Nome do arquivo a ser gravado.
             */
            File arquivo = new File("exemplo.txt");

            /**
             * O Construtor de FileOutputStream recebe como 
             * primeiro parametro, o conteudo a 
             * ser gravado no arquivo, e 
             * como segundo parametro um booleano, chamado 'append'
             * que determina se, caso o arquivo exista, 
             * o conteudo deva ser concatenado com o ja existente (true)
             * ou sobrescrito (false) 
             */
            fos = new FileOutputStream(arquivo, false);

            fos.write(entrada.trim().getBytes());

        } catch (IOException iex) {

            throw iex;

        } finally {

            fos.close();

        }


Formatando Datas em Java



Ainda falando sobre Datas. 

Muitas vezes precisamos formatar as datas a fim de facilitar a visualização do usuário. 

Utilizaremos neste exemplo a Classe java.text.SimpleDateFormat, que possui diversos métodos para o trabalho com valores de data. 

Basta passarmos um padrão determinado, no construtor de SimpleDateFormat (Ex. "dd/MM/yyyy") e aplicar o método format(), que retorna a String formatada de acordo com o padrão designado anteriormente.

O Código abaixo mostra um exemplo de utilização da Classe SimpleDateFormat, para formatação de Datas:


         /**
          * Captura data atual do Sistema
          *
        Date data = new Date(System.currentTimeMillis()); 
        
        
        /**
         *  Passa padrão "dd/MM/yyyy" para o construtor
         */
   SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");

System.out.println(formato.format(data).toString());




A tabela abaixo, mostra padrões bastante utilizados com o SimpleDateFormat:

ValorDescriçãoSaída
yAno2014
MMês do AnoApril, 07, 7
dDia do Mês1-31
EDia da SemanaFriday, Sunday
aAM/PMAM, PM
HHora do Dia0-23
hHora AM/PM1-12
mMinutos0-60
sSegundos0-60


Para mais informações sobre os padrões válidos, visite a documentação Oficial JAVA.

quinta-feira, 3 de abril de 2014

Conversão java.util.Date para java.sql.Date

Trabalhar com Datas em JAVA, para o programador iniciante e até mesmo para programadores mais experientes, pode ser uma tarefa um tanto quanto confusa. 


Quando trabalhamos com persistência dos dados em banco, muitas vezes precisamos fazer a conversão entre as classes java.util.Date (quando ainda são atributos de determinado objeto) para java.sql.Date (para persistência ou retorno do Banco de Dados).


Basta utilizar o metodo getTime() da classe java.sql.Date e passar o retorno do mesmo, no construtor do objeto java.util.Date. 


O código abaixo realiza a conversão de  java.sql.Date para  java.util.Date:


   
//


    // Converte java.sql.Date para java.util.Date     

    /*
     *  data do tipo java.sql.Date,
     *  pegando data atual do sistema    
     */

    java.sql.Date dataSql = new java.sql.Date(System.currentTimeMillis());



    /*     
     *  cria novo objeto java.util.Date,
     *  usando o metodo getTime() do java.sql.Date
      */
    java.util.Date dataUtil = new java.util.Date(dataSql.getTime());

    //Exibe na tela
    System.out.println("java.util.Date: " + dataUtil.toString());
    System.out.println("java.sql.Date: " + dataSql.toString());


//
O contrário também é possível.

A classe java.util.Date também possui o método getTime() e o Construtor do objeto da classe java.sql.Date também recebe o retorno, do tipo Long.


O código abaixo realiza a conversão de  java.util.Date para  java.sql.Date:
   
//

    // Converte java.util.Date para java.sql.Date     

    /* 
     *  data do tipo java.util.Date,
     *  pegando data atual do sistema
     */

    java.util.Date dataUtil = new java.util.Date(System.currentTimeMillis());



    /*     
     *  cria novo objeto java.sql.Date,
     *  usando o metodo getTime() do java.util.Date
     */
    java.sql.Date dataSql = new java.sql.Date(dataUtil.getTime());

    //Exibe na tela
    System.out.println("java.util.Date: " + dataUtil.toString());
    System.out.println("java.sql.Date: " + dataSql.toString());


//
É isso.