Trabalhando com Arquivos UTF-8 em Java Resumo: Este artigo descreve um método seguro para realizar a leitura e gravação de arquivos texto com encoding UTF-8 em java.

1. Introdução

Definimos encoding como uma técnica que define as regras para armazenar os códigos dos caracteres em memória (esses códigos são denominados code points no jargão Unicode). Na prática, existem vários encodings diferentes: UTF-8, ISO-8859-1 (apelidado de Latin-1), UCS-2, Windows-1252, etc. Cada um deles utiliza um algoritmo distinto para fazer a representação dos códigos Unicode.

UTF-8 diferencia-se da maioria dos outros encodings pelo fato de ser completo. Isto é: ele é capaz de armazenar qualquer caractere Unicode. Outros encodings, como ISO-8859-1 e Windows-1252, preferem trabalhar apenas com um subconjunto da tabela Unicode (ex: apenas com caracteres das linguagens ocidentais). A grande maioria dos softwares comerciais e open source (SGBD’s, por exemplo) prefere trabalhar internamente com o formato UTF-8, pois este encoding favorece a questão da internacionalização do produto. Pelo mesmo motivo, as linguagens padrão para troca de informações XML e JSON normalmente trabalham com a codificação UTF-8. Aliás, já existem vários arquivos e bases de dados de domínio público codificadas em UTF-8 na Internet.

Sendo assim, mais cedo ou mais tarde chegará a hora em que precisaremos trabalhar com arquivos UTF-8 (não há como fugir!!!). Neste artigo apresentaremos uma receita segura para trabalhar com UTF-8 na linguagem Java, tanto na leitura como na gravação de arquivos.

2. Java x UTF-8: O Problema

Na linguagem Java, as classes mais utilizadas para leitura e gravação de arquivos são java.io.FileReader e java.io.FileWriter, respectivamente. Essa situação é bastante justificável, uma vez que trabalhar com essas classes é muito simples na prática. No entanto, existe um problema importante associado a estas classes que precisa ser conhecido por todo desenvolvedor Java. O que ocorre é que, por default, ambas não usam UTF-8. Mas que problema isso pode causar? Muitos! Basicamente, se você tiver que trabalhar com um arquivo texto UTF-8 que possuir qualquer caractere que não seja padrão ASCII (ex: letras acentuadas, cedilha, etc.), o caractere em questão não será lido em nem gravado corretamente.

Demonstraremos isso com um exemplo. Considere o arquivo texto “poema.txt”, apresentado na figura 1. Este arquivo foi criado utilizando a codificação UTF-8 (veja o círculo em vermelho na figura).

Figura 1: Arquivo texto com encoding UTF-8

O exemplo da listagem 1 mostra um pequeno programa onde a classe “FileReader” é usada para realizar a leitura do arquivo texto.

Listagem 1: Programa que não funciona com arquivos UTF-8

/**
 * Esta classe lê o arquivo "poema.txt" usando a classe java.io.FileReader. 
 * O programa não trabalha com UTF-8 de forma correta
 *
 */

import java.io.BufferedReader;
import java.io.FileReader;

public class LeituraFileReader {

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

		// abertura do arquivo
		FileReader arq = new FileRea

...

1. Introdução

Imagine três objetos que chamaremos de ‘A’, ‘B’ e ‘C’. A seguir, relacionamos todas as possíveis maneiras para dispor esses objetos. Em outras palavras, apresentamos todas as formas de permutar os objetos:

• ‘A’, ‘B’ e ‘C’
• ‘A’, ‘C’ e ‘B’
• ‘B’, ‘A’ e ‘C’
• ‘B’, ‘C’ e ‘A’
• ‘C’, ‘A’ e ‘B’
• ‘C’, ‘B’ e ‘A’

Quando estamos desenvolvendo um sistema, é muito comum que nos deparemos com situações práticas em que precisaremos lidar com permutações. Por exemplo: sistemas que lidam com otimização de recursos, normalmente necessitam trabalhar com testes envolvendo permutações para determinar a forma menos custosa de realizar um conjunto de n tarefas.

Neste artigo apresentamos um algoritmo recursivo em Java para implementar a permutação de objetos. O artigo está dividido em duas partes. Na primeira introduzimos um algoritmo básico capaz de gerar e apresentar todas as permutações de n objetos sem repetição. Na segunda mostramos como modificar este algoritmo para que ele possa realizar permutações com repetição de objetos.

2. Permutações sem Repetição: um Algoritmo Recursivo

Antes de entramos no algoritmo propriamente dito, vamos abordar a questão do número total de permutações de n objetos. Este número é dado por P(n) = n!. Ou seja: para 3 objetos (como no caso do exemplo apresentado na introdução do artigo), P(3) = 3! = 3 x 2 x 1 = 6 permutações. Para 4 objetos temos: P(4) = 4! = 4 x 3 x 2 x 1 = 24 permutações. Para 10 objetos, o total já chega à casa dos milhões: P(10) = 10! = 3.628.800. Veja que um pequeno aumento no número de objetos resulta em um grande crescimento no total de permutações.

O recurso básico para a elaboração do algoritmo consiste na montagem de uma árvore de recursão mostrando uma “instância” de solução para o problema. Um exemplo é mostrado na figura 1, onde apresenta-se a árvore de recursão considerando a permutação de 3 objetos.

Figura 1: Árvore de recursão da solução do problema das permutações de 3 objetos

A árvore de recursão nos deixa claro que permutar n elementos é uma atividade similar a colocá-los dentro de n gavetas (este é o exemplo típico apresentado nos livros de Probabilidade e Estatística). Se temos 3 objetos e colocamos o objeto ‘A’ na primeira gaveta, então existem duas opções para a segunda gaveta: ‘B’ ou ‘C’. Se ‘B’ for colocado na segunda gaveta, então sobrará apenas a terceira gaveta para ‘C’. E por aí vai! Cada caminho na árvore de recursão corresponde a uma diferente permutação e no exemplo da figura 1 existem 6 caminhos, pois sabemos que P(3) = 6.

A listagem 1 mostra o código Java com a definição da classe “Permutacoes”. Esta classe possui um método público estático chamado “permuta” que recebe um vetor de char como entrada e apresenta todas as formas de permutar os objetos desse vetor.

Listagem 1: Classe “Per

...

1. Introdução

Na linguagem Java, um mapa (map) é um objeto que associa (ou “mapeia”) chaves com valores. Cada chave é sempre associada a, no máximo, um valor e não podem existir chaves duplicadas. A Figura 1 mostra um exemplo em que as chaves são nomes de pessoas e os valores são os números de telefone das mesmas.

Figura 1: Mapa associando nomes (chave) e telefones (valor)

Existem inúmeras aplicações práticas para os mapas. Este artigo apresenta uma das mais interessantes: usar este tipo de objeto com o objetivo de descobrir as palavras presentes em um determinado arquivo texto e computar as suas frequências (número de ocorrência de cada uma delas).

2. Computando as Frequências

A Listagem 1 apresenta o programa Java que utiliza um objeto do tipo java.util.HashMap para realizar a contagem de frequência de palavras. A explicação sobre o funcionamento do programa é apresentada através de comentários colocados dentro do código e em explicações adicionais apresentadas na parte final deste artigo.

Listagem 1: Classe “ContaPalavras”

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * classe ContaPalavras - recebe como entrada um arquivo texto, identifica as
 * diferentes palavras e contabiliza as frequências.
 * 
 * uso: java ContaPalavras arquivo_texto
 * 
 * @author Eduardo Correa
 * 
 */
public class ContaPalavras {

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

	//-------------------------------------------------------
	// (0) declaração/inicialização de variáveis
	//-------------------------------------------------------
		
	String curLine; //recebe cada linha lida do arquivo texto
		
	Map<String,Integer> mapPalavras; //mapa: Palavra -> Frequencia  
						//usado para contabilizar as 
						//frequencias das palavras
		
	mapPalavras = new HashMap<String,Integer>();
		
		
	//-------------------------------------------------------
	// (1) abre o arquivo texto
	//-------------------------------------------------------
		
	//(1.1) testa se nome do arq. texto foi passado na chamada do programa
        if (args.length != 1) {
            System.err.println("ERRO: eh preciso especificar o nome do arquivo");
            System.err.println("Uso: java ContaPalavras arquivo_texto");
            System.exit(1);
        }

	//(1.2) abre o arquivo
        FileReader txtFile = new FileReader(args[0]);
        BufferedReader txtBuffer = new BufferedReader(txtFile);

	//-------------------------------------------------------
	// (2) loop que processa cada linha do arquivo texto
	//-------------------------------------------------------

        //(2.1) pega a primeira linha do arquivo
        curLine = txtBuffer.readLine();
      
        
        while (curLine != null) {
        	
    		//-------------------------------------------------------
        	//(2.2) quebra a linha em tokens (palavras) utilizando 
        	//      expressão 

...

1. Introdução

Quando um programa responsável por checar a ortografia de um documento encontra uma palavra que não faz parte de seu dicionário, esta é apontada como um possível erro ortográfico. Adicionalmente, o programa apresentará uma lista de sugestões, ou seja, uma relação de palavras que sejam próximas (ou similares) à palavra errada. A lista de sugestões é normalmente precedida por aquela famosa frase: “você não quis dizer... ?”.

Mas qual o critério utilizado para selecionar as palavras próximas? Qual a noção empregada para computar o quanto duas palavras são similares? A resposta está no conceito de distância de edição. Este artigo explica o conceito e apresenta exemplos de utilização na linguagem PHP.

2. Distância de Edição

A distância de edição é uma medida que compara duas strings, digamos str1 e str2, e retorna o número mínimo de caracteres que precisam ser modificados, inseridos ou excluídos para transformar str1 em str2. A ideia é que se duas strings possuem um valor baixo para a distância de edição então podemos considerá-las similares, já que transformar uma na outra requer um número baixo de operações.

Para que o conceito fique mais claro, considere que temos str1 = “DUDU” e str2= “EDU”. Como podemos proceder para transformar “DUDU” em “EDU”? Na prática, existem várias as maneiras possíveis, conforme veremos a seguir.

Para começar, na Figura 1 apresentamos uma maneira não muito inteligente de fazer a transformação. Neste exemplo, para transformar “DUDU” em “EDU” o seguinte procedimento foi executado: primeiro excluímos todas as letras de “D”, “U”, “D” e “U” e depois adicionamos todas as letras de “E”, “D”, “U”. O custo total é de 7 operações (4 exclusões + 3 inserções).

Figura 1: Transformação – Uma exemplo com custo alto

A transformação representada na Figura 1 não é nada inteligente porque é muito custosa. É possível transformar “DUDU” em “EDU” de uma forma muito mais inteligente e econômica em relação ao número de operações, conforme mostra a Figura 2. Neste exemplo a transformação foi feita da seguinte forma:

• Exclusão da primeira letra “D” de “DUDU”, gerando a palavra “UDU”;
• Troca do primeiro “U” por “E” em “UDU”, gerando a palavra “EDU”.

Desta forma, foram necessárias apenas 2 operações. Este é o número mínimo de operações necessárias para o exemplo (Ou seja: não há como transformar “DUDU” em “EDU” realizando menos de 2 operações).

Figura 2: Transformação – Uma exemplo com custo mínino

A medida da distância de edição retorna um número inteiro que representa exatamente o custo mínimo para transformar str1 em str2 (ou str2 em str1). Conforme dissemos anteriormente, quando esse custo é baixo, normalmente str1 e str2 são muito parecidas. Se, por um exemplo, um usuário digita a palavra “EXCESSÃO” (palavra com erro ortográfico) a distância de edição poderá nos ajudar a sugerir “EXCEÇÃO” (palavra com grafia correta) como uma correção, uma vez que o valor da distância de edição

...

1. Introdução

A sub-cláusula CUBE é utilizada no Oracle em instruções SELECT com GROUP BY. Ela possibilita o cálculo de subtotais e totais para diferentes níveis dos dados agregados.

Este artigo introduz a utilização básica desta operação ainda pouco conhecida pelos desenvolvedores que trabalham com o SGBD Oracle. Para facilitar as explicações, faremos uso da tabela exemplo “T_VENDAS” cujos dados são apresentados na Figura 1. O script para criação da tabela está disponibilizado na Listagem 1. Nesta tabela, cada registro representa um cliente diferente de uma loja de departamentos hipotética. O campo “Id” corresponde à identificação do cliente. Os campos “Sexo”, “Idade” e “UF” descrevem propriedades dos clientes, enquanto o campo e “Valor” indica o valor gasto na compra realizada por cada cliente.

Figura 1: Tabela T_VENDAS

Listagem 1: Script para criar e popular a tabela “T_VENDAS”

//criação da tabela

CREATE TABLE t_vendas (
id NUMBER PRIMARY KEY,
sexo CHAR(1), 
idade CHAR(5),
UF CHAR(2),
VALOR NUMBER (5,2)
)
/  

//inserindo dados na tabela
INSERT INTO t_vendas VALUES(1,'F','<18','SP',115);
INSERT INTO t_vendas VALUES(2,'M','26-30','RJ',120); 
INSERT INTO t_vendas VALUES(3,'F','26-30','RJ',49);
INSERT INTO t_vendas VALUES(4,'F','18-25','MG',235); 
INSERT INTO t_vendas VALUES(5,'F','31-40','SP',101); 
INSERT INTO t_vendas VALUES(6,'M','<18','RJ',200); 
INSERT INTO t_vendas VALUES(7,'F','26-30','MG',55); 
INSERT INTO t_vendas VALUES(8,'F','<18','RJ',5);
INSERT INTO t_vendas VALUES(9,'M','18-25','RJ',68);
INSERT INTO t_vendas VALUES(10,'M','<18','SP',15); 
COMMIT;

2. CUBE

CUBE é uma operação que pode ser entendida como uma espécie de “versão tridimensional” da operação de GROUP BY. Ela produz um maior número de resultados do que o produzido com em um SELECT com GROUP BY comum.

Vamos então comparar os dois tipos de instrução: (i) SELECT com GROUP BY x (ii) SELECT com GROUP BY e CUBE. Na Listagem 2, apresentamos o comando SELECT com GROUP BY que contabiliza a soma dos valores gastos nas compras dentro de grupos formados pelos campos “Sexo” e “UF”. O resultado da execução da instrução é apresentado na Figura 2.

Listagem 2: SELECT com GROUP BY

SELECT SEXO, UF, SUM(VALOR) 
FROM T_VENDAS
GROUP BY SEXO, UF
ORDER BY 1,2 

Figura 2: do SELECT com GROUP BY (Listagem 2)

Na Listagem 3, realizamos uma pequena modificação nesta instrução através da inserção da sub-cláusula CUBE. Isto força a execução da operação d

...

Introdução

Em diversas situações práticas, quando trabalhamos com arrays torna-se necessário realizar uma cópia de seu conteúdo para realizar algum tipo de processamento. A linguagem Java oferece diferentes formas para copiar o conteúdo de um array para outro:

• Implementando um laço com o comando “for”.
• Utilizando o método “clone”.
• Utilizando “System.arraycopy”.
• Utilizando “Arrays.copyOf”.

Este artigo tem por objetivo apresentar exemplos de utilização destas quatro abordagens e também realizar uma breve discussão a respeito das vantagens e desvantagens de cada uma. Nos exemplos apresentados, “a” é o vetor origem (vetor os dados originais) e “b” o vetor destino (que receberá os dados copiados).

Abordagem 1: Comando “for”

É a maneira mais tradicional de realizar a operação, podendo ser utilizada em qualquer linguagem de programação. Nesta abordagem precisamos inicialmente reservar espaço para o vetor destino (vetor “b”). Depois disso, implementa-se um laço for que varre todo o conteúdo do vetor origem (vetor “a”), copiando o valor armazenado em cada posição (um por um) para a posição correspondente em “b”. Esta implementação é mostrada na Listagem 1.

Listagem 1: Copiando o conteúdo de um array para outro com o comando “for”

import java.util.Random;

public class CopiaFor {

	public static void main(String[] args) {
		
		//(1) cria o array "a" e o preenche com uma sequência de números aleatórios
		int [] a = new int[5];
		Random numeros = new Random();
		for (int i=0; i < a.length; i++) {
			a[i]=numeros.nextInt();
			System.out.println("a[" + i + "]=" + a[i]);
		}
		System.out.println();
		
		//(2) Copia o conteúdo de "a" para "b" com o uso de laço for
		
		int [] b = new int[a.length];                //primeiro é preciso reservar espaço para b
		for (int i=0; i < a.length; i++) b[i]=a[i];  //agora podemos copiar
		
		//(3) exibe o conteúdo de "b" 
		for (int i=0; i < a.length; i++) {
			System.out.println("b[" + i + "]=" + b[i]);
		}
		
	} 
}

Abordagem 2: Método “clone()”.

Na linguagem Java, o método “clone()” é utilizado para clonar um objeto, ou seja, para gerar uma cópia de seu conteúdo. O método pode ser utilizado para duplicar o conteúdo de um array, conforme mostra a Listagem 2. Observe que nesta abordagem não é preciso reservar espaço para o vetor “b”, pois o método “clone()” faz isso automaticamente. Além, disso basta uma simples linha de código sem o uso de qualquer parâmetro para realizar a operação.

Listagem 2: Copiando o conteúdo de um array para outro com o método “clone()”

import java.util.Random;


public class CopiaClone {

public static void main(String[] args) {
		
		//(1) cria o array "a" e o preenche com uma sequência de números aleatórios
		int [] a = new int[5];
		Random numeros = new Random();
		for (int i=0; i < a.length; i++) {
			a[i]=numeros.nextInt();
			System.out.println("a[" + i + "]=" + a[i]);
		}
		System.out.println();
		
		//(2) Copia o conteúdo de "a" para "b" com o uso do método “clone()”
		
		int [] b = a.clone();  //este comando reserva espaço para "b" 
//e faz a cópia do conteúdo de "a" para "b"
		
		//(3) exibe o conteúdo de "b" 
		for (int i=0; i < a.length; i++) {
			System.out.println("b[" + i + "]=" + b[i]);
		}
	}

} 

Abordagem 3: Método “System.arraycopy”.

Outra forma de copiar arrays é com o uso da classe “System”. Ela possui um método denominado “arraycopy” que oferece uma forma eficiente de realizar a operação. Para utilizar o método é preciso especificar alguns parâmetros, conforme indicado em sua assinatura:

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Os argumentos “src” e “dest” representam os vetores origem e destino, respectivamente (em nosso exemplo, esses vetores chamam-se “a” e “b”). O argumento “srcPos” é a posição inicial no array origem. O argumento “destPos” é a posição inicial no array destino. Por fim, “length” é utilizado para especificarmos o número de elementos que serão copiados.

O programa da Listagem 3 mostra como realizar a cópia do conteúdo de “a” para “b” com o uso de System.arraycopy.

Listagem 3: Copiando o conteúdo de um array para outro com o método “System.arraycopy”

import java.util.Random;


public class CopiaArrayCopy {
	
public static void main(String[] args) {
		
		//(1) cria o array "a" e o preenche com uma sequência de números aleatórios
		int [] a = new int[5];
		Random numeros = new Random();
		for (int i=0; i < a.length; i++) {
			a[i]=numeros.nextInt();
			System.out.println("a[" + i + "]=" + a[i]);
		}
		System.out.println();
		
		//(2) Copia o conteúdo de "a" para "b" com o uso do método “System.arraycopy”
		
		int [] b = new int[a.length];                //primeiro é preciso reservar espaço para b
		System.arraycopy(a, 0, b, 0, a.length);  //agora podemos copiar
		
		
		//(3) exibe o conteúdo de "b" 
		for (int i=0; i < a.length; i++) {
			System.out.println("b[" + i + "]=" + b[i]);
		}
	}

} 

Para usar o método “System.arraycopy” é preciso primeiro reservar espaço para “b”. Depois podemos chamar o método, especificando os parâmetros de forma adequada. Em nosso exemplo a chamada ao método foi feita da seguinte forma:

System.arraycopy(a, 0, b, 0, a.length);

Com isto, estamos dizendo que desejamos copiar o conteúdo de “a” a partir de sua posição 0 para “b” também a partir de sua posição “0”. O número de elementos a ser copiado é igual a “a.length”, ou seja, desejamos copiar todos os elementos armazenados em “a”.

O método “System.arraycopy” parece mais difícil de utilizar do que os anteriormente apresentados, pois ele requer a utilização de parâmetros. Porém o seu uso é vantajoso em determinadas situações. Para começar, uma grande vantagem é que o método é mais flexível, pois oferece a possibilidade de copiar apenas parte dos dados que estão armazenados em “a” para “b”. Este recurso é exemplificado no programa da Listagem 4.

Listagem 4: Copiando parte do conteúdo de um array com o método “System.arraycopy”

public class CopiaParte {

public static void main(String[] args) {
	
	//(1) cria o array "a" e o preenche com os caracteres da palavra "utopia"
	char[] a = { 'u', 't', 'o', 'p

...

Figura 1: JSON - Javascript Object Notation

1. Introdução

JSON (JavaScript Object Notation) é um modelo para armazenamento e transmissão de informações no formato texto. Apesar de muito simples, tem sido bastante utilizado por aplicações Web devido a sua capacidade de estruturar informações de uma forma bem mais compacta do que a conseguida pelo modelo XML, tornando mais rápido o parsing dessas informações.

O ambiente PHP, na versão 5.2.0 ou superior, oferece um parser bastante simples e interessante para a manipulação de dados estruturados no formato JSON. Basicamente, você precisa utilizar apenas três funções: “json_decode”, “json_encode”, e “json_last_error”. Para simplificar ainda mais as coisas, não é preciso realizar nenhuma instalação adicional ou qualquer tipo de configuração no “php.ini” para utilizar estas funções (as extensões para JSON são automaticamente compiladas quando instala-se o PHP).

2. Decodificando JSON: a função “json_decode”

A função “json_decode” recebe como entrada uma string codificada no formato JSON e a converte para uma variável PHP. Mostraremos como utilizar essa função através de alguns exemplos. Para começar, a Listagem 1 mostra um exemplo básico em que os dados de um funcionário (nome, idade e sexo) armazenados em uma string JSON são “importados” para um objeto PHP.

Listagem 1: Função “json_decode” – exemplo inicial

<?php
//string json contendo os dados de um funcionário
$json_str = '{"nome":"Jason Jones", "idade":38, "sexo": "M"}';

//faz o parsing na string, gerando um objeto PHP
$obj = json_decode($json_str);

//imprime o conteúdo do objeto 
echo "nome: $obj->nome<br>"; 
echo "idade: $obj->idade<br>"; 
echo "sexo: $obj->sexo<br>"; 
?> 

O resultado da execução do programa é:

nome: Jason Jones
idade: 38
sexo: M

Observe que a função “json_decode” é aplicada diretamente sobre a string “$json_str”, que contém os dados do funcionário representados em JSON. Esta função faz o parsing no conteúdo da string, convertendo-o automaticamente para um objeto PHP (variável $obj). Realizada a conversão, o $obj pode ser utilizada normalmente dentro do código PHP, conforme exemplificamos através das instruções “$echo”.

No exemplo apresentado, a string JSON possuía os dados de apenas um empregado. Mas como poderíamos proceder para trabalhar com uma string ou arquivo JSON contendo os dados de múltiplos empregados, como, por exemplo, os dados mostrados na Listagem 2.

Listagem 2: Arquivo JSON contendo 3 registros

{
empregados: 
[
{"nome":"Jason Jones", "idade":38, "sexo": "M"},
{"nome":"Ada Pascalina", "idade":35, "sexo": "F"},
{"nome":"Delphino da Silva", "idade":26, "sexo": "M"}
]
}' 

Quando desejamos representar múltiplos objetos em JSON, fazemos uso de um array. Os arrays JSON são delimitados por colchetes, com seus elementos separados entre vírgula, conforme mostrado na Listagem 2. Neste exemplo, os dados de três funcionários estão representados no array (“Jason Jones”, “Ada Pascalina” e “Delphino da Silva”). O programa da Listagem 3 demonstra como implementar um programa PHP para importar e trabalhar com um array JSON.

Listagem 3: Função “json_decode” – trabalhando com um array

<?php

//string json (array contendo 3 elementos)
$json_str = '{"empregados": '. 
		'[{"nome":"Jason Jones", "idade":38, "sexo": "M"},'.
		'{"nome":"Ada Pascalina", "idade":35, "sexo": "F"},'.
		'{"nome":"Delphino da Silva", "idade":26, "sexo": "M"}'.
		']}';

//faz o parsing da string, criando o array "empregados"
$jsonObj = json_decode($json_str);
$empregados = $jsonObj->empregados;

//navega pelos elementos do array, imprimindo cada empregado
foreach ( $empregados as $e )
    {
	echo "nome: $e->nome - idade: $e->idade - sexo: $e->sexo<br>"; 
    }
?> 

Veja o resultado da execução do programa:

nome: Jason Jones - idade: 38 - sexo: M
nome: Ada Pascalina - idade: 35 - sexo: F
nome: Delphino da Silva - idade: 26 - sexo: M

O exemplo da Listagem 4 mostra o parsing de uma srting JSON um pouco mais complexa. Desta vez, o primeiro funcionário possui dois dependentes, enquanto os demais não possuem (ou seja, foi introduzido um “campo” opcional denominado “dependentes”). Também acrescentamos uma nova variável denominada “data” para armazenar data da versão do arquivo de empregados.

Listagem 4: Função “json_decode” – trabalhando com um objeto c

...

1. Introdução

A cláusula GROUP BY é utilizada em instruções SELECT com o propósito de produzir resultados agregados por um ou mais campos. Iniciaremos este artigo relembrando rapidamente a sua forma de utilização. Para isto, faremos uso de um exemplo envolvendo os dados armazenados na tabela “T_VENDAS”, apresentada na Figura 1.

Imagine que esta tabela armazena os dados das compras efetuadas por clientes de uma loja de departamentos hipotética, em uma determinada semana. Cada registro representa um cliente diferente, identificado pelo atributo Id. Os campos “Sexo”, “Idade” e “UF” descrevem propriedades dos clientes, enquanto o campo e “Valor” indica o valor gasto na compra realizada por cada cliente. O script para criar e popular a tabela no Oracle é apresentado na Listagem 1.

Figura 1: Tabela T_VENDAS

Listagem 1: Script para criar e popular a tabela “T_VENDAS”

//criação da tabela

CREATE TABLE t_vendas (
id NUMBER PRIMARY KEY,
sexo CHAR(1), 
idade CHAR(5),
UF CHAR(2),
VALOR NUMBER (5,2)
)
/  

//inserindo dados na tabela
INSERT INTO t_vendas VALUES(1,'F','<18','SP',115);
INSERT INTO t_vendas VALUES(2,'M','26-30','RJ',120); 
INSERT INTO t_vendas VALUES(3,'F','26-30','RJ',49);
INSERT INTO t_vendas VALUES(4,'F','18-25','MG',235); 
INSERT INTO t_vendas VALUES(5,'F','31-40','SP',101); 
INSERT INTO t_vendas VALUES(6,'M','<18','RJ',200); 
INSERT INTO t_vendas VALUES(7,'F','26-30','MG',55); 
INSERT INTO t_vendas VALUES(8,'F','<18','RJ',5);
INSERT INTO t_vendas VALUES(9,'M','18-25','RJ',68);
INSERT INTO t_vendas VALUES(10,'M','<18','SP',15); 
COMMIT;

Com o uso da cláusula GROUP BY, podemos criar uma instrução SELECT capaz de gerar grupos formados pelas diferentes combinações de valores de campos escolhidos e produzir um determinado resultado matemático (soma, média, contagem de frequência, etc.) referente a cada grupo. Um exemplo é apresentado na Lisatagem 2 em que o SELECT com GROUP BY contabiliza a soma dos valores gastos nas compras dentro de grupos formados pelos campos “Sexo” e “UF”. . O resultado produzido é apresentado na Figura 2.

Listagem 2: SELECT com GROUP BY

SELECT SEXO, UF, SUM(VALOR) 
FROM T_VENDAS
GROUP BY SEXO, UF
ORDER BY 1,2 

Figura 2: Resultado do SELECT da Listagem 2

2. ROLLUP

Certamente, para a maioria dos leitores do artigo o texto apresentado até aqui não representou nenhuma novidade, pois a cláusula GROU

...

1. Introdução

Imagine que um programador esteja criando um joguinho para telefone celular em que o objetivo seja comandar um foguete em uma viagem até Marte, sendo necessário para isso ultrapassar uma sequência de n naves espaciais que se encontram a sua frente (ex: 30 naves). Cada nave a ser ultrapassada pode ser de apenas um dos seguintes dois tipos:

• nave marciana (M): é a nave inimiga. Quando o foguete do jogador se deparar com esse tipo de nave, será preciso duelar. A nave marciana vai atirar e tentará derrubá-lo; por isso, o foguete só poderá ultrapassá-la, se contra-atacar e conseguir derrubá-la.
• nave neutra (~M): neste caso, não se trata de uma nave inimiga e o jogador deverá apenas ultrapassá-la. Caso o jogador se confunda e atire em uma nave neutra, perderá o jogo! (obs: a representação ~M escolhida para a nave neutra significa “não marciana”).

Considere que o programador deste joguinho tenha decidido que na primeira fase, o objetivo seja ultrapassar uma sequência de 30 naves. Para dar mais dificuldade ao jogo, ele quer que cada nave que surja na sequência tenha 80% de chance de ser uma nave marciana e apenas 20% de chance de ser uma nave neutra.

Nesse caso, como ele poderia criar um procedimento para produzir diferentes sequências aleatórias com essas características? Ou seja: como desenvolver um gerador de sequências não fixas de naves que sejam compostas por aproximadamente 80% de naves M e 20% de naves ~M? Felizmente (para o programador do joguinho!), o problema acima pode ser resolvido de maneira simples, pois a sequência de naves espaciais que será produzida possui distribuição binomial probabilidades. Trata-se de uma das mais conhecidas distribuições de probabilidade e uma das que possui o maior número de aplicações práticas. Este artigo tem dois objetivos: introduzir os conceitos básicos sobre distribuição binomial de probabilidades e apresentar uma técnica para trabalhar com este tipo de distribuição na linguagem Java.

2. A Distribuição Binomial

Antes de abordarmos a implementação Java, apresentamos nesta seção uma breve definição formal para distribuição binomial de probabilidades, para que o leitor fique familiarizado com os seus principais conceitos e características.

• Considere um experimento E e seja M um evento associado a E.
• Seja P(M) = p (a probabilidade de ocorrência do evento M é p). Sendo assim, temos P(~M) = 1 – p (probabilidade de não ocorrer o evento M).
• Considere que sejam realizadas n repetições do experimento. Dessa forma, o conjunto de todos os resultados possíveis para o experimento (espaço amostral) será formado por todas as sequências possíveis {m1, m2, ..., Mn}, onde cada elemento dentro da sequência é M ou ~M. Por exemplo, considerando n=3, o conjunto com todos os resultados possíveis é dado por:
  {M,M,M}
  {M,M,~M}
  {M,~M,M}
  {M,~M,~M}
  {~M,M,M}
  {~M,M,~M}
  {~M,~M,M}
  {~M,~M,~M}
• Suponha que P(M) = p seja sempre a mesma para todas as repetições.
• Seja a variável (aleatória) X = {número de vezes que o evento M tenha ocorrido na sequência de n repetições}. Dizemos que X possui distribuição binomial com parâmetros n e p.

O exemplo do joguinho da sequência de 30 naves marcianas e naves neutras apresentado na seção anterior se enquadra exatamente nesse caso. Neste caso, estamos lidando com o seguinte fenômeno (variável aleatória): X = “número de vezes em que a nave marciana aparece em uma sequência”. Veja que X é claramente uma variável com distribuição binomial, cujos parâmetros são n=30 (tamanho da sequência) e p = 0,80 (probabilidade de uma nave ser marciana).

3. Implementação Java

A

...

Introdução

Ordenação de vetores é um dos mais importantes temas associados à programação. Nas faculdades de computação, o assunto é estudado especialmente em disciplinas como “Estruturas de Dados” ou “Análise e Projetos de Algoritmos”. Existem diversos algoritmos para realizar a tarefa, como o simples, mas pouco eficiente, “Método da Bolha” e o complexo, porém eficiente, “Quicksort”.

Mas e se desejássemos fazer a operação inversa? Explicando melhor: suponha que a partir de um vetor ordenado, por exemplo [1,2,3,4,5], nosso objetivo fosse embaralhar o conteúdo do mesmo, deixando-o, por exemplo com a configuração [3,4,1,5,2]. Ou seja, imagine que a tarefa a ser executada é a de “desordenar” um vetor ordenado! Por incrível que pareça, essa tarefa possui inúmeras aplicações práticas, que vão desde o campo dos jogos de computadores (ex: embaralhar as cartas em um jogo de baralho) até a área de mineração de dados (misturar os registros de uma base de dados para poder aplicar uma rotina de particionamento aleatório de dados).

Será que existe alguma forma simples e eficiente para embaralhar o conteúdo de vetores? A resposta é: sim, existem algumas formas e as apresentaremos nesse artigo através de exemplos em Java. O texto está dividido em duas partes: a primeira apresenta uma rápida revisão sobre a classe “ArrayList” (a mais utilizada para a implementação de arrays) e sobre a forma de ordenar e embaralhar dados contidos em elementos desse tipo com o uso da classe “Collections”. A segunda parte do artigo apresenta um método mais genérico para permitir o “embaralhamento” de qualquer tipo de vetor. Este método baseia-se no uso da classe “java.util.Random” e pode ser facilmente adaptado para qualquer outra linguagem de programação.

1. Embaralhando ArrayLists

Quando programamos em Java, normalmente os arrays são implementados com o uso de classes como ArrayList, Vector ou LinkedList, que implementam a interface List. A Listagem 1 apresenta um exemplo envolvendo a classe ArrayList. No exemplo, criamos um ArrayList de inteiros chamado “numeros” e adicionamos a ele 5 elementos. A seguir, imprimimos o seu conteúdo e apresentamos exemplos de chamadas aos métodos mais comumente utilizados nos ArrayLists, que executam tarefas como retornar propriedades do ArrayList, modificar o seu conteúdo, buscar um elemento, etc.

Listagem 1: Exemplo básico de utilização da classe ArrayList

import java.util.ArrayList;
import java.util.List;

public class RevisaoArrayList {

	public static void main(String[] args) {
		
		//cria um ArrayList chamado "numeros"
		List<Integer> numeros = new ArrayList<Integer>();

		//adiciona 5 elementos ao ArrayList com o método "add"
		//cada númeor é sempre inserido no fim da lista
		numeros.add(10);
		numeros.add(1000);
		numeros.add(500);
		numeros.add(40);
		numeros.add(-1);

		//imprime o conteúdo do ArrayList
		System.out.println("numeros: " + numeros.toString()); //imprime o conteúdo do array
		
		//alguns métodos...
		System.out.println("tamanho: " + numeros.size());
		System.out.println("primeiro elemento: " + numeros.get(0));
		System.out.println("terceiro elemento: " + numeros.get(2));
		System.out.println("ultimo elemento: " + numeros.get(numeros.size()-1));
		
		//troca o valor do terceiro elemento de 500 para 50
		numeros.set(2, 50);
		System.out.println("configuracao de numeros apos troca de valor: " + numeros.toString());

		//remove o segundo elemento
		numeros.remove(1);
		System.out.println("configuracao de numeros apos remocao: " + numeros.toString());
		
		//verifica se o array contém os elementos 40 e 15
		System.out.println("contem o elemento 40? " + numeros.contains(40));
		System.out.println("contem o elemento 15? " + numeros.contains(15));
		
	}
	
}

O resultado da execução do programa é mostrado na Figura 1.

Figura 1: Execução do programa da Listagem 1

Para ordenar ArrayLists fazemos uso da classe “Collections”. Esta classe contém uma série de métodos estáticos que atuam so

...

1. Introdução

Weka é um software livre para mineração de dados, do tipo open source, desenvolvido em Java dentro das especificações da GPL (General Public License) que se consolidou como a ferramenta de mineração de dados mais utilizada por estudantes e professores de universidades. A ferramenta também é muito utilizada por profissionais que desejam aprender os conceitos básicos sobre mineração de dados. Através de sua interface gráfica (conhecida como Weka Explorer) é possível conduzir processos de mineração de dados de forma simples, realizando a avaliação dos resultados obtidos e a comparação de algoritmos. Além disso, a ferramenta oferece recursos para a execução de tarefas relacionadas ao pré-processamento de dados como, por exemplo, a seleção e a transformação de atributos.

A ferramenta Weka trabalha preferencialmente com bases de dados no formato texto. Por esta razão, quase todos os tutoriais e apostilas sobre a ferramenta disponibilizados na Internet mostram como utilizar a Weka para minerar bases de dados estruturadas nos formatos ARFF ou CSV. No entanto, o que um número reduzido de usuários da ferramenta sabe é que também é possível utilizar a Weka para minerar diretamente tabelas de SGBD’s relacionais. Esta forma de utilização da Weka é bastante interessante já que, na maior parte das aplicações práticas, os dados a serem minerados se encontram originalmente armazenados em algum banco relacional (MySQL, Oracle, PostgreSQL, SQL Server, etc.). Desta forma, quando efetua-se a conexão da Weka com um SGBD, deixa de existir a necessidade de exportar os dados do banco para texto e posteriormente formatá-los como ARFF (ou CSV) - atividades que, em geral, consomem um tempo considerável.

Este artigo descreve os passos exigidos para a configuração de uma conexão da Weka com o SGBD MySQL. O artigo é direcionado para usuários que já possuem alguma experiência com a ferramenta e que possuam a mesma instalada em suas máquinas. Para muitos desses usuários, especialmente os que não estão acostumados com conceitos do universo Java - como o padrão JDBC e o formato JAR - a forma de realizar a configuração poderá parecer um pouco “intimidadora” (de fato, os passos necessários são um pouquinho trabalhosos). Apesar disso, as vantagens minerar diretamente SGBD’s relacionais compensam o trabalho. O roteiro será explicado passo-a-passo, então mesmo aqueles que não possuem experiência em Java conseguirão executá-lo.

O restante do artigo está dividido da seguinte forma. A Seção 2 apresenta um script para criar e popular uma tabela-exemplo no MySQL (tabela “weather”). A Seção 3 contém o roteiro para configurar a conexão da Weka com o MySQL. Embora o exemplo envolva o MySQL, os passos podem ser facilmente adaptados para outro SGBD. Por fim, na Seção 4 do artigo, apresenta-se um exemplo que mostra como minerar uma tabela relacional (ou seja, que faz uso da conexão criada). O exemplo em questão envolve a mineração da tabela “weather” no MySQL.

2. Criando a Tabela Exemplo

Esta seção apresenta os scripts para a criação de uma tabela exemplo no MySQL. Esta tabela poderá ser diretamente acessada e minerada pela Weka após a configuração da conexão com o SGBD.

A tabela-exemplo se chama “weather” e contém os mesmos dados da base “weather.arff” que é disponibilizada junto com a ferramenta Weka (localizada na pasta “data” dentro do diretório de instalação da Weka). As Listagens 1 e 2 contêm, respectivamente, os scripts para criar e popular a tabela. Para os exemplos apresentados no artigo, a tabela “weather” foi criada em um banco MySQL chamado “devmedia”. No entanto, você poderá criá-la em qualquer banco.

Listagem 1: Criação da Tabela “weather”

CREATE TABLE weather(
outlook VARCHAR( 8 ) NOT NULL ,
temperature float NOT NULL ,
humidity float NOT NULL ,
windy VARCHAR( 5 ) NOT NULL ,
play CHAR( 3 ) NOT NULL 
) 

Listagem 2: Populando a Tabela “weather”

INSERT INTO weather values('sunny',85,85,'FALSE','No');
INSERT INTO weather values('sunny',80,90,'TRUE','No');
INSERT INTO weather values('overcast',83,86,'FALSE','Yes');
INSERT INTO weather values('rainy',70,96,'FALSE','Yes');
INSERT INTO weather values('rainy',68,80,'FALSE','Yes');
INSERT INTO weather values('rainy',65,70,'TRUE','No');
INSERT INTO weather values('overcast',64,65,'TRUE','Yes');
INSERT INTO weather values('sunny',72,95,'FALSE','No');
INSERT INTO weather values('sunny',69,70,'FALSE','Yes');
INSERT INTO weather values('rainy',75,80,'FALSE','Yes');
INSERT INTO weather values('sunny',75,70,'TRUE','Yes');
INSERT INTO weather values('overcast',72,90,'TRUE','Yes');
INSERT INTO weather values('overcast',81,75,'FALSE','Yes');
INSERT INTO weather values('rainy',71,91,'TRUE','No'); 

3. Configurando a Conexão da Weka com o MySQL

O texto a seguir apresenta o roteiro passo-a-passo para a configuração da conexão da Weka com o MySQL. Pelo fato de a Weka ser um software desenvolvido em Java, esta conexão é realizada através do padrão JDBC (mais especificamente, com o uso do driver JDBC do MySQL). Caso você seja um usuário da Weka, mas não conheça muito sobre Java, não fique preocupado: simplesmente execute os passos apresentados no roteiro a seguir. Eles mostram como criar um ambiente exemplo contendo todos os arquivos de configuração necessários para realizar a conexão Weka-MySQL.

Passo 1: Vá até a pasta de instalação da Weka (ex: C:\Arquivos de Programas\Weka-3-6-6) ou crie uma pasta em seu computador (ex: “C:\mining”) e copie o arquivo “weka.jar” para dentro desta pasta. O arquivo “weka.jar” é o principal da ferramenta Weka, correspondendo à biblioteca que contém os “executáveis” da ferramenta (arquivos “.class”).

Passo 2: Baixe o driver JDBC do MySQL e coloque na mesma pasta do arquivo “weka.jar”. Trata-se de um arquivo “.jar” que poderá ser obtido no próprio site do MySQL: http://dev.mysql.com (ou em outros sites). Ele é conhecido como mysql connector (ou Connector/J). Para o teste descrito neste artigo, foi baixado o driver com o seguinte nome: mysql-connector-java-5.1.22-bin.jar.

Passo 3: Para realizar a conexão da Weka com o MySQL ou qualquer outro SGBD

...

1. Introdução

Os números aleatórios são utilizados de diversas formas em programas de computador. Eles são importantes no desenvolvimento de jogos, na área de segurança de informações (ex: para gerar senhas ou textos de campos captcha) e em programas de mineração de dados e análise estatística, apenas para citar alguns exemplos.

A linguagem Java disponibiliza funcionalidades para a geração de números aleatórios em uma classe denominada “Random” do pacote “java.util”. Este artigo apresenta um guia rápido dos usos mais comuns da classe Random.

2. A Classe Random na Prática

As instâncias da classe “Random” são objetos geradores de números aleatórios, que produzem estes números em resposta a solicitações. A Listagem 1 apresenta um exemplo básico de utilização da classe. A explicação do programa se encontra logo após a especificação do código.

Listagem 1: Exemplo básico de utilização da classe Random

import java.util.Random;

public class Random1 {

	public static void main(String[] args) {

		//instância um objeto da classe Random usando o construtor padrão
		Random gerador = new Random();
	    
		//imprime sequência de 10 números inteiros aleatórios
	    for (int i = 0; i < 10; i++) {
	    	System.out.println(gerador.nextInt());
	 	}
	}
}

Um resultado possível para a execução do programa é mostrado na Figura 1.

Figura 1: Execução do programa da Listagem 1

Agora vamos à explicação do programa. A classe “Random” está definida no pacote “java.util”, portanto qualquer programa Java que faça uso da mesma precisará fazer a importação com “import java.util.random”. No programa da Listagem 1, o gerador de número aleatórios foi instanciado através do uso do construtor padrão: Random gerador = new Random().

Esta é a forma mais simples de inicializar um objeto da classe Random. De acordo com a documentação da classe, quando se utiliza o construtor padrão, o valor desemente utilizado em cada chamada será “muito provavelmente” diferente do valor de semente escolhido em qualquer invocação posterior desse construtor. A grosso modo, a semente pode ser definida uma espécie de “ponto de partida” para a geração de uma sequência de números aleatórios (em exemplos posteriores mostraremos como é possível especificar uma semente). O programa contém um loop for que gera 10 números aleatórios através de 10 chamadas ao método “nextInt”. No exemplo, o método é chamado sem nenhum parâmetro, retornando a cada iteração um inteiro diferente da sequência de aleatórios. Serão retornados números positivos ou negativos dentre toda a faixa de valores inteiros do Java.

O resumo é o seguinte: todas as vezes que você executar o programa da Listagem 1, obterá uma sequência diferente de 10 números inteiros negativos ou positivos. O menor e o maior número que podem ser gerados são, respectivamente, iguais ao menor e maior inteiro possível na plataforma em que o programa estiver sendo executado.

No entanto, para muitas aplicações práticas você precisará gerar inteiros entre 0 e algum limite superior (ex: 10, 50, 100, etc.). Para fazer isto, basta fazer uma chamada ao método “nextInt” passando um parâmetro “n”. Neste caso, o inteiro a ser retornado estará contid

...

1. Introdução

Este artigo aborda dois temas avançados e de fundamental importância no tratamento de exceções na linguagem PL/SQL:

• Exceções programadas: exceção que é disparada apenas em situações definidas pelo programador.
• Blocos internos para tratamento de exceções: recurso que adiciona maior controle ao mecanismo de tratamento de erros.

Como sugestão de leitura deixo o artigo “Tratamento de Exceções de Sistema na linguagem PL/SQL”, onde foram introduzidos os conceitos básicos sobre o tratamento de exceções na linguagem PL/SQL e apresentada a “receita” para realizar o tratamento das exceções de sistema.

2. Exceções Programadas

Caso o programador deseje, poderá definir os seus próprios tipos de exceção na linguagem PL/SQL. Neste caso - ao contrário do que ocorre com as exceções de sistema mostradas artigo citado - a exceção não será disparada automaticamente, mas apenas quando determinadas ações especificadas pelo programador ocorrerem. Para criar exceções programadas, você deve seguir dois passos:

• Criar uma variável do tipo EXCEPTION na seção de declarações de seu procedure ou função.
• Inserir um tratador para a sua exceção no bloco de exceções. O comando RAISE é usado para forçar com que a sua exceção seja disparada.

O programa da Listagem 1 exemplifica a utilização das exceções programadas. Trata-se de um procedure que imprime os n primeiros números ímpares, onde n é um parâmetro de entrada especificado pelo usuário. O procedure possui uma exceção programada que é disparada sempre que n for passado com um valor menor igual a zero.

Listagem 1: Procedure p_impares

CREATE OR REPLACE PROCEDURE p_impares(n IN NUMBER) IS

/* -----------------------------------------------------------
   PROCEDURE : p_impares
   DESCRIÇÃO : imprime os “n” primeiros números ímpares
   ----------------------------------------------------------- */

i                    PLS_INTEGER;
j                    PLS_INTEGER := 1;
e_param_invalido     EXCEPTION; -- exceção definida pelo programador

BEGIN

   -- esta linha força com que a exceção programada seja disparada 
   -- caso n seja menor ou igual a zero
   IF n <= 0 THEN RAISE e_param_invalido; END IF; 

   i:=1;

   FOR i IN 1..N LOOP

     DBMS_OUTPUT.PUT_LINE(j);
     j:= j + 2;

   END LOOP;

    EXCEPTION
      WHEN e_param_invalido THEN      -- tratamento da exceção programada
 
         DBMS_OUTPUT.PUT_LINE('----------------------------------');
         DBMS_OUTPUT.PUT_LINE('Erro!!!');
         DBMS_OUTPUT.PUT_LINE('O parametro n deve ser >= 1.');
         DBMS_OUTPUT.PUT_LINE('----------------------------------');

END p_impares;
/

Para executar o programa, basta logar no SQL*Plus e chamar o procedure conforme indicado na Figura 1. Se, como é mostrado no exemplo, passarmos o valor 0 como entrada (ou um número negativo), a exceção programada irá disparar, produzindo uma mensagem de erro no console (para a mensagem aparecer, não esqueça de habilitar a saída do console com

...

1. Introdução

Na linguagem PL/SQL qualquer tipo de erro é tratado como uma exceção (exception), o que significa uma situação que, a princípio, não deveria ocorrer durante a execução seu programa. Existem dois tipos de exceção:

• Exceção de sistema (system exception): um erro definido pelo Oracle que é disparado automaticamente pela runtime engine da PL/SQL assim que ela detecta o problema. Exemplos: “duplicate value in index” e “no data found”.
• Exceção Programada: exceção definida pelo programador e, portanto, específica da aplicação. Este tipo de exceção não é disparada automaticamente, mas apenas para situações indicadas pelo programador em seu código.

Neste artigo, abordaremos o tratamento de exceções de sistema.

2. Tratando uma Exceção de Sistema – Modelo Básico

O primeiro passo requerido para que você possa tratar uma exceção de sistema é inserir um bloco EXCEPTION no final da sua procedure ou função. A Figura 1 indica em destaque este bloco, colocado imediatamente antes da palavra reservada END do bloco principal.

Figura 1: Bloco para Tratamento de Exceções

Quando um erro ocorre em qualquer linha do programa PL/SQL, uma exceção é disparada. O processamento do programa é imediatamente interrompido e o fluxo é desviado para o bloco de exceções. Dentro deste bloco, a runtime engine do PL/SQL tentará localizar o tratador de exceção adequado para o erro ocorrido. Um exemplo é apresentado na Figura 2.

Figura 2: Tratador de Exceção

Veja que, na seção de declarações da procedure “p_dummy”, a variável “v1” é especificada como sendo do tipo CHAR(2). Entretanto, no corpo do programa existe uma instrução de atribuição que tenta colocar um valor maior do que a capacidade máxima da variável: v1 := 'ABC';

Durante a execução do programa, quando a runtime engine tentar executar o comando acima, as seguintes ações ocorrerão:

1. Um erro do tipo VALUE_ERROR será detectado pelo Oracle.
2. O fluxo normal do programa será interrompido e a execução será desviada para o bloco de exceções (EXCEPTION).
3. Dentro do bloco de exceções, a runtime engine procurará pelo tratador de exceções adequado para o tipo de erro ocorrido. Um tratador de exceções é simplesmente um bloco de código dentro da seção EXCEPTION que é identificado com o uso da palavra WHEN seguida da descrição do tipo de erro (ex: WHEN VALUE_ERROR).

O programa da Listagem 1 apresenta um exemplo de função com uma rotina para tratamento de exceções programada. O programa cria uma função chamada “f_inverso” que recebe como entrada um número x e retorne como saída: f(x) = 1/x. Esta função realiza o tratamento de exceção quando o usuário passe como entrada o valor 0.

Listagem 1: Função f_inverso

CREATE OR REPLACE FUNCTION f_inverso(x IN NUMBER) RETURN NUMBER IS

/* -----------------------------------------------------------
   FUNÇÃO    : f_inverso
   DESCRIÇÃO : retorna f(x) = 1/x
   ----------------------------------------------------------- */

vFx   NUMBER;

BEGIN

   vFx := 1/x;
   RETURN vFx;

    EXCEPTION
      WHEN ZERO_DIVIDE THEN -- este é o “rótulo” dado pelo Oracle
                            -- para o tipo de erro disparado
                            -- quando ocorre a divisão por zero.
 
         DBMS_OUTPUT.PUT_LINE('----------------------------------');
         DBMS_OUTPUT.PUT_LINE('Erro: divisão por ZERO.');
         DBMS_OUTPUT.PUT_LINE('Não é possível obter o f(x) = 1/x.');
         DBMS_OUTPUT.PUT_LINE('----------------------------------');
          
         RETURN NULL;  -- s

...

1. Introdução

As funções analíticas podem ser utilizadas no SQL do Oracle para o cálculo e recuperação de resultados agregados em uma instrução SELECT. Elas podem ser empregadas como alternativa ao uso do SELECT com a cláusula “GROUP BY” em diversas situações práticas. A diferença consiste basicamente no fato de as funções analíticas serem capazes de retornar múltiplas linhas para cada grupo, algo que só é possível para o GROUP BY quando empregamos sub-consultas, tabelas virtuais e junções (técnicas que irão tornar a instrução SQL maior e mais complicada).

Nas seções a seguir, apresentamos alguns exemplos práticos introdutórios de utilização das funções analíticas. Utilizaremos como exemplo uma tabela de livros, cujo script de criação e inserção de dados é mostrado na Listagem 1.

Listagem 1: Script de criação para criar e popular a tabela exemplo (Livro)

CREATE TABLE LIVRO (
	ID NUMBER(2) PRIMARY KEY,
	TITULO VARCHAR2(30) NOT NULL,
	GENERO VARCHAR2(20) NOT NULL,
	PRECO NUMBER(5,2) NOT NULL
)
/

INSERT INTO LIVRO VALUES (1,'A Revolução dos Bichos', 'Ficção', 15);
INSERT INTO LIVRO VALUES (2,'Na Pior em Paris e Londres', 'Não-Ficção', 60);
INSERT INTO LIVRO VALUES (3,'Lutando na Espanha', 'Não-Ficção', 45);
INSERT INTO LIVRO VALUES (4,'A Flor da Inglaterra', 'Ficção', 45);
INSERT INTO LIVRO VALUES (5,'1984', 'Ficção', 40);

2. Sintaxe Básica

O modelo com a sintaxe básica para utilizar uma função analítica em uma consulta SQL é mostrado na Figura 1. Não se preocupe se você não entender precisamente o modelo neste momento, pois os exemplos apresentados na Seção 3 facilitarão este entendimento.

Figura 1: Sintaxe básica para utilizar funções analíticas em uma consulta SQL

Na sintaxe apresentada:

• Função_Analítica(argumentos): representa a função que será utilizada para computar resultados agregados ou valores de alguma medida estatística.
• OVER / PARTITION BY: cláusulas utilizadas para definir as partições (grupos) para “quebrar” ou agregar os resultados.

Existem sintaxes mais complexas para o uso de funções analíticas, porém não as apresentaremos neste artigo, já que, por enquanto, o objetivo é passar apenas conceitos introdutórios.

3. Exemplos

Iniciamos a seção de exemplos, mostrando como utilizar a sintaxe básica do SQL com função analítica para escrever uma consulta que retorna o id, título, gênero e total de livros para o gênero retornado na linha corrente. Para tal, basta utilizar a conhecida função COUNT(*) em conjunto com as clausular OVER – PARTITION BY e realizar o particionamento dos

...

1. Introdução

No último artigo mostramos as funções para cálculo da média, mediana e moda no banco de dados Oracle. O artigo pode ser consultado através do link: http://www.devmedia.com.br/calculando-media-moda-e-mediana-no-oracle/25577

Média, mediana e moda são medidas de tendência central, cujo propósito é sintetizar em um único número o que é típico (ou médio) em um conjunto de dados. Porém, estas medidas normalmente irão fornecer apenas um quadro incompleto dos dados. Para exemplificar a o que acabamos de afirmar, considere a tabela CAMPEONATO, mostrada na Figura 1. Esta tabela mostra as infrações cometidas por diversos jogadores que foram expulsos em um campeonato de futebol. As colunas JUIZ_A e JUIZ_B mostram as punições que foram atribuídas por dois juízes do “tribunal de esporte” para cada infração (cada punição é dada em número de jogos).

Figura 1: Tabela “Campeonato”

Podemos calcular a média de jogos atribuída nas penas de ambos os juízes com o uso da função AVG, como mostra a Listagem 1. Observe que a média é de 3 jogos tanto para o juiz A como para o juiz B.

Listagem 1: Obtenção da MÉDIA das penas atribuídas pelos Juízes A e B com a função AVG

SELECT AVG(juiz_a), AVG(juiz_b) FROM campeonato

AVG(juiz_a)     AVG(juiz_b)	
3                      3  

Será eque podemos concluir que os juízes tem “comportamento igual”, ou seja, que eles utilizam critérios parecidos? Ou será que, de fato, o uso da medida da média isoladamente não foi capaz de apresentar um quadro real da situação?

Para respondermos a essas perguntas, precisaremos fazer uso de outras medidas estatísticas. Precisaremos usar medidas de variabilidade, pois elas são capazes de fornecer um índice da dispersão dos escores em torno da média. As próximas seções apresentam essas medidas e a sua forma de utilização no SGBD Oracle.

2. Amplitude

Amplitude é uma medida rápida da variabilidade. Ela consiste na diferença entre o mais alto e o mais baixo valor de um determinado conjunto de dados (ou seja, de um determinado campo numérico da tabela Oracle). Na linguagem SQL, podemos calcular a amplitude com o uso das funções MAX e MIN, como mostra a Listagem 2.

Listagem 2: Obtenção da AMPLITUDE com as funções MAX e MIN

SELECT 
  (MAX(juiz_a) - MIN(juiz_a)) as Amplitude_A, 
  (MAX(juiz_b) - MIN(juiz_b)) as Amplitude_B 
FROM campeonato 

Amplitude_A    Amplitude_B	
3                      6

A amplitude do Juiz A é igual a 3, pois a sua maior pena foi de 4 jogos e a menor de 1 jogo (4 – 1 = 3). Já a amplitude do Juiz B é igual a 6, pois a sua maior pena foi de 7 jogos e a menor de 1 jogo (7 – 1 = 6). Com isto, já podemos perceber que a distribuição das penas do Juiz B apresenta uma maior variabilidade do que a do Juiz A.

No entanto, na prática a amplitude não é uma medida muito boa. Ela tem a vantagem de ser simples e rápida de calcular. Porém tem a desvantagem de depender apenas de dois valores de toda a distribuição (o menor valor e o maior valor). Com isso, ela pode ser claramente influenciada por um único valor. Precisamos então de medidas que levem em conta todos os valores da distribuição. Essas medidas são a Variância e o Desvio Padrão.

3. Variância e Desvio Padrão

Para entendermos a variância, inicialmente precisamos apresentar o conceito de desvio que consiste na distância de um valor arbitrário ao valor

...

1. Introdução

As medidas de tendência central são muito utilizadas em estudos de Probabilidade e Estatística para que seja possível representar em um único número, o que é típico (ou médio) em um conjunto de dados. Para que possamos começar a introduzir essas medidas, faremos uso da tabela “CAMPEONATO”, cujos dados são apresentados na Figura 1. Esta tabela mostra as infrações cometidas e punições atribuídas para diversos jogadores (a punição é dada em número de jogos) que foram expulsos em partidas do “campeonato de futebol A”. Observe que os jogadores “Wesley” e “Joel” foram expulsos mais de uma vez durante o campeonato.

Figura 1: Tabela “Campeonato”

2. Moda

A moda é a medida de tendência central que consiste no valor mais frequente em uma distribuição. Para obter a moda da variável PUNICAO no SQL do Oracle, basta utilizar a função STATS_MODE, como mostra a Listagem 1. O resultado é 4, pois, a maioria das punições (3 casos) foi de 4 jogos para os jogadores expulsos.

Listagem 1: Obtenção da MODA com a função STATS_MODE

SELECT STATS_MODE(punicao) FROM campeonato

STATS_MODE(punicao)
4

3. Média

A média é uma medida bem conhecida por todos nós. Trata-se da soma de cada valor do conjunto de registros, dividida pelo número de registros. Em SQL, a função para o cálculo da média é AVG (Listagem 2). Em nosso exemplo, os jogadores foram, em média, punidos por 3 jogos. Veja que ao contrário da moda, a média nem sempre o valor que ocorre com maior frequência no conjunto de dados.

Para ficar mais claro, a média foi calculada da seguinte forma: (4+1+3+2+4+4+3)/7 = 21/7 = 3. Onde 7 é a quantidade de registros total.

Listagem 2: Obtenção da MÉDIA com a função AVG

SELECT AVG(punicao) FROM campeonato

AVG(punicao)
3

4. Mediana

A ideia da mediana é separar a distribuição em duas partes iguais. Para calcular essa medida, inicialmente os dados devem ser

...

1. Introdução

JSON e XML representam duas importantes linguagens para a representação e troca de informações em aplicações Web. Nos dias atuais, é cada vez mais comum encontrar sistemas que, por uma ou outra razão, precisam trabalhar com ambos os formatos. Esta necessidade motivou o surgimento de programas utilitários que realizam a conversão de informações de XML para JSON e vice-versa.

Este artigo apresenta a classe “XML”, um programa utilitário do pacote “org.json” que possibilita a conversão entre os dois formatos na linguagem Java. Além de descrever a forma de utilização da classe, o artigo discute algumas diferenças conceituais entre XML e JSON que podem atrapalhar a vida dos desenvolvedores que precisam lidar com ambas as linguagens.

2. O Pacote “org.json”

A biblioteca “org.json” permite o processamento de JSON em programas Java. Em nossos dois últimos artigos, apresentamos as instruções detalhadas para obtenção e instalação da biblioteca e também mostramos uma série de exemplos de utilização da mesma em programas Java. O artigo que aborda a instalação da biblioteca pode ser consultado através do link: http://www.devmedia.com.br/trabalhando-com-json-em-java-o-pacote-org-json/25480.

De qualquer forma, não custa nada repetirmos de forma resumida o processo de instalação. Inicialmente, você deve acessar o site www.json.org/java e baixar todos os arquivos Java que estão relacionados na página. Se você usa uma IDE como o Eclipse ou Netbeans, basta criar um package chamado “org.json” em seu projeto e copiar os arquivos Java que você baixou para dentro deste package. Se você não utiliza nenhuma IDE, crie uma pasta para servir como pasta do projeto (por exemplo: C:\TESTE). Dentro desta pasta, crie uma pasta chamada org. Dentro da pasta org, crie uma pasta chamada json. A estrutura completa é mostrada na Figura 1. Copie todos os arquivos Java que você baixou para dentro da subpasta json.

Figura 1: Estrutura de pastas

3. A Classe XML

A classe “XML” (programa “XML.java”) fornece métodos estáticos que possibilitam a conversão de um documento (texto) XML para um JSONObject (tipo que armazena informações JSON na “org.json”) e para a conversão de um JSONObject para um documento XML. A classe XML deve ser utilizada em conjunto com a classe “XMLTokener” e também com as classes que formam o núcleo do pacote “org.json”: “JSONObject”, “JSONArray”, “JSONStringer”, “JSONWriter”, “JSONTokener”, “JSONException” e “JSONString”. Ou seja, você precisa de todas essas classes em seu ambiente para poder usar a classe “XML”.

Para explicarmos a forma de utilização da classe, faremos uso de exemplos envolvendo o arquivo “paises.xml”, mostrado na Listagem 1.

Listagem 1: paises.xml

<?xml version="1.0"?>
<paises>
   <pais sigla="BR">
       <nome>Brasil</nome>
       <populacao>196.655.014</populacao>
   </pais>
   <pais sigla="AR">
       <nome>Argentina</nome>
       <populacao>40.764.561</populacao>
   </pais>
</paises>

Inicialmente, apresentamos na Listagem 2 um programa que utiliza a classe XML para converter o documento XML de países para um objeto JSON. Em primeiro lugar, o XML é montado em uma variável do tipo String. Em seguida, o seu conteúdo é importando para uma variável do tipo JSONObject do pacote “org.json”. A partir daí, basta utilizar o método toString() para gerar uma string JSON contendo as informações dos países.

Listagem 2: Programa para Conversão de XML para JSON

import org.json.*;

public class Json2XML {

	public static void main(String[] args) throws JSONException {
		
		//--------------------------------------
		// (1) monta "paises.xml" em uma string
		//--------------------------------------
				
		String xmlString = "<?xml version=\"1.0\"?>" + 
					"<paises>" + 
						"<pais sigla=\"BR\">" + 
							"<nome>Brasil</nome>" + 
							"<pop

...

1. Introdução

No artigo que se encontra publicado no seguinte link: http://www.devmedia.com.br/trabalhando-com-json-em-java-o-pacote-org-json/25480, foi apresentada a biblioteca “org.json” que permite o processamento de JSON em programas Java. As instruções detalhadas para obtenção e configuração da biblioteca foram mostradas, assim como uma série de exemplos de utilização da mesma em programas Java.

Neste artigo, vamos utilizar a biblioteca “org.json”, porém com uma abordagem um pouco mais avançada. O objetivo é apresentar um programa Java capaz de manipular um objeto JSON com estrutura complexa. Definimos como objeto complexo aquele que possui uma ou mais dentre as seguintes características:

• Arrays;
• Hierarquias (ou Objetos dentro de Objetos);
• Informações Opcionais.

2. Um Exemplo de Estrutura Complexa

O pequeno banco de dados “devmovies.json”, mostrado na Listagem 1, é um exemplo de estrutura complexa no formato JSON. Trata-se de um banco de dados sobre cinema que armazena as informações referentes a dois filmes hipotéticos: “Os Arquivos Json” e “Sexta-feira 13: JSON Vive”.

Listagem 1: devmovies.json

{
	"devmovies":
		{
		"filme":
			[
			{
				"id":1,
				"titulo":"Os Arquivos JSON ",
				"ano":1998,
				"resumo":"A história dos arquivos muito leves",
				"generos":["Ação","Sci-fi","Drama"],
				"elenco":["Gillian Triggerson","David Markupovny"]
			},
			{
				"id":2,
				"titulo":"Sexta-feira 13: JSON vive",
				"ano":1986,				
				"generos":["Ação","Horror"],
				"elenco":["Ann Labelvalue Pair", "Jennifer Json", "John Java"]
			}
			]
		}
}

No exemplo da Listagem 1, “devmovies” é um objeto cujo conteúdo é um outro objeto, denominado “filme”. Ou seja, logo no início do arquivo JSON temos um tipo de hierarquia simples. O objeto “filme”, por sua vez, é um array onde cada elemento representa um filme. Os dados armazenados para os filmes são: “id” (inteiro), “título” (String), “ano” (inteiro), “resumo” (informação opcional do tipo String – veja que o segundo filme não possui um resumo cadastrado), classificação dos gêneros do filme (o array de String “generos”) e elenco (array de String “elenco”).

3. Processando a Estrutura “devmovies.json”

O programa da Listagem 2 utiliza o pacote “org.json” para processar o banco de dados “devmovies.json”. Resumidamente o programa funciona da seguinte forma. Em primeiro lugar, montamos o banco de dados em uma variável do tipo String. Em seguida, importamos o seu conteúdo para uma variável do tipo JSONObject do pacote “org.json”. A partir daí, o programa mostra como podemos utili

...

1. Introdução

JSON pode ser definido como um modelo para o armazenamento e troca de informações no formato texto. Suas principais características conceituais foram apresentadas em um recente artigo do portal Devmedia, disponível no link a seguir: http://www.devmedia.com.br/introducao-ao-formato-json/25275.

Este artigo aborda a manipulação de JSON na linguagem Java através da biblioteca “org.json”. Esta biblioteca foi desenvolvida pelo próprio “mentor” do modelo JSON, Douglas Crockford, e se tornou uma das mais conhecidas e utilizadas pelos desenvolvedores Java. Trata-se de um pacote composto por um conjunto classes / interfaces Java que podem ser estudadas, adaptadas e utilizadas livremente por qualquer desenvolvedor. A principal característica da “org.json” é que ela trabalha lendo todo o documento JSON para a memória, em um processo similar ao feito pela API DOM para processamento de XML.

O restante do artigo está dividido da seguinte forma. A Seção 2 descreve os passos para a obtenção e configuração da biblioteca. A Seção 3 é a principal do artigo, abordando a utilização da “org.json” em programas Java. Por fim, a Seção 4 apresenta as conclusões e comentários finais.

2. Download e Configuração

Para obter o pacote “org.json”, execute as etapas a seguir:

Passo 1: acesse o site http://www.json.org/java/. Será exibida uma tabela relacionando todas as classes que compõem o pacote (Figura 1). Clique em qualquer link da primeira coluna (Source), como por exemplo JSONObject.java.

Figura 1: Web site do pacote “org.json”

Passo 2: você será levado para uma página do github, onde poderá fazer download de um arquivo compactado contendo todos os fontes que compõem o pacote. Para isto, basta clicar no link Downloads, destacado na Figura 2 (ele fica localizado no canto direito da tela, mais ou menos na parte superior).

Figura 2: Link para download

Passo 3: A seguir será apresentada uma tela para que você escolha o formato do arquivo que deseja receber (“zip” ou “tar.gz”). Basta clicar no botão correspondente e o download será efetuado.

Após realizar o download, você pode criar um ambiente para testar o pacote. Se você utiliza o Eclipse ou Netbeans, basta criar um package chamado “org.json” em seu projeto e descompactar os arquivos “.java” que compõem a biblioteca dentro desse package.

Se você ainda tem pouca experiência em Java ou não utiliza nenhuma IDE, execute os passos descritos a seguir para criar o ambiente de teste.

Passo 1: Crie uma pasta para servir como pasta do projeto (por exemplo: C:\TESTE). Dentro desta pasta, crie uma pasta chamada org. Dentro da pasta org, crie uma pasta chamada json. A estrutura completa é mostrada na Figura 3.

Figura 3: Estrutura de pastas

Passo 2: Descompacte os arquivos da biblioteca para a pasta C:\TESTE\org\json.

IMPORTANTE: você pode descompactar todos os arquivos contidos no “zip”, porém apenas os sete arquivos relacionados a seguir é que realmente compõem a biblioteca (os outros arquivos contidos no “zip” são apenas utilitários):

• JSONArray.java
• JSONException.java
• JSONObject.java
• JSONString.java
• JSONStringer.java
• JSONTokener.java
• JSONWriter.java

3. Utilizando o Pacote org.json

Após a criação do ambiente de teste, estamos prontos para escrever programas que utilizem o pacote “org.json”. A classe principal, ou seja, a que você mais irá utilizar, é a JSONObject. Uma variável deste tipo armazena um objeto JSON. Segundo a definição do Javadoc desta classe, um objeto JSON é uma coleção não ordenada de pares nome/valor. Os métodos get() e opt() podem ser utilizados para acessar os valores por nome, enquanto o método put() serve para modificar valores. Na Listagem 1 apresentamos um exemplo de programa que cria um JSONObject para armazenar dados de um filme. Os campos (ou pares nome/valor) “titulo”, “ano” e “genero” são inseridos um por um, com o uso do método put(). Em seguida, o objeto é serializado para uma string com o uso do método toString() (um dos que você mais vai usar na prática). O programa também mostra como usar o método put() para modificar o valor de um campo e como utilizar o get() para recuperar um determinado valor. É importante observar que é necessário importar as classes JSONObject e JSONException, além de ser preciso tratar uma exceção do tipo JSONException.

Listagem 1: Criando um objeto JSON e utilizando os métodos put(), get() e toString()

import org.json.JSONException;
import org.json.JSONObject;

public class TesteOrgJson1 {

	public static void main(String[] args) throws JSONException {
		
		/* -------------------------------------------------------
		 * TESTE 1 
		 * cria um JSONObject para armazenar dados de um filme
		 * -------------------------------------------------------*/
		
		//instancia um novo JSONObject
		JSONObject my_obj = new JSONObject();

		//preenche o objeto com os campos: titulo, ano e genero
		my_obj.put("titulo", "JSON x XML: a Batalha Final");
		my_obj.put("ano", 2012);
		my_obj.put("genero", "Ação");
		
		//serializa para uma string e imprime
		String json_string = my_obj.toString();
		System.out.println("objeto original -> " + json_string);
		System.out.println();
		
		//altera o titulo e imprime a nova configuração do objeto
		my_obj.put("titulo", "JSON x XML: o Confronto das Linguagens");
		json_string = my_obj.toString();
		System.out.println("objeto com o título modificado -> " + json_string);
		System.out.println();
		
		//recupera campo por campo com o método get() e imprime cada um
		String titulo = my_obj.getString("titulo");
		Integer ano = my_obj.getInt("ano");
		String genero = my_obj.getString("genero");
		
		System.out.println("titulo: " + titulo);
		System.out.println("ano: " + ano);
		System.out.println("ge

...