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:
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;
}
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.
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);
}
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();
}
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:
Valor
Descrição
Saída
y
Ano
2014
M
Mês do Ano
April, 07, 7
d
Dia do Mês
1-31
E
Dia da Semana
Friday, Sunday
a
AM/PM
AM, PM
H
Hora do Dia
0-23
h
Hora AM/PM
1-12
m
Minutos
0-60
s
Segundos
0-60
Para mais informações sobre os padrões válidos, visite a documentação Oficial JAVA.
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());
//