Artigos com o marcador Java

Verificando finais de semana em Java

08/09/09

Pessoal,

Seguem dois métodos simples que utiliza a API Calendar do JAVA para detectar os finais de semana de um determinado mês. Os dias dos mês que são finais de semana são colocados em uma List e retornados pelo método. Já me quebrou muitos galhos esses métodos.

Lembrando que em Calendar, o mês 01 (janeiro) começa com o valor 0.

O código abaixo está dividido em dois métodos. Há o isFinaDeSemana() que a partir de um dia, mês e ano, te devolve se é ou não um final de semana. O outro método getFinaisDeSemanaMes() te devolve uma list com todos os dias que são finais de semana em um mês.

  private List getFinaisDeSemanaMes(int ano, int mes)
  {
    Calendar calendar = new GregorianCalendar(ano, mes - 1, 1);
    int diasMaximos = calendar.getMaximum(Calendar.DAY_OF_MONTH);
    int dia = 1;
    List finaisDeSemana = new ArrayList();
 
    for (dia = 1; dia <= diasMaximos; dia++)
    {
      try
      {
        if (isFinalDeSemana(ano, mes, dia))
        {
          finaisDeSemana.add(new Long(dia));
        }
      }
      catch (Exception ex)
      {
        ex.printStackTrace();
        continue;
      }
    }
 
    return finaisDeSemana;
  }
 
  private boolean isFinalDeSemana(int ano, int mes, int dia) throws Exception
  {
    if ((mes < 1) || (mes > 12))
    {
      throw new Exception("Mês inválido");
    }
 
    boolean finalDeSemana;
    mes = mes - 1;
    Calendar data = new GregorianCalendar();
 
    data.set(ano, mes, 1);
    int diaMaximo = data.getActualMaximum(Calendar.DAY_OF_MONTH);
 
    if (diaMaximo < dia)
    {
      throw new Exception("Dia inválido");
    }
 
    data.set(ano, mes, dia);
    int diaDaSemana = data.get(Calendar.DAY_OF_WEEK);
 
    if ((diaDaSemana == Calendar.SATURDAY) || (diaDaSemana == Calendar.SUNDAY))
    {
      finalDeSemana = true;
    }
    else
    {
      finalDeSemana = false;
    }
 
    return finalDeSemana;
  }

calendar, final de semana, Java

Usando o XStream para serializar e desserializar objetos Java para XML

06/03/09

Escrito por RicardoSEP em Java

7 comentários

O XStream é uma biblioteca simples e poderosa que facilita muito nossa vida quando precisamos serializar objetos Java para arquivos XML e também para fazer o processo inverso. A partir de JavaBeans podemos escrever os XML com poucas linhas de código.

Nesse artigo o uso básico e o intermediário do XStream. Veremos como serializar e desserializar objetos, o uso de aliases e list.

O ambiente que usei para criar esse artigo foi o seguinte:

Windows XP – SP3
JDK 6
Eclipse 3.4 – Ganymede
XStream 1.3.1

Para começar, precisamos baixar a biblioteca para ser usada. Acessem o site oficial do XStream (http://xstream.codehaus.org), cliquem em “Download” e baixem a última versão da versão binária (Binary Distribution).

Depois de baixado, descompacte o arquivo e você verá diversos arquivos JARs. Não precisamos de todos, porém se quiser pode adicionar todos no classpath do seu projeto ou aqueles que mais se encaixarem em suas necessidades. No site do XStream tem uma explicação sobre cada uma das dependências opcionais. Acesse: http://xstream.codehaus.org/download.html.

Depois de adicionar os JARs no classpath, estamos prontos para começar a codificar. Nosso primeiro exemplo será serializar um objeto simples (JavaBean) para XML. Vamos criar esse objeto:

 
package com.meupost.beans;
 
public class Agenda {
 
	private String nomePessoa;
	private int idade;
	private String email;
	private String telefone;
	private String fax;
 
	public String getNomePessoa() {
		return nomePessoa;
	}
 
	public void setNomePessoa(String nomePessoa) {
		this.nomePessoa = nomePessoa;
	}
 
	public int getIdade() {
		return idade;
	}
 
	public void setIdade(int idade) {
		this.idade = idade;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	public String getFax() {
		return fax;
	}
 
	public void setFax(String fax) {
		this.fax = fax;
	}
}

Beleza! O objeto é esse. Vamos mandar ele para um XML. No nosso exemplo faço a serialização direto no void main(). Vejam:

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.thoughtworks.xstream.XStream;
 
public class Main {
 
    public static void main(String args[]) {
 
         Agenda a1 = new Agenda();
 
         a1.setEmail("amigo1@email.com.br");
         a1.setFax("123-4567");
         a1.setIdade(55);
         a1.setNomePessoa("Fernando Pessoa");
         a1.setTelefone("654-3210");
         XStream x = new XStream();
 
         System.out.println(x.toXML(a1));
 
    }
}

A saída será assim:

<com.meupost.beans.Agenda>
  <nomePessoa>Fernando Pessoa</nomePessoa>
  <idade>55</idade>
  <email>amigo1@email.com.br</email>
  <telefone>654-3210</telefone>
  <fax>123-4567</fax>
</com.meupost.beans.Agenda>

Muito bom. Mas agora vamos complicar mais um pouco. Vamos criar mais um objeto chamado Endereco que vai conter onde nosso indivíduo mora. Esse objeto Endereco entrará como atributo do objeto Agenda. Vejam o exemplo abaixo de como fica e o resultado do XML.

Objeto Endereco:

 
package com.meupost.beans;
 
public class Endereco {
 
	private String rua;
	private int numero;
	private String cidade;
	private String estado;
 
	public String getRua() {
		return rua;
	}
 
	public void setRua(String rua) {
		this.rua = rua;
	}
 
	public int getNumero() {
		return numero;
	}
 
	public void setNumero(int numero) {
		this.numero = numero;
	}
 
	public String getCidade() {
		return cidade;
	}
 
	public void setCidade(String cidade) {
		this.cidade = cidade;
	}
 
	public String getEstado() {
		return estado;
	}
 
	public void setEstado(String estado) {
		this.estado = estado;
	}
}

Objeto Agenda. Reparem que adicionamos o atributo Endereco!

package com.meupost.beans;
 
public class Agenda {
 
	private String nomePessoa;
	private int idade;
	private String email;
	private String telefone;
	private String fax;
	private Endereco endereco;
 
	public String getNomePessoa() {
		return nomePessoa;
	}
 
	public void setNomePessoa(String nomePessoa) {
		this.nomePessoa = nomePessoa;
	}
 
	public int getIdade() {
		return idade;
	}
 
	public void setIdade(int idade) {
		this.idade = idade;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	public String getFax() {
		return fax;
	}
 
	public void setFax(String fax) {
		this.fax = fax;
	}
 
	public Endereco getEndereco() {
		return endereco;
	}
 
	public void setEndereco(Endereco endereco) {
		this.endereco = endereco;
	}
}

E agora o teste e resultado:

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.meupost.beans.Endereco;
import com.thoughtworks.xstream.XStream;
 
public class Main {
 
    public static void main(String args[]) {
 
        Agenda a1 = new Agenda();
 
        a1.setEmail("amigo1@email.com.br");
        a1.setFax("123-4567");
        a1.setIdade(55);
        a1.setNomePessoa("Fernando Pessoa");
        a1.setTelefone("654-3210");
 
        Endereco end = new Endereco();
        end.setRua("Rua Saldanha Marinho");
        end.setNumero(1234);
        end.setCidade("São José do Rio Preto");
        end.setEstado("São Paulo");
 
        a1.setEndereco(end);
        XStream x = new XStream();
 
        System.out.println(x.toXML(a1));
 
     }
}

Ótimo. E por fim o XML gerado:

<com.meupost.beans.Agenda>
  <nomePessoa>Fernando Pessoa</nomePessoa>
  <idade>55</idade>
  <email>amigo1@email.com.br</email>
  <telefone>654-3210</telefone>
  <fax>123-4567</fax>
  <endereco>
    <rua>Rua Saldanha Marinho</rua>
    <numero>1234</numero>
    <cidade>São José do Rio Preto</cidade>
    <estado>São Paulo</estado>
  </endereco>
</com.meupost.beans.Agenda>

Viram que dentro do nó endereco temos os atributos que definimos no nosso objeto? Pois bem, é assim que você pode relacionar os JavaBeans.

Vocês já devem ter percebido que o nome do nó raiz ta o mesmo nome do pacote. Isso com certeza é um incoveniente muito grande quando colocamos nosso sistema em produção. Para arrumarmos isso, podemos usar os Aliases que o XStream oferece. Basta uma linha de código. Vamos mudar nosso método void main() adicionando o alias e vamos gerar o XML novamente. Vejam:

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.meupost.beans.Endereco;
import com.thoughtworks.xstream.XStream;
 
public class Main {
 
    public static void main(String args[]) {
 
        Agenda a1 = new Agenda();
 
        a1.setEmail("amigo1@email.com.br");
        a1.setFax("123-4567");
        a1.setIdade(55);
        a1.setNomePessoa("Fernando Pessoa");
        a1.setTelefone("654-3210");
 
        Endereco end = new Endereco();
        end.setRua("Rua Saldanha Marinho");
        end.setNumero(1234);
        end.setCidade("São José do Rio Preto");
        end.setEstado("São Paulo");
 
        a1.setEndereco(end);
 
       XStream x = new XStream();
       //Adicionei nova linha aqui!
       x.alias("agenda", Agenda.class);
 
       System.out.println(x.toXML(a1));
 
    }
}

E o resultado:

<agenda>
  <nomePessoa>Fernando Pessoa</nomePessoa>
  <idade>55</idade>
  <email>amigo1@email.com.br</email>
  <telefone>654-3210</telefone>
  <fax>123-4567</fax>
  <endereco>
    <rua>Rua Saldanha Marinho</rua>
    <numero>1234</numero>
    <cidade>São José do Rio Preto</cidade>
    <estado>São Paulo</estado>
  </endereco>
</agenda>

Agora, vamos fazer o processo inverso. Ao invés de escrevermos o XML, vamos ler e criar os objeto a partir do XML. Para facilitar, vamos usar nossos objetos já criados (Agenda e Endereco). Abaixo há um exemplo onde crio um objeto String com o XML a ser lido, passo a String ao XStream e o próprio se encarrega de criar nossos objetos JavaBean de volta sem esforço nenhum.

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.meupost.beans.Endereco;
import com.thoughtworks.xstream.XStream;
 
public class Main {
 
    public static void main(String args[]) {
 
        String xml;
 
        xml = "<agenda>" +
        "<nomePessoa>Angelina Jolie</nomePessoa>" +
        "<idade>35</idade>" +
        "<email>angelina@jolie.com</email>" +
        "<telefone>1742-5236</telefone>" +
        "<fax>6541-222</fax>" +
        "<endereco>" +
             ="<rua>Rubião Júnior</rua>" +
            "<numero>2104</numero>" +
            "<cidade>São José do Rio Preto</cidade>" +
            "<estado>São Paulo</estado>" +
        "</endereco>" +
        "</agenda>";
 
        XStream x = new XStream();
 
        x.alias("agenda", Agenda.class);
        Agenda a = (Agenda) x.fromXML(xml);
 
        System.out.println(a.getNomePessoa());
    }
}

Vejam que no exemplo acima eu precisei indicar qual a classe que o nó raiz “agenda” fazia parte. Depois foi só passar o XML para o XStream e fazer o Cast para obter o objeto. Por fim exibimos em console o nome da Angelina!

Agora mais um problema tanto para leitura quanto para escrita do XML. E quando temos várias informações dentro de um nó? Por exemplo, temos um XML precido com esse abaixo:

<agenda>
  <pessoas>
    <pessoa>
      <nomePessoa>Fernando Pessoa</nomePessoa>
      <idade>55</idade>
      <email>amigo1@email.com.br</email>
      <telefone>124-6984</telefone>
      <fax>654-3210</fax>
      <endereco>
        <rua>Rua Saldanha Marinho</rua>
        <numero>5110</numero>
        <cidade>São José do Rio Preto</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
    <pessoa>
      <nomePessoa>felipao@email.com.br</nomePessoa>
      <idade>60</idade>
      <email>amigo1@email.com.br</email>
      <telefone>2310-1110</telefone>
      <fax>211-4100</fax>
      <endereco>
        <rua>Rua Francisco Glicério</rua>
        <numero>210</numero>
        <cidade>Campinas</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
    <pessoa>
      <nomePessoa>Raul Seixas</nomePessoa>
      <idade>78</idade>
      <email>raulzito@email.com.br</email>
      <telefone>222-2222</telefone>
      <fax>111-1111</fax>
      <endereco>
        <rua>Rua Mar Vermelho</rua>
        <numero>450</numero>
        <cidade>Babilônia</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
  </pessoas>
</agenda>

Temos vários nós pessoa. Como se fosse uma lista de pessoas. E para tratarmos isso com o XStream? Temo como? Sim, lógico que tem. Primeiramente vamos criar o objeto (JavaBean) Pessoa contendo os mesmos atributos que havia no objeto Agenda, pois agora o objeto Agenda vai conter somente um atributo que é a lista de pessoas. Veja como fica o objeto Agenda e o objeto Pessoa:

Agenda:

package com.meupost.beans;
 
import java.util.ArrayList;
import java.util.List;
 
public class Agenda {
 
	private List<Pessoa> pessoas = new ArrayList<Pessoa>();
 
	public void add(Pessoa pessoa) {
		this.pessoas.add(pessoa);
	}
 
	public List<Pessoa> getContent() {
		return this.pessoas;
	}
}

Pessoa:

package com.meupost.beans;
 
public class Pessoa {
 
	private String nomePessoa;
	private int idade;
	private String email;
	private String telefone;
	private String fax;
	private Endereco endereco;
 
	public String getNomePessoa() {
		return nomePessoa;
	}
 
	public void setNomePessoa(String nomePessoa) {
		this.nomePessoa = nomePessoa;
	}
 
	public int getIdade() {
		return idade;
	}
 
	public void setIdade(int idade) {
		this.idade = idade;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	public String getFax() {
		return fax;
	}
 
	public void setFax(String fax) {
		this.fax = fax;
	}
 
	public Endereco getEndereco() {
		return endereco;
	}
 
	public void setEndereco(Endereco endereco) {
		this.endereco = endereco;
	}
}

Viram a diferença? Agora o objeto agenda possui uma List onde podemos ir adicionando o objeto Pessoa. O XStream ficará responsável de ler essa List e colocar no XML. Abaixo veja o exemplo de preenchimento dos objetos e o resultado depois que o XStream transforma para XML:

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.meupost.beans.Endereco;
import com.meupost.beans.Pessoa;
import com.thoughtworks.xstream.XStream;
 
 
public class Main {
 
     public static void main(String args[]) {
 
		Agenda a1 = new Agenda();
 
		Pessoa p1 = new Pessoa();
		p1.setEmail("amigo1@email.com.br");
		p1.setFax("654-3210");
		p1.setIdade(55);
		p1.setNomePessoa("Fernando Pesso");
		p1.setTelefone("124-6984");
		Endereco e1 = new Endereco();
		e1.setRua("Rua Saldanha Marinho");
		e1.setCidade("São José do Rio Preto");
		e1.setNumero(5110);
		e1.setEstado("São Paulo");
		p1.setEndereco(e1);
 
		Pessoa p2 = new Pessoa();
		p2.setEmail("amigo1@email.com.br");
		p2.setFax("211-4100");
		p2.setIdade(60);
		p2.setNomePessoa("felipao@email.com.br");
		p2.setTelefone("2310-1110");
		Endereco e2 = new Endereco();
		e2.setRua("Rua Francisco Glicério");
		e2.setCidade("Campinas");
		e2.setNumero(210);
		e2.setEstado("São Paulo");
		p2.setEndereco(e2);
 
		Pessoa p3 = new Pessoa();
		p3.setEmail("raulzito@email.com.br");
		p3.setFax("111-1111");
		p3.setIdade(78);
		p3.setNomePessoa("Raul Seixas");
		p3.setTelefone("222-2222");
		Endereco e3 = new Endereco();
		e3.setRua("Rua Mar Vermelho");
		e3.setCidade("Babilônia");
		e3.setNumero(450);
		e3.setEstado("São Paulo");
		p3.setEndereco(e3);
 
		a1.add(p1);
		a1.add(p2);
		a1.add(p3);
 
		XStream x = new XStream();
		x.alias("agenda", Agenda.class);
		x.alias("pessoa", Pessoa.class);
		String xml = x.toXML(a1);
 
		System.out.println(xml);
    }
}

E a nossa saída em XML:

<agenda>
  <pessoas>
    <pessoa>
      <nomePessoa>Fernando Pesso</nomePessoa>
      <idade>55</idade>
      <email>amigo1@email.com.br</email>
      <telefone>124-6984</telefone>
      <fax>654-3210</fax>
      <endereco>
        <rua>Rua Saldanha Marinho</rua>
        <numero>5110</numero>
        <cidade>São José do Rio Preto</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
    <pessoa>
      <nomePessoa>felipao@email.com.br</nomePessoa>
      <idade>60</idade>
      <email>amigo1@email.com.br</email>
      <telefone>2310-1110</telefone>
      <fax>211-4100</fax>
      <endereco>
        <rua>Rua Francisco Glicério</rua>
        <numero>210</numero>
        <cidade>Campinas</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
    <pessoa>
      <nomePessoa>Raul Seixas</nomePessoa>
      <idade>78</idade>
      <email>raulzito@email.com.br</email>
      <telefone>222-2222</telefone>
      <fax>111-1111</fax>
      <endereco>
        <rua>Rua Mar Vermelho</rua>
        <numero>450</numero>
        <cidade>Babilônia</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
  </pessoas>
</agenda>

Bem, estamos chegando quase no fim do artigo. Mostrei como usar o XStream para escrever XML e como ler. Ainda há muito o que aprender sobre o XStream como os aliases de campo (aliasField) e atributos. Mas esse artigo não irá se aprofundar tanto. Espero que com o que foi mostrado e ensinado aqui seja o suficiente para um início. Há um pouco de material de estudo no site do XStream, mas também é básico. O melhor mesmo é ir no Google ou mexer no JavaDoc do XStream (http://xstream.codehaus.org/javadoc/index.html).

Para praticar você pode usar diversas APIs disponíveis como o do YouTube, Mercado Livre, Yahoo… Esses XMLs são mais complexos e são ótimos para estudo.

Até a próxima!

Java, persistencia, serializacao, tutorial, xml, xstream

Serialização de objeto no Java

03/12/08

Escrito por RicardoSEP em Java

Nenhum comentário

Quando estamos fazendo qualquer atividade no computador como um documento de texto, jogando um game ou até mesmo declarando o imposto de renda é quase que imperceptivel para nós a capacidade desses aplicativos salvarem informações no computador para que no futuro possamos continuar o trabalho de onde paramos. Mas o que isso tem haver com serialização de objetos no Java?

Bem, quando estamos codificando em Java, nossa aplicação também poderá salvar e recuperar informações no computador. Essas informações salvas, são salvas como objetos e essas mesmas informações salvas podem ser recuperadas para uso posterior pelo nosso programa.

Basicamente a serialização de objetos nos permite salvar em arquivo objetos para que no futuro nossa aplicação recupere esse objeto a partir do arquivo ou até mesmo uma outra aplicação poderá recuperar tal objeto. Diversas linguagens trabalham com serialização de objetos. Em um post futuro, tentarei explicar como funciona a serialização de objetos no Ruby.

A serialização de objetos no Java é simples e utiliza uma interface de marcação que é a java.io.Serializable. Essa interface não possui nenhum método. Ela só serve para marcar a classe que poderá ser serializada. Quando Java internamente olhar para essa classe e ver que ela implementa a java.io.Serializable, ele saberá que essa classe é certa para a serialização.

A serialização é boa para alguns casos e ruins para outros. Em classes onde há senhas, dados confidenciais ou qualquer tipo de informação que deva ser protegida a serialização pode ser perigosa pois ela “externa” essas informações. Portanto deverá haver muito cuidado na hora de se decidir o que deve ser serializado ou não.

Nesse post mostrarei de forma bem simples e organizada como serializar o objeto para arquivo, recuperar esse objeto e exibir em console os atributos do objeto que salvamos.

Primeiramente vamos criar um objeto que iremos salvar. Eu criei uma JavaBean que representa um carro.

package com.meupost.beans;
 
import java.io.Serializable;
 
public class Carro implements Serializable {
 
	private String cor;
	private String nome;
	private String marca;
	private float valor;
 
	public String getCor() {
		return cor;
	}
 
	public void setCor(String cor) {
		this.cor = cor;
	}
 
	public String getNome() {
		return nome;
	}
 
	public void setNome(String nome) {
		this.nome = nome;
	}
 
	public String getMarca() {
		return marca;
	}
 
	public void setMarca(String marca) {
		this.marca = marca;
	}
 
	public float getValor() {
		return valor;
	}
 
	public void setValor(float valor) {
		this.valor = valor;
	}
}

Feita a nossa classe que irá ser serializada, iremos criar outra classe que será responsável por serializar o objeto da classe acima. Essa classe que iremos criar agora é a classe fundamental na serialização de objetos no Java. Vejam:

package com.meupost.serial;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
 
public class Serializar {
 
	/**
	* Esse método recebe um objeto arquivo e o objeto que será serializado. 
        * O método irá serializar o objeto passado no arquivo (referenciado pelo objeto file).
	*/
	public static void salvarObjeto(File file, Object objeto) throws FileNotFoundException,
 IOException {
 
		if (objeto == null) {
			throw new NullPointerException("Objeto passado é nulo");
		}
 
		FileOutputStream fileOut = null;
		ObjectOutputStream objOut = null;
 
		try {
			fileOut = new FileOutputStream(file);
			objOut = new ObjectOutputStream(fileOut);
			objOut.writeObject(objeto);
 
		} 
		catch (FileNotFoundException e) {
			throw new FileNotFoundException("O arquivo não pode ser encontrado");
		} 
		catch (IOException e) {
			throw new IOException("Erro de entrada e saída");
		}
		finally {
			if (fileOut != null) {
				fileOut.close();
			}
 
			if (objOut != null) {
				objOut.close();
			}
		}
 
	}
 
	/**
	* Para ler o objeto serializado, nós somente precisamos no arquivo onde 
        * esse objeto está salvado.
	* Sabendo o arquivo, nós conseguimos recuperar o objeto tranquilamente.
	*/
	public static Object recuperarObjeto(File file) throws FileNotFoundException, IOException,
ClassNotFoundException {
		Object obj = null;
 
		if (file == null) {
			throw new NullPointerException("Objeto FILE é Nulo.");
		}
 
		FileInputStream fileIn = null;
		ObjectInputStream objIn = null;
 
		try {
			fileIn = new FileInputStream(file);
			objIn = new ObjectInputStream(fileIn);
 
			obj = objIn.readObject();
		}
		catch (FileNotFoundException e) {
			throw new FileNotFoundException("Arquivo não encontrado");
		}
		catch (IOException e) {
			throw new IOException("Erro de entrada e saída");
		}
		catch (ClassNotFoundException e) {
			throw new ClassNotFoundException("Erro ao recuperar objeto do arquivo");
		}
		finally {
			if (fileIn != null) {
				fileIn.close();
			}
 
			if (objIn != null) {
				objIn.close();
			}
		}
 
		return obj;
	}
}

Com essa classe pronta, nós estamos apto a serializar o nosso objeto. Assim, vamos criar a classe Main para que nós possamos testar se nossa serialização irá funcionar o não. Na classe Main nós iremos instanciar alguns objetos Carro, colocaremos esses objetos em uma List e salvaremos essa List usando a nossa classe Serializar.

Depois de serializado, nós iremos recuperar essa List e iremos iremos percorrer essa lista mostrando os objetos que foram salvo. Eu criei um método que preenche a lista com objetos carro para ficar mais organizado.

package com.meupost.main;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import com.meupost.beans.Carro;
import com.meupost.serial.Serializar;
 
public class Main {
 
	/**
	* Na classe Main iremos testar nossa serialização. Vamos serializar uma lista
	* de objetos Carro.
	*/
	public static void main(String[] args) {
		String path = "C:\Documents and Settings\ricardo\Desktop\objeto.ser";
		File file = new File(path);
 
		try {
			List<Carro> lstCarros = preencherLista();
 
			Serializar.salvarObjeto(file, lstCarros);
			System.out.println("Objetos salvos com Sucesso!");
 
			List<Carro> novaLista =  (List) Serializar.recuperarObjeto(file);
			System.out.println("Objetos Recuperados com sucesso");
 
			Iterator<Carro> it = novaLista.iterator();
 
			while (it.hasNext()) {
				Carro car = (Carro) it.next();
				System.out.println("Nome: " + car.getNome());
				System.out.println("Marca: " + car.getMarca());
				System.out.println("Cor: " + car.getCor());
				System.out.println("Valor: " + car.getValor());
				System.out.println("==================================");
			}
 
		} 
		catch (FileNotFoundException e) {
			e.printStackTrace();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}
 
	/**
	* Cria e seta nosso objeto carro. Colocaremos esse objeto em uma lista. Tal lista,
	* contendo os objetos carro, irá ser serializada.
	*/
	public static List<Carro> preencherLista() {
		List<Carro> listaCarros = null;
 
		Carro carro1 = new Carro();
		carro1.setCor("Preto");
		carro1.setMarca("Ford");
		carro1.setNome("F-250");
		carro1.setValor(80000.50F);
 
		Carro carro2 = new Carro();
		carro2.setCor("Prata");
		carro2.setMarca("Chevrolet");
		carro2.setNome("Celta");
		carro2.setValor(26451.44F);
 
		Carro carro3 = new Carro();
		carro3.setCor("Vermelho");
		carro3.setMarca("Chevrolet");
		carro3.setNome("Corsa");
		carro3.setValor(38478.40F);
 
		Carro carro4 = new Carro();
		carro4.setCor("Amarelo");
		carro4.setMarca("Volkswagen");
		carro4.setNome("Fusca");
		carro4.setValor(2411.14F);
 
		listaCarros = new ArrayList<Carro>();
 
		listaCarros.add(carro1);
		listaCarros.add(carro2);
		listaCarros.add(carro3);
		listaCarros.add(carro4);
 
		return listaCarros;
	}
}

Feita a classe Main e verificado que não há nenhum erro de compilação, nós podemos executar nosso pequeno programa. Executando da forma que está postada aqui, a saída para console ficará assim:

Objetos salvos com Sucesso!
Objetos Recuperados com sucesso
Nome: F-250
Marca: Ford
Cor: Preto
Valor: 80000.5
=======================================
Nome: Celta
Marca: Chevrolet
Cor: Prata
Valor: 26451.44
=======================================
Nome: Corsa
Marca: Chevrolet
Cor: Vermelho
Valor: 38478.4
=======================================
Nome: Fusca
Marca: Volkswagen
Cor: Amarelo
Valor: 2411.14
=======================================

E isso pessoal, espero que tenha sido útil o tutorial e que tenham gostado. Se quiserem saber mais sobre serialização de objetos utilizando o Java, você pode achar nesses links:

http://en.wikipedia.org/wiki/Serialization#Java
http://java.sun.com/developer/technicalArticles/Programming/serialization/
http://www.deitel.com/articles/java_tutorials/20050923/IntroductionToObjectSerialization.html

arquivo, file, Java, objects, objetos, serializable, serializacao, Windows

Tocando arquivos MP3 com Java e JLayer

28/11/08

Escrito por RicardoSEP em Java

6 comentários

Uma das coisas que mais motivam nós programadores quando estamos aprendendo a programar ou que continuemos a estudar a linguagem a qual programamos é aprender sempre algo novo que a linguagem nos oferece. Claro que Java nos permite hoje fazer qualquer tipo de aplicação, porém o grande problema é que não sabemos como fazer o que queremos e a partir da aí buscamos cada vez mais o conhecimento que precisamos para fazer o que desejamos.

Recentemente descobri essa biblioteca chamada JLayer a qual nos permite tocar de forma muito fácil arquivos MP3 em nossos programas Java. Eu ainda não estudei essa biblioteca profundamente para ver tudo o que ela tem, porém hoje eu mostro como fazer o básico para tocar arquivos MP3 usando a Jlayer.

O tutorial é dividido em duas partes. A primeira parte (logo a seguir) ensina a tocar um arquivo mp3 em código Java de forma bem simples. Na segunda parte (que publicarei algum dia), ensinarei a tocar o arquivo mp3 usando threads e mostrando alguns outros recursos do JLayer.

Para fazer este tutorial, eu estou usando o seguinte ambiente de desenvolvimento:

JDK 1.6
JLayer 1.0.1
Eclipse 3.4 (Ganymede)
Ubuntu 8.10 (Intrepid Ibex)

A primeira coisa que devemos fazer é baixa a biblioteca JLayer. A biblioteca é grátis (LGPL) e você pode fazer o download dos binários e fontes aqui: http://www.javazoom.net/javalayer/javalayer.html

Depois de feito o download, descompacte o arquivo e copie o arquivo jl1.0.1.jar para a pasta lib de seu projeto. Copiado o jar, adicione a biblioteca ao classpath do projeto. Feito isso, vamos criar uma classe que será responsável por tocar nosso arquivo MP3. Eu chamei a classe de MP3 e ela ficou dessa forma:

package com.meupost.player;
 
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
 
import javazoom.jl.player.Player;
 
public class MP3 {
 
	/**
	 * Objeto para nosso arquivo MP3 a ser tocado
	 */
	private File mp3;
 
	/**
	 * Objeto Player da biblioteca jLayer. Ele tocará o arquivo
	 * MP3
	 */
	private Player player;
 
	/**
	 * Construtor que recebe o objeto File referenciando o arquivo
	 * MP3 a ser tocado e atribui ao atributo MP3 da classe.
	 * 
	 * @param mp3
	 */
	public MP3(File mp3) {
		this.mp3 = mp3;
	}
 
	/**
	 * Método que toca o MP3
	 */
	public void play() {
	    try {
                FileInputStream fis     = new FileInputStream(mp3);
                BufferedInputStream bis = new BufferedInputStream(fis);
                this.player = new Player(bis);
                System.out.println("Tocando!");
                this.player.play();
                System.out.println("Terminado!");
            }
            catch (Exception e) {
                System.out.println("Problema ao tocar " + mp3);
                e.printStackTrace();
            }
     }
}

A classe está comentada e explica o que significa os atributos e os métodos. No método play(), vemos que um objeto FileInputStream e BufferedInputStream são instanciados. O Player da biblioteca JLayer usa o BufferedInputStream para poder instanciar e deixar pronto o objeto Player, o qual nos permite enfim, tocar a música. O método play() do objeto Player é o responsável pela execução da música.

Note que como esse exemplo não é multithread, a música começará a tocar no momento da chamada do método play() e o fluxo de execução irá parar nesse método. O fluxo somente retornará quando a música terminar. Por fim, se ocorrer qualquer erro na execução da música, esteremos capturando a exceção e exibindo o stackTrace da mesma.

Terminada essa nossa classe MP3, vamos criar uma classe Main que instancia nossa classe MP3 e que permita nós testarmos a classe MP3 para ver se realmente funciona.

Eu criei uma classe Main assim:

package com.meupost.main;
 
import java.io.File;
 
import com.meupost.player.MP3;
 
public class Main {
 
	public static void main(String[] args) {
		//String com o caminho do arquivo MP3 a ser tocado
		String path = "/home/ricardo/Músicas/Rock Clássico/Eagles - Hotel California.mp3";
 
		//Instanciação de um objeto File com o arquivo MP3
		File mp3File = new File(path);
 
		//Instanciação do Objeto MP3, a qual criamos a classe.
		MP3 musica = new MP3(mp3File);
 
		//Finalmente a chamada do método que toca a música
		musica.play();
	}
}

As quatro linhas de código nela estão comentadas e falam o que é cada comando. Acredito que você já possa testar e ver se funciona. Mande um Play aí.

Espero que tenham gostado. É bem simples, mas muito legal. No próximo tutorial mostrarei como fazer um tocador mais complexo utilizando threads.

eclipse, Java, jlayer, Música, mp3

Como conectar o Java ao MySQL usando o NetBeans

25/11/08

Escrito por RicardoSEP em Java

27 comentários

Pessoal, resolvi fazer esse artigo ensinando como se conectar a uma base de dados MySQL usando o Java porque vi que é uma dificuldade muito comum entre as pessoas que estão iniciando em programação. Espero que esse artigo ajude a todos que estão com essa dificuldade a sanarem suas dúvidas,

Esse artigo parte do pressuposto de que quem for seguir esse tutorial tenha o JDK (Java Development Kit) instalado assim como o MySQL e o NetBeans. Caso você não tenha nenhum deles, você pode baixar e instalar a partir dos sites oficiais. Abaixo segue os sites de cada um deles:

Para esse tutorial eu estou usando o JDK6, MySQL 5.0 e o NetBeans 6.5 rodando tudo em cima do Ubuntu 8.10 Intrepid Ibex.

O NetBeans possui algumas “facilidades” de conexão a banco de dados bem ao estilo “Next > Next > Ok”. Porém o tutorial foi feito na maneira tradicional.

Após tudo instalado hora de começar a colocar a mão na massa. O Java para se conectar a qualquer banco de dados precisa de um driver de conexão, esse driver é chamado de JDBC (Java Database Connectivity). Sem um JDBC não é possível fazer uma conexão a um banco de dados. Cada banco de dados possui seu próprio JDBC. Por exemplo a Oracle fornece um JDBC para ser usado em bancos Oracle, o PostGRESQL também fornece um JDBC para ser usado com o PostGRESQL e assim vai. Não é diferente com o MySQL. O pessoal do MySQL também disponibilizou um JDBC para ser usado em conexão Java – MySQL.

Um pouquinho mais de informação sobre os drivers JDBC pode ser encontrado aqui na Wikipedia.

Como o MySQL também nos fornece um JDBC, vamos baixa-lo do site oficial do MySQL. Endereço do JDBC é: http://dev.mysql.com/downloads/. No menu, clique em Connectors e depois em Connector/J. Agora é só fazer o download do JDBC. Feito o download descompacte o arquivo.

Vai ser descompactado vários arquivos como instruções e documentações mas o arquivo que nos interessa é um que termina com extensão .JAR. Até a finalização desse artigo o nome do JDBC do MySQL é mysql-connector-java-5.1.7-bin.jar

Esse é o JDBC que irá nos conectar a uma base MySQL. Guarde a localização desse arquivo. Agora vamos criar um banco de exemplo com alguns dados.

Se conecte ao MySQL com sua ferramenta favorita ou pelo console mesmo. Para esse artigo eu criei um banco com uma tabela e três colunas. Tudo bem simples. Se quiser seguir esse exemplo abaixo vai os script SQL para a criação. Basta rodar no banco. Fique a vontade para fazer o esquema de banco a sua maneira, só lembre de mais para frente no artigo adaptar o seu esquema de banco ao código.

Script SQL:

CREATE TABLE IF NOT EXISTS 'usuarios' (
'nome' varchar(50) NOT NULL,
'email' varchar(50) NOT NULL,
'idade' int(11) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
 
INSERT INTO usuarios (nome, email, idade) VALUES
('Ricardo', 'ricardo@meuemail.com', 23),
('José', 'jose@seuemail.com', 29);

Beleza! Banco criado e alguns dados inseridos. Vamos para o NetBeans!

Abra a NetBeans e teremos uma tela inicial parecida com essa:

Vamos criar nosso projeto. Para isso faça:

Arquivo > Novo Projeto;
Escolha categoria: Java. Projeto: Aplicativo Java;
Clique em Próximo;
Coloque um nome para o projeto e clique em finalizar;

Próxima tela após clicar no botão Próximo. Aqui é onde definiremos o nome para o projeto e mais algumas configurações.

Nosso projeto foi criado.

Agora vamos adicionar o driver JDBC para que nossa aplicação consiga se conectar ao Banco de Dados. Para isso:

Clique com o botão direito em cima do Projeto > Propriedades.
Selecione a opção Bibliotecas e clique no botão Adicionar JARs/pasta.
Vá até o JDBC que baixamos do site do MySQL selecione o arquivo .jar
Clique em OK > OK

Pronto. O JDBC já foi adicionado a nossa aplicação. Agora vamos fazer um pouco de código

Nós iremos fazer toda a conexão com banco de dados direto da classe principal que o NetBeans nos forneceu. Logicamente essa metodologia não segue as melhores práticas da programação e todo o resto, mas serve para você ter uma idéia de pelo menos como conectar sua aplicação a uma base MySQL.

O código gerado pelo NetBeans está assim:

package mysqlconnection;
 
public class Main {
 
     public static void main(String[] args) {
          //Nosso código vai aqui
     }
}

Vamos criar a conexão e vamos fazer um select básico no banco. Abaixo segue o código com a conexão, com o envio do select e o tratamento de exceção. O código está comentado com o que cada linha está fazendo:

package mysqlconnection;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
public class Main {
 
     public static void main(String[] args) {
           String driver = "com.mysql.jdbc.Driver"; //Classe do driver JDBC
           String banco = "MeuBD"; //Nome do Banco criado
           String host = "localhost"; //Maquina onde está o banco
           String str_conn = "jdbc:mysql://" + host + ":3306/" + banco; //URL de conexão
           String usuario = "root"; //Usuário do banco
           String senha = ""; //Senha de conexão
 
           try {
               Class.forName(driver); //Carrega o driver
 
               //Obtém a conexão com o banco
               Connection conn = DriverManager.getConnection(str_conn, usuario, senha);
 
               //Cria um statement para podermos mandar um SQL para o banco
               Statement stmt = conn.createStatement();
 
               //Mandamos o SQL para o banco e obtemos um ResultSet
               String sql = "SELECT * FROM usuarios";
               ResultSet rs = stmt.executeQuery(sql);
 
               //Percorrendo o ResultSet e obtendo os valores do banco
              while (rs.next()) {
                    System.out.println(rs.getString("nome"));
                    System.out.println(rs.getString("email"));
                    System.out.println(rs.getInt("idade"));
                    System.out.println("====================================");
             }
        } 
        catch (ClassNotFoundException ex) {
             System.out.println("Não foi possível carregar o driver.");
             ex.printStackTrace();
        }
        catch (SQLException ex) {
             System.out.println("Problema com o SQL");
             ex.printStackTrace();
       }
    }
}

Repare que na obtenção dos objetos a partir do ResultSet nós usamos como chave o nome da coluna no banco de dados.

Se estiver tudo certo, já podemos executar nosso código. Para isso faça aperta F6 ou clique no “Play”. Se tudo deu certo e se você utilizou o esquema de banco fornecido nesse post, a saída para console será assim:

run:
Ricardo
ricardo@meuemail.com
23
====================================
José
jose@seuemail.com
29
====================================
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)

Bacana hein?!

É isso pessoal, fizemos uma conexão bem simples a uma base de dados MySQL usando Java e JDBC. Espero que tenham gostado do artigo e até a próxima!

developer, j2se, Java, jdbc, mysql, NetBeans, Programação, programming

Dica rápida: Instalando o NetBeans no Ubuntu

23/11/08

Escrito por RicardoSEP em Java

Nenhum comentário

Essa é uma dica rápida para quem quer instalar o NetBeans no Ubuntu.

Antes de começar a fazer a instalação, certifique-se que você tenha o Java instalado em sua máquina. Para fazer esse teste é simples abra o Terminal e digite:

java -version

Deverá ser exibida a versão do Java que você tem instalado. Se não aparecer a versão do Java, provavelmente você não tem o Java instalado em sua máquina. Precisaremos instalar. Para isso faça o seguinte, no console novamente digite:

sudo apt-get install sun-java6-jre sun-java6-plugin sun-java6-fonts

Depois de instalado, tente novamente executar o comando:

java -version

Uma saída parecida com essa deverá aparecer:

java version "1.6.0_10"
Java(TM) SE Runtime Environment (build 1.6.0_10-b33)
Java HotSpot(TM) Server VM (build 11.0-b15, mixed mode)

Feito isso, teremos o Java instalado e podemos então instalar o NetBeans. Baixe a última versão para Linux do NetBeans em http://www.netbeans.org/. Até a publicação desse post, o NetBeans está na versão 6.5 e o nome do arquivo baixado é netbeans-6.5-ml-linux.sh

Depois de baixado, abra o terminal e vá na pasta onde você baixou o NetBeans (geralmente é no Desktop) e execute o seguinte comando:

sudo sh netbeans-6.5-ml-linux.sh

Pronto. Agora toda instalação será via GUI (igual no Windows), basta ir cliando em avançar, customizar sua instalação e pronto. O instalador do NetBeans irá criar um menu para o programa em Aplicativos > Desenvolvimento > NetBeans IDE 6.5. Isso se seu ambiente for Gnome.

Até a próxima!

desenvolvimento, eclipse, IDE, Java, Linux, NetBeans, ubuntu

Fatorial recursivo em Java e Ruby

18/11/08

Escrito por RicardoSEP em Java

4 comentários

Muita gente que está começando com programação procura sobre recursividade e exemplos de recursividade. Acredito que o exemplo mais clássico da demonstração da recursividade seja o cálculo do fatorial de um número inteiro N.

Primeiramente o que é recursividade?

A recursividade, em programação, é capacidade de uma função (ou método) poder chamar ela mesma.

Vendo o exemplo de cálculo fatorial talvez clarifique as idéias. Abaixo está dois exemplos de cálculo de fatorial utilizando a recursividade. Os dois exemplos fazem exatamente a mesma coisa, calcula o fatorial de um número. A única diferença entre os dois é que um está escrito em Ruby e o outro em Java.

Java:

package com.meupost.exemplo;
 
public class Fatorial {
 
	public static long fatorial(long number) {
		if (number == 0) {
			return 1;
		}
 
		return number * fatorial(number - 1);
	}
 
	public static void main(String[] args) {
		System.out.println(Fatorial.fatorial(5));
 
	}
}

Ruby:

def fatorial(number)
  if (number == 0)
    return 1
  else
    return number * fatorial(number - 1)
  end
end
 
puts fatorial(5)

Em ambos os casos a saída será 120 pois 5! = 120.

Sobre como se calcula um fatorial veja aqui.

Para mais informações sobre recursividade veja aqui.

Java, Programação, programming, recursividade, Ruby

Comparação de desempenho entre linguagens de programação

27/07/08

Escrito por RicardoSEP em Programação

2 comentários

No dia 08/07/2008 o blog var/log/mind publicou uma comparação de desempenho entre algumas linguagens de programação. As linguagens testadas pelo blog foram C++, JAVA, Ruby, JRuby, Python, Jython, Groovy e PHP. Esse tema gerou até um bafafá na blogosfera nacional e internacional.

A tipo de benchmark feito pelo é blog foi bem simples e baseado em um pedaço de lógica onde é medido o tempo de cada iteração num total de 100000 iterações.

O mais espantoso foi que JAVA obteve um desempenho melhor do que C++. Esse resultado me deixou com uma pulga atrás da orelha porque sempre acreditei (mas nunca havia testado) de que C++ por ser somente compilado seria bem mais rápido do que JAVA que é compilado e interpretado pela JVM.

Então resolvi fazer o mesmo teste que o blog var/log/mind fez. Utilizei os mesmos códigos disponibilizados por ele e rodei eles em minha máquina. Somente não testei Python, Jython e o Groovy.

Ambiente de Testes

Meu ambiente de testes difere do ambiente de testes do var/log/mind (veja a tabela mais abaixo), assim como versões de compiladores e interpretadores. Abaixo segue o meu ambiente de testes e mais um pouco abaixo as versões dos compiladores e interpretadores usados no teste.

Meu ambiente:

Processador: AMD 4200+ X2 64 Bits
Memória: 3GB RAM
SO: Windows XP SP2 Professional

As diferenças entre o ambiente de teste original do var/log/mind e o meu ambiente de teste:

	MeuPost.com	var/log/mind
Processador	AMD 4200+ X2 64 Bits	Intel® Core™ Duo CPU T2600 @ 2.16GHz
Memória	3GB RAM	2GB
SO:	Windows XP SP2 Professional	Ubuntu Gutsy Gibbon 7.10

Compiladores e Interpretadores usados:

C++: MinGW32 GCC: 3.4.2
JAVA 1.6
Ruby 1.8.6-26
JRuby 1.1
PHP 5.2.3

Teste:

Para realizar o teste rodei 5 vezes o código de cada linguagem diferente e anotei todos os resultados em nanossegundos. Depois tirei a média dos resultados.

Resultados

Seguinte a tendência dos resultados, em meu ambiente JAVA também foi superior ao C++. Os resultados também mostraram que o Python está mais maduro que Ruby embora nas últimas versões do Ruby (1.9) o desempenho tenha melhorado muito.

Outro fato interessante é que o JRuby está também mais rápido que Ruby. Já o PHP mostra a força de sua maturidade e popularidade ganhando tanto do Ruby como do JRuby, isso em meu ambiente, porque no var/log/mind tanto o Ruby como o JRuby ganharam do PHP.

Acredito que esse desempenho superior do Ruby no var/log/mind está diretamente associado ao sistema operacional. O Ruby está rodando muito mais rápido em ambientes Linux do que em Windows.

Abaixo segue a tabela de resultados:

	Iteração 1	Iteração 2	Iteração 3	Iteração 4	Iteração 5	Média	Total
C++	12000	12000	12000	12000	12000	12000	60000
Java	1509	1369	1384	1376	1385	1404,6	7023
Ruby	491990	493750	494690	493280	494840	444232	2468550
Jruby	244040	246360	243830	243450	246750	244886	1224430
PHP	125200	125030	124880	124890	124900	124980	624900

1 segundo = 1000000 microssegundo = 1000000000 nanossegundo

Para facilitar a visualização dos resultados, abaixo segue um gráfico com o resultado do teste:

Códigos

Abaixo segue os códigos utilizados nos testes. São os mesmos do var/log/mind com uma única diferença no código C++. Como o var/log/mind usou o Linux, ele usou a função gettimeofday(), em Windows essa função não existe, então eu como não sou um programador C++, achei essa função no Blog OpenAsthra e coloquei no código.

Todos os outros códigos são exatamente iguais.

C++

#include &lt;time.h&gt;
#include &lt;windows.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;sys/time.h&gt;
 
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
  #define DELTA_EPOCH_IN_MICROSECS  11644473600000000Ui64
#else
  #define DELTA_EPOCH_IN_MICROSECS  11644473600000000ULL
#endif
 
struct timezone 
{
  int  tz_minuteswest; /* minutes W of Greenwich */
  int  tz_dsttime;     /* type of dst correction */
};
 
int gettimeofday(struct timeval *tv, struct timezone *tz)
{
  FILETIME ft;
  unsigned __int64 tmpres = 0;
  static int tzflag = 0;
 
  if (NULL != tv)
  {
    GetSystemTimeAsFileTime(&amp;ft);
 
    tmpres |= ft.dwHighDateTime;
    tmpres &lt;&lt;= 32;
    tmpres |= ft.dwLowDateTime;
 
    tmpres /= 10;  /*convert into microseconds*/
    /*converting file time to unix epoch*/
    tmpres -= DELTA_EPOCH_IN_MICROSECS; 
    tv-&gt;tv_sec = (long)(tmpres / 1000000UL);
    tv-&gt;tv_usec = (long)(tmpres % 1000000UL);
  }
 
  if (NULL != tz)
  {
    if (!tzflag)
    {
      _tzset();
      tzflag++;
    }
    tz-&gt;tz_minuteswest = _timezone / 60;
    tz-&gt;tz_dsttime = _daylight;
  }
 
  return 0;
}
 
#define TEST
#ifdef TEST
#endif
 
class Person
{
 
    public:
 
        Person(int count) : _next(NULL), _prev(NULL) { _count = count; }
        int shout(int shout, int nth)
        {
            if (shout &lt; nth) return (shout + 1);
            _prev-&gt;_next = _next;
 
            _next-&gt;_prev = _prev;
            return 1;
        }
        int count() { return _count; }
        Person* next() { return _next; }
        void next(Person* person) { this-&gt;_next = person ; }
        Person* prev() { return _prev; }
        void prev(Person* person) { this-&gt;_prev = person; }
    private:
        int _count;
        Person* _next;
        Person* _prev;
};
 
class Chain
{
    public:
        Chain(int size) : _first(NULL)
        {
            Person* current = NULL;
            Person* last = NULL;
            for(int i = 0 ; i &lt; size ; i++)
            {
                current = new Person(i);
                if (_first == NULL) _first = current;
                if (last != NULL)
                {
                    last-&gt;next(current);
                    current-&gt;prev(last);
                }
                last = current;
            }
            _first-&gt;prev(last);
            last-&gt;next(_first);
        }
        Person* kill(int nth)
        {
            Person* current = _first;
            int shout = 1;
            while(current-&gt;next() != current)
            {
                Person* tmp = current;
                shout = current-&gt;shout(shout,nth);
                current = current-&gt;next();
                if (shout == 1)
                {
                    delete tmp;
                }
            }
            _first = current;
            return current;
        }
        Person* first() { return _first; }
    private:
        Person* _first;
};
 
int main(int argc, char** argv)
{
    int ITER = 100000;
    Chain* chain;
    struct timeval start, end;
    gettimeofday(&amp;start,NULL);
    for(int i = 0 ; i &lt; ITER ; i++)
    {
        chain = new Chain(40);
        chain-&gt;kill(3);
        delete chain;
    }
    gettimeofday(&amp;end,NULL);
    fprintf(stdout,"Time per iteration = %d microsecondsnr", (((end.tv_sec - start.tv_sec) * 1000000) + (end.tv_usec - start.tv_usec)) / ITER);
    //fprintf(stdout,"Last man standing is %dnr", (chain-&gt;first()-&gt;count() + 1));
    return 0;
}
 
}

JAVA:

package com.dnene.josephus;
 
public class Chain {
 
	private Person first = null;
 
	public Chain(int size) {
		Person last = null;
		Person current = null;
 
		for (int i = 0; i &lt; size; i++) {
			current = new Person(i);
 
			if (first == null)
				first = current;
 
			if (last != null) {
				last.setNext(current);
				current.setPrev(last);
			}
 
			last = current;
		}
 
		first.setPrev(last);
		last.setNext(first);
	}
 
	public Person kill(int nth) {
		Person current = first;
		int shout = 1;
 
		while (current.getNext() != current) {
			shout = current.shout(shout, nth);
			current = current.getNext();
		}
 
		first = current;
 
		return current;
	}
 
	public Person getFirst() {
		return first;
	}
 
	public static void main(String[] args) {
 
		int ITER = 100000;
		long start = System.nanoTime();
 
		for (int i = 0; i &lt; ITER; i++) {
			Chain chain = new Chain(40);
			chain.kill(3);
		}
 
		long end = System.nanoTime();
 
		System.out.println("Time per iteration = " + ((end - start) / (ITER))
				+ " nanoseconds.");
	}
}
 
package com.dnene.josephus;
 
public class Person {
 
	int count;
	private Person prev = null;
	private Person next = null;
 
	public Person(int count) {
		this.count = count;
	}
 
	public int shout(int shout, int deadif) {
		if (shout &lt; deadif)
			return (shout + 1);
 
		this.getPrev().setNext(this.getNext());
		this.getNext().setPrev(this.getPrev());
 
		return 1;
	}
 
	public int getCount() {
		return this.count;
	}
 
	public Person getPrev() {
		return prev;
	}
 
	public void setPrev(Person prev) {
		this.prev = prev;
	}
 
	public Person getNext() {
		return next;
	}
 
	public void setNext(Person next) {
		this.next = next;
	}
}

Ruby / JRuby

class Person
    attr_reader :count, :prev, :next
    attr_writer :count, :prev, :next
 
    def initialize(count)
        #puts 'Initializing person : ' + count.to_s()
        @count = count
        @prev = nil
        @next = nil
    end
 
    def shout(shout, deadif)
        if shout &lt; deadif
            return shout + 1
        end
        @prev.next = @next
        @next.prev = @prev
        return 1
    end
end      
 
class Chain
    attr_reader :first
    attr_writer :first
 
    def initialize(size)
        @first = nil
        last = nil
        for i in (1..size)
            current = Person.new(i)
            if @first == nil
                @first = current
            end
            if last != nil
                last.next = current
                current.prev = last
            end
            last = current
        end
        @first.prev = last
        last.next = @first
    end
 
    def kill(nth)
        current = @first
        shout = 1
        while current.next != current
            shout = current.shout(shout,nth)
            current = current.next
        end
        @first = current
        return current
    end
end
 
ITER=100000
start = Time.now
ITER.times { |i|
chain = Chain.new(40)
chain.kill(3)
}
ends = Time.now
puts 'Time per iteration = ' + ((ends - start) * 1000000 / ITER).to_s() + " microseconds"

PHP

&lt;?php
class Person
{   
    function __construct($c)
    {   
        $this-&gt;count = $c;
    }       
 
    function getPrev()
    {       
        return $this-&gt;prev; 
    }           
 
    function setPrev($pr)
    {   
        $this-&gt;prev = $pr;
    }   
 
    function getNext()
    {
        return $this-&gt;next;
    }
 
    function setNext($nxt)
    {
        $this-&gt;next = $nxt;
    }
 
    function shout($shout, $nth)
    {
        if ($shout &lt; $nth)
        {
            return $shout + 1;
        }
        $this-&gt;getPrev()-&gt;setNext($this-&gt;getNext());
        $this-&gt;getNext()-&gt;setPrev($this-&gt;getPrev());
        return 1;
    }
}
 
class Chain
{
    var $first;
 
    function __construct($size)
    {
        for($i = 0; $i &lt; $size ; $i++)
        {
            $current = new Person($i);
            if ($this-&gt;first == null) $this-&gt;first = $current;
            if ($last != null)
            {
                $last-&gt;setNext($current);
                $current-&gt;setPrev($last);
            }
            $last = $current;
        }
        $this-&gt;first-&gt;setPrev($last);
        $last-&gt;setNext($this-&gt;first);
    }
 
    function kill($nth)
    {
        $current = $this-&gt;first;
        $shout = 1;
        while($current-&gt;getNext() !== $current)
        {
            $shout =  $current-&gt;shout($shout,$nth);
            $current = $current-&gt;getNext();
        }
        $this-&gt;first = $current;
    }
}
 
$start = microtime(true);
$ITER = 100000;
for($i = 0 ; $i &lt; $ITER ; $i++)
{
    $chain = new Chain(40);
    $chain-&gt;kill(3);
}
$end = microtime(true);
printf("Time per iteration = %3.2f microsecondsnr",(($end -  $start) * 100000 / $ITER));
?&gt;

É isso pessoal.

Esse tema de desempenho sempre gera polêmica pois sempre há brechas e margens para discussão. Então, quem quiser debater sobre o assunto.

Até a próxima.

C++, comparativo, desempenho, Java, JRuby, performance, PHP, Ruby

Dica rápida: Formatando um número para moeda em Java

14/07/08

Escrito por RicardoSEP em Java

Nenhum comentário

Dica rápida em bem simples para nossos leitores. Para formatarmos um número em formato de moeda usando Java, basta fazermos:

import java.text.NumberFormat;
 
public class Main {
 
	public static void main(String[] args) {
		//Gera um número aleatório
		double pagamento = Math.random() * 10000;
		NumberFormat nf = NumberFormat.getCurrencyInstance();
		System.out.println("Seu pagamento é " + nf.format(pagamento));
	}
}

Saída:

Seu pagamento é R$ 7.722,51

No código acima não usamos o objeto Locale no método getCurrencyInstance(). Isso quer dizer que o Java busca no SO a formatação de moeda. Se você quiser setar uma formatação de moeda diferente, então você pode usar o objeto Locale da seguinte forma:

import java.text.NumberFormat;
import java.util.Locale;
 
public class Main {
 
	public static void main(String[] args) {
		//Gera um número aleatório
		double pagamento = Math.random() * 10000;
		NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US);
		System.out.println("Seu pagamento é " + nf.format(pagamento));
	}
}

Saída:

Seu pagamento é $4,337.63

O Locale.US indica que queremos a formatação de moeda para o dólar americano.

E isso é tudo pessoal. Até a próxima!

casas decimais, formatação, j2se, Java, moeda, Programação

Como obter informações do sistema operacional usando Java

11/07/08

Escrito por RicardoSEP em Java

1 comentário

Essa é uma dica rápida para quem programa Java e precisa saber de algumas informações do sistema operacional ou do próprio Java em que a aplicação está rodando. Dependendo dessas informações, podemos tomar decisões em código específicas para um determinado sistema.

Para fazer isso, o Java nos fornece o método getProperty(String key) da classe System.

O parâmetro key é uma string que fornecemos ao método para que ele nos retorne as informação que desejamos, como nome do sistema operacional, versão do java…

Vamos ao exemplo:

package com.meupost.main;
 
public class Main {
 
	public static void main(String[] args) {
 
		String vendor = System.getProperty("java.vendor");
		String osName = System.getProperty("os.name");
		String separadorArquivo = System.getProperty("file.separator");
 
		System.out.println("Java Vendor: " + vendor);
		System.out.println("Sistem Operacional: " + osName);
		System.out.println("Separador de Arquivos: " + separadorArquivo);
 
	}
}

No trecho de código acima é atribuído nas Strings informações como o vendor, o nome do sistema operacional e o caractere que o sistema operacional usa para separar os arquivos. Se o código acima fosse executado em Windows XP, o resultado seria:

Java Vendor: Sun Microsystems Inc.
Sistema Operacional: Windows XP
Separador de Arquivos:

Se fosse executado em Linux:

Java Vendor: Sun Microsystems Inc.
Sistema Operacional: Linux
Separador de Arquivos: /

Abaixo segue uma lista com as chaves que podem ser passadas como parâmetro no método getProperty().

Key	Description of Associated Value
java.version	Java Runtime Environment version
java.vendor	Java Runtime Environment vendor
java.vendor.url	Java vendor URL
java.home	Java installation directory
java.vm.specification.version	Java Virtual Machine specification version
java.vm.specification.vendor	Java Virtual Machine specification vendor
java.vm.specification.name	Java Virtual Machine specification name
java.vm.version	Java Virtual Machine implementation version
java.vm.vendor	Java Virtual Machine implementation vendor
java.vm.name	Java Virtual Machine implementation name
java.specification.version	Java Runtime Environment specification version
java.specification.vendor	Java Runtime Environment specification vendor
java.specification.name	Java Runtime Environment specification name
java.class.version	Java class format version number
java.class.path	Java class path
java.library.path	List of paths to search when loading libraries
java.io.tmpdir	Default temp file path
java.compiler	Name of JIT compiler to use
java.ext.dirs	Path of extension directory or directories
os.name	Operating system name
os.arch	Operating system architecture
os.version	Operating system version
file.separator	File separator (“/” on UNIX)
path.separator	Path separator (“:” on UNIX)
line.separator	Line separator (“n” on UNIX)
user.name	User’s account name
user.home	User’s home directory
user.dir	User’s current working directory

j2se, Java, Linux, Mac, Programação, Sistemas Operacionais, Windows

Publicidade

<a href='http://openx.sopalmeiras.com/www/delivery/ck.php?n=a763ff2d&cb=INSERT_RANDOM_NUMBER_HERE' target='_blank'><img src='http://openx.sopalmeiras.com/www/delivery/avw.php?zoneid=9&cb=INSERT_RANDOM_NUMBER_HERE&n=a763ff2d' border='0' alt='' /></a>
Nuvem
blog Blogs Cinema developer Dicas eclipse email flash flickr game Geral Gmail Google Humor IDE Internet j2se Java jogo Jogos Jogos Flash JRuby Linux Mac metal metallica Microsoft Música Open-Source OpenOffice opensource Programação rails Ruby Ruby e Rails sexta show Sistemas Operacionais speedy tutorial ubuntu video Web 2.0 Windows wordpress
Tópicos Recentes
Comentários
- Altair de Almeida Costa em Canto gregoriano! Fantástico.
- anonimo em Como conectar o Java ao MySQL usando o NetBeans
- Jhonatan em Problema do Rails 2.2.2 com o MySQL em Windows
- Ricardo em Fatorial recursivo em Java e Ruby
- tao simples ! em Como conectar o Java ao MySQL usando o NetBeans
Links Recomendados
Publicidade

<a href='http://openx.sopalmeiras.com/www/delivery/ck.php?n=adc0724d&cb=INSERT_RANDOM_NUMBER_HERE' target='_blank'><img src='http://openx.sopalmeiras.com/www/delivery/avw.php?zoneid=10&cb=INSERT_RANDOM_NUMBER_HERE&n=adc0724d' border='0' alt='' /></a>
Meus tweets
- Se fuderam. E eu gostei! http://tr.im/RBhF 04:48:17 PM março 12, 2010 from DestroyTwitter
- Isso aqui é no Shopping Dom Pedro ou não? Parece bem o shopping D. Pedro. http://tr.im/RkOM 05:33:22 PM março 10, 2010 from DestroyTwitter
- Fuiiiiiii! 05:02:26 AM março 08, 2010 from TweetDeck
- Vou indo nessa! Aanhã é acordar cedo.... Avatar continua chupando! #ChupaAvatar 05:01:36 AM março 08, 2010 from TweetDeck
- Avatar MODINHA se Fu! É isso que da só fazer um filme cheio de clichês, sem conteúdo e só com efeitos especiais! 05:00:44 AM março 08, 2010 from TweetDeck
- Guerra ao Terror ganhou!!!! Ganhou!!! Chupa ao AVATAR! 04:59:28 AM março 08, 2010 from TweetDeck
- CHupa Avatar!!!!!!!!!!!!!!! 04:59:02 AM março 08, 2010 from TweetDeck
- AOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO!!!!!!! 04:58:54 AM março 08, 2010 from TweetDeck
- Tom Hanks! Assisti Forrest ump pea 365365 vez nesse FDS. hahahahahahha 04:58:39 AM março 08, 2010 from TweetDeck
- Mais um para Hurt Locker! Guerra ao Terror! CHUPA AVATAR! Pena não ter sido o Tarantino! 04:55:30 AM março 08, 2010 from TweetDeck

Artigos com o marcador Java

Ambiente de Testes

Teste:

Resultados

Códigos

Publicidade

Nuvem

Tópicos Recentes

Comentários

Links Recomendados

Publicidade