Danilo Antônio Leite. Todo o desenvolvimento dos algoritmos e os testes foram realizados em um computador com as seguintes configurações:

Transcrição

1 PÓS GRADUAÇÃO EM MODELAGEM MATEMÁTICA E COMPUTACIONAL - CEFET-MG ALGORITMOS E ESTRUTURAS DE DADOS - PROF. DRA. CRISTINA D. MURTA TRABALHO PRÁTICO N o 2 IMPLEMENTAÇÃO, EXECUÇÃO, TESTE E MEDIÇÃO EM TABELAS HASHING Danilo Antônio Leite dalsoftinf@gmail.com Configurações do Ambiente Utilizado para os Testes Todo o desenvolvimento dos algoritmos e os testes foram realizados em um computador com as seguintes configurações:. Dell Vostro 3450 (laptop). Processador Inter(R) Core(TM) i5-2450m CPU 2.50 GHz. Memória RAM: 6 GB. Sistema Operacional: Windows 7 Professional 64 Bits Service Pack 1. HD: 605 GB na partição Windows Os códigos foram implementados utilizando NetBeans IDE e linguagem Java (JDK 1.8). A execução dos testes dos algoritmos em Java também foi realizada com a utilização do ambiente NetBeans. Projeto de um TAD Dicionário para armazenar uma base de dados de URLs O TAD deverá possuir as seguintes características básicas: Inicializar tabela: inicialização da tabela vazia. Inserir URL: insere uma URL na tabela. Pesquisar URL: realiza busca de uma URL na tabela, retornando o elemento buscado em caso de sucesso e o número de comparações necessário para encontrá-lo; em caso de insucesso retornar o número de comparações necessários para descobrir o resultado. Importar dados de um arquivo de URLs: insere N URLs na tabela a partir de um arquivo texto fornecido. Relato do Experimento 1. Implementação da Tabela Hashing com Listas Encadeadas a) O tamanho da tabela adotado para o projeto foi de 1071 posições, que corresponde a aproximadamente 10% da quantidade de registros a ser inserida nesta tabela, conforme recomendado pelos referenciais teóricos sobre o assunto. Neste caso inicialmente estima-se uma quantidade média esperada de 10 colisões por posição na tabela. Os elementos serão armazenadas em listas encadeadas vinculadas a cada posição da tabela hash. Em caso de colisão os elementos serão armazenados em uma lista encadeada vinculada à posição de colisão. A inserção de novos elementos será realizada sempre na primeira posição da lista encadeada para evitar percorrer a lista no momento da inserção.

2 A construção foi iniciada pela lista encadeada. Primeiramente foi implementado o elemento de lista através da classe ListElement.java. Em seguida foi criada uma estrutura de lista encadeada através da classe ListSet.java utilizando o elemento criado anteriormente, e definindo as operações necessárias ao funcionamento da lista, em especial a operação de inclusão add que é responsável por inserir um elemento (URL) na primeira posição da lista encadeada. Foram realizados em seguida os testes de funcionamento dessa estrutura e acrescentadas operações para exibição de resultados e outros dados necessários. Algum código excedente (além do essencialmente proposto neste trabalho) teve que ser gerado para fins de testes, visibilidade e monitoramento de resultados. Estes foram utilizados durante os testes e a fase de construção dos programas, por isso fazem parte da documentação anexa que integra este relatório ao final do documento. As estruturas foram adicionadas gradativamente e todas foram testadas individualmente antes de se partir para a próxima etapa. Decidiu-se por incluir uma classe FindResults.java para facilitar a obtenção de resultados (número de comparações na lista, retorno da busca - encontrado ou não encontrado, posição da tabela para fins de monitoramento e testes) de uma pesquisa, pensando em extrair posteriormente as estatísticas solicitadas. Finalmente foi implementada a estrutura hashtablelistset.java que disponibiliza as funções do TAD proposto: inicialização da lista, função hash, inclusão em nível de tabela hash, resultados de pesquisa, estatísticas, além de exibição de todo o conteúdo da tabela e das quantidades de URLs armazenadas por posição. Esta última funcionalidade foi utilizada para geração de dados para os gráficos de distribuição que foram gerados para facilitar a avaliação da eficácia da função hash utilizada. Outras funções complementares tiveram que ser implementadas: leitura e importação de dados de arquivo texto (URLs), sorteio de N URLs para realização de pesquisas, ordenação de vetor de inteiros para fins de eficácia ao extrair dados do arquivo para sorteio e cálculo das estatísticas de comparações. A classe txtfile.java contém as funções para importar os dados do arquivo e incluir na tabela hash (utilizando funções das classes hashtablelistset.java (utiliza também hashtableopenadress.java que trata de hashing com endereçamento aberto linear). Para a função hash foram consideradas as seguintes variáveis e características para montagem do resultado:. Tamanho da URL;. O código numérico correspondente a cada caractere da URL;. A posição de cada caractere da URL;. O tamanho projetado da tabela hash;. Utilização de operações para geração de um inteiro longo: soma acumulada, potenciação, divisão;. Aplicação do resto da divisão para gerar um valor final dentro dos limites esperados. Finalmente, após alguns testes e pequenos ajustes a versão final do algoritmo da função hash ficou definido como segue:

3 public int hash(string url){ int h = -1; // retorno da função hash para posicionar na tabela int n = url.length(); // tamanho da string if (n == 0) return h; long codurl = 0; for(int i = 0; i < n; i++){ codurl = (long) (codurl + url.charat(i)*math.pow(2, n-i)/(i+1)); //gera um código inteiro baseado nos caracteres da string } codurl = (long) codurl/n; h = (int) (codurl % TABLE_SIZE); // o resultado do hash é o codurl dividido pelo tamanho da tabela hash return h; } Ao fazer os primeiros testes utilizando a versão inicial da função hash, ao inserir as URLs na tabela hash com listas encadeadas percebeu-se uma distribuição irregular, com elevado número de colisões em algumas posições da tabela conforme pode ser visualizado no gráfico a seguir: Qtd. URLs 500 Distribuição das URLs (quantidades) por posição da Tabela Hash - Resultado Insatisfatório Posição Hash Nesta situação percebe-se claramente que a função Hash utilizada não gerou uma boa distribuição das URLs, pois houve número elevado de colisões em determinadas posições. O maior número de colisões obtido para uma mesma posição foi 472 neste caso. Houve ainda 7 posições zeradas (sem nenhuma URL). Diante desse cenário ficou evidente a necessidade de se alterar ou substituir a função Hash.

4 Em seguida foi realizado um ajuste na função hash e resultados melhores foram obtidos. Desta vez o número máximo de colisões em uma mesma posição foi igual a 43. Houve 2 posições zeradas. Nesse caso houve uma melhor distribuição das URLs na tabela hash. A distribuição não foi uniforme (perfeita) porém o resultado foi satisfatório comparado à primeira tentativa. A tabela a seguir apresenta a visão da distribuição da quantidade de URLs por posição da tabela hash com listas encadeadas, após o procedimento de inserção das URLs: Qtd. URLs 50 Distribuição de URLs (quantidades) na tabela Hash com Listas Encadeadas Posição Hash A seguir é exibido o resultado da distribuição após o teste utilizando a mesma função hash da situação anterior, mas a massa de dados contendo as URLs foi ajustada. Como havia código HTML em muitas URLs do arquivo original, diversas URLs ficaram com tamanho maior e informações excedentes e redundantes por conta do código HTML, gerando maior número de colisões. Utilizando o arquivo contendo somente as URLs "enxutas", foi possível perceber uma melhora significativa na distribuição das URLs nas posições da tabela hash. Esse último resultado foi adotado como referência para os testes subsequentes e a função hash foi considerada satisfatória para os propósitos deste trabalho.

5 25 Qtd. URLs Distribuição de URLs (quantidades) na tabela Hash com Listas Encadeadas Posição Hash A seguir é apresentada uma visão parcial dos dados após a inserção na tabela hash com listas encadeadas. Os dados na íntegra podem ser visualizados através da execução do programa: run: Linha 0 ==> 1.[ com.br];5.[idgnow.uol.com.br];6.[flip.correiodopovo.com.br];7.[espacodocasamento.com.br];8.[ca rmagazine.uol.com.br];9.[arvitec.com.br]; Linha 1 ==> 1.[ om.br]; Linha 2 ==> 1.[ blogspot.com.br];5.[openx.ambientebrasil.com.br];6.[knorte.com.br];7.[img4.reembolsocentral.co m.br];8.[facebuug.blogspot.com.br];9.[embalando.com.br];10.[dpaonline.dpaschoal.com.br];11.[cl ubedaboacompra.com.br]; Linha 3 ==> 1.[ j.gov.br];5.[ Linha 4 ==> 1.[ a.com.br];5.[siteforte.com.br];6.[parqueestadualcamposdojordao.vilabol.uol.com.br];7.[metodist alondrina.com.br];8.[italo.com.br];9.[img6.clickjogos.uol.com.br];10.[eros.com.br];11.[assineg lobocondenast.com.br];12.[apachecompany.com.br]; Linha 5 ==> 1.[ eiraopreto.com.br];... Linha 1068 ==> 1.[ ;4.[ ];12.[euqueroquero.com.br]; Linha 1069 ==> 1.[ roserinstituto.com.br];5.[ te.com.br];8.[

6 aimoveis.com.br];12.[pandabrinquedos.com.br];13.[news.autoz.com.br];14.[loja.trisbrasil.com.br ];15.[dicasdeingrid.blogspot.com.br]; Linha 1070 ==> 1.[ desmensagens.com.br];5.[ com.br];8.[personare.com.br];9.[gazetaderibeirao.rac.com.br];10.[fotos.gruporscom.com.br];11.[ cursocpa.com.br];12.[canilsetimadinastia.com.br]; b) A seguir são apresentados alguns resultados da análise estatística dos dados cadastrados na tabela hash com listas encadeadas. Foram sorteadas 1000 URLs da base e em seguida foram realizadas buscas para cada uma delas, e ao final foram obtidas as estatísticas contendo os seguintes dados referentes ao número de comparações para encontrar as URLs: menor valor, maior valor, média e mediana para o número de comparações. Estatísticas para 1000 URLs CADASTRADAS Teste 1 Teste 2 Teste 3 Teste 4 Maior Valor: 20 Média: 6, Mediana: 6, Maior Valor: 20 Média: 5, Mediana: 6, Maior Valor: 17 Média: 6, Mediana: 6, Maior Valor: 22 Média: 5, Mediana: 5, Teste 5 Teste 6 Teste 7 Teste 8 Maior Valor: 17 Média: 5, Mediana: 5, Maior Valor: 21 Média: 6, Mediana: 6, Maior Valor: 19 Média: 5, Mediana: 5, Maior Valor: 19 Média: 5, Mediana: 6, Teste 9 Teste 10 Teste 11 Teste 12 Maior Valor: 19 Média: 6, Mediana: 6, Maior Valor: 22 Média: 6, Mediana: 6, Maior Valor: 19 Média: 6, Mediana: 6, Maior Valor: 18 Média: 5, Mediana: 6, c) A seguir são apresentados resultados da análise estatística dos dados NÃO cadastrados na tabela hash com listas encadeadas. Foram sorteadas 1000 URLs da base e em seguida estas foram alteradas em 1 caractere. Posteriormente foram realizadas buscas para cada uma delas, e ao final foram obtidas as estatísticas contendo os seguintes dados referentes ao número de comparações necessários para identificar que as URLs não existem na tabela hash: menor valor, maior valor, média e mediana para o número de comparações.

7 Estatísticas para 1000 URLs NÃO CADASTRADAS (ALTERADAS) Teste 1 Teste 2 Teste 3 Teste 4 Menor Valor: 3 Maior Valor: 22 Média: 10, Mediana: 10,00000 Menor Valor: 2 Maior Valor: 21 Média: 10, Mediana: 10,00000 Menor Valor: 2 Maior Valor: 21 Média: 10, Mediana: 10,00000 Menor Valor: 2 Maior Valor: 22 Média: 9, Mediana: 10,00000 Teste 5 Teste 6 Teste 7 Teste 8 Menor Valor: 3 Maior Valor: 22 Média: 9, Mediana: 10,00000 Menor Valor: 2 Maior Valor: 22 Média: 9, Mediana: 10,00000 Menor Valor: 2 Maior Valor: 21 Média: 9, Mediana: 10,00000 Menor Valor: 2 Maior Valor: 22 Média: 10, Mediana: 10, Teste 9 Teste 10 Teste 11 Teste 12 Menor Valor: 2 Maior Valor: 22 Média: 10, Mediana: 10,00000 Menor Valor: 2 Maior Valor: 22 Média: 9, Mediana: 10,00000 Menor Valor: 2 Maior Valor: 22 Média: 9, Mediana: 10,00000 d) Fazer uma tabela com os resultados e comparar com a teoria. Menor Valor: 2 Maior Valor: 22 Média: 10, Mediana: 10, Analisando os dados abaixo percebe-se que o melhor caso (menor valor) em todos os testes resultou em 1 comparação somente. O valor da mediana entre 5 e 6 mostra que para mais da metade dos elementos amostrados o número de colisões foi abaixo da média esperada de 10 colisões. A média dos valores em torno de 6 também reforça a ideia de um número de colisões um pouco abaixo do esperado para os dados amostrados. O pior caso (maior valor) nos permite visualizar o número máximo de colisões na mesma posição da tabela hash, o que sugere uma boa distribuição dos dados. Estatísticas de 1000 URLs Cadastradas - Número de Comparações T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 Menor Valor Maior Valor Média 6,083 5, ,931 5,923 6,224 5,892 5,876 6,165 6,076 6,027 5,971 Mediana Para a pesquisa de URLs não cadastradas o menor valor corresponde às posições onde houve menor número de colisões. O maior valor representa o número máximo de colisões dentro da amostra, e média é bem próxima da média estimada e esperada e a mediana com valor fixo igual a 10 mostra que apesar da distribuição não ser uniforme (perfeita), esse valor sugere uma boa distribuição dos dados como já mostrado anteriormente no gráfico de distribuição. Estatísticas de 1000 URLs NÃO Cadastradas - Número de Comparações T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 Menor Valor Maior Valor Média 10,05 10,1 10,1 9,953 9,959 9,874 9,996 10,016 10,008 9,882 9,926 10,062 Mediana

8 A seguir são exibidos os gráficos para melhor visualização dos resultados apresentados: 25 Estatísticas de 1000 URLs NÃO Cadastradas Número de Comparações Menor Valor Maior Valor Média Mediana

9 2. Implementação da Tabela Hashing com Endereçamento Aberto a) O tamanho da tabela adotado para o hashing com endereçamento aberto foi de posições, que corresponde exatamente ao dobro da quantidade de registros a ser inserida nesta tabela, conforme recomendado pelos referenciais teóricos sobre o assunto. A estrutura dessa tabela é composta basicamente de um vetor de Strings, da função hash e da operação de inclusão, além de propriedades auxiliares e os métodos de pesquisa e estatísticas. Em caso de colisão no momento da inclusão de uma URL, será procurada a próxima posição livre para inclusão. A construção foi facilitada devido ao aproveitamento das estruturas geradas anteriormente, sendo necessário algumas adaptações para trabalhar com o vetor de Strings. Os métodos e a estrutura são similares aos gerados anteriormente para a tabela hash com listas encadeadas, porém os códigos foram adaptados para trabalhar com a nova estrutura. A classe responsável pela estrutura de endereçamento aberto é hashtableopenadress.java. A função hash irá diferir da função utilizada anteriormente somente pelo tamanho da tabela (neste caso 21392), que é utilizado para limitar os valores finais gerados pela função. Foram realizados testes com valores inferiores mas os resultados não se mostraram satisfatórios, pois o número de dados agrupados aumentaram consideravelmente em relação à configuração atual. A seguir é apresentada a versão final da função hash utilizada, sendo que o valor da constante TABLE_SIZE neste caso foi configurado para 21392: public int hash(string url){ int h = -1; // retorno da função hash para posicionar na tabela int n = url.length(); // tamanho da string if (n == 0) return h; long codurl = 0; for(int i = 0; i < n; i++){ codurl = (long) (codurl + url.charat(i)*math.pow(2, n-i)/(i+1)); //gera um código inteiro baseado nos caracteres da string } codurl = (long) codurl/n; h = (int) (codurl % TABLE_SIZE); // o resultado do hash é o codurl dividido pelo tamanho da tabela hash return h; }

10 A seguir são exibidos dados parciais das URLs após a inclusão das mesmas na tabela hash com endereçamento aberto:... Linha 22 ==> bdp3100.caldeiraodeofertas.com.br Linha 23 ==> lenteszeiss.com.br Linha 24 ==> Linha 25 ==> culinaria.terra.com.br Linha 26 ==> Linha 27 ==> Linha 28 ==> Linha 29 ==> Linha 30 ==> Linha 31 ==> lances.caldeiraodeofertas.com.br Linha 32 ==> Linha 33 ==> Linha 34 ==> Linha 35 ==> Linha 36 ==> servlet.pop.com.br Linha 37 ==> Linha 38 ==> Linha 39 ==> carros.peugeot.com.br Linha 40 ==> Linha 41 ==> Linha 42 ==> Linha 43 ==> Linha 44 ==> Linha 45 ==> wp.kzuka.com.br Linha 46 ==> Linha 47 ==> Linha 48 ==> Linha 49 ==> casacinepoa.com.br Linha 50 ==> minasdeouro.com.br Linha 51 ==> mrvhospitalar.com.br Linha 52 ==> Linha 53 ==> Linha 54 ==> Linha 55 ==> Linha 56 ==> Linha 57 ==> Linha 58 ==> Linha 59 ==> Linha 60 ==> parqueestadualcamposdojordao.vilabol.uol.com.br Linha 61 ==> Linha 62 ==> Linha 63 ==> Linha 64 ==> Linha 65 ==> Linha 66 ==> valehost.com.br Linha 67 ==> Linha 68 ==> colecionadorasdemoda.blogspot.com.br Linha 69 ==> Linha 70 ==> Linha 71 ==> crianca.ig.com.br Linha 72 ==> lojademotos.com.br Linha 73 ==> Linha 74 ==> Linha 75 ==> Linha 76 ==> usinadorock.com.br Linha 77 ==> Linha 78 ==> Linha 79 ==> Linha 80 ==> images.parperfeito.com.br Linha 81 ==> Linha 82 ==> Linha 83 ==> Linha 84 ==> Linha 85 ==> Linha 86 ==> Linha 87 ==> promaqrental.blogspot.com.br Linha 88 ==>

11 b) A seguir são apresentados alguns resultados da análise estatística dos dados cadastrados na tabela hash com endereçamento aberto. Foram sorteadas 1000 URLs da base e em seguida foram realizadas buscas para cada uma delas, e ao final foram obtidas as estatísticas contendo os seguintes dados referentes ao número de comparações para encontrar as URLs: menor valor, maior valor, média e mediana para o número de comparações. Estatísticas para 1000 URLs CADASTRADAS Teste 1 Teste 2 Teste 3 Teste 4 Maior Valor: 27 Média: 1, Maior Valor: 42 Média: 1, Maior Valor: 36 Média: 1, Maior Valor: 45 Média: 1, Teste 5 Teste 6 Teste 7 Teste 8 Maior Valor: 42 Média: 1, Maior Valor: 62 Média: 1, Maior Valor: 62 Média: 1, Maior Valor: 17 Média: 1, Teste 9 Teste 10 Teste 11 Teste 12 Maior Valor: 31 Média: 1, Maior Valor: 16 Média: 1, Maior Valor: 21 Média: 1, Maior Valor: 25 Média: 1, c) A seguir são apresentados resultados da análise estatística dos dados NÃO cadastrados na tabela hash com endereçamento aberto. Foram sorteadas 1000 URLs da base e em seguida estas foram alteradas em 1 caractere. Posteriormente foram realizadas buscas para cada uma delas, e ao final foram obtidas as estatísticas contendo os seguintes dados referentes ao número de comparações necessários para identificar que as URLs não existem na tabela hash: menor valor, maior valor, média e mediana para o número de comparações.

12 Estatísticas para 1000 URLs NÃO CADASTRADAS (ALTERADAS) Teste 1 Teste 2 Teste 3 Teste 4 Menor Valor: 0 Maior Valor: 73 Média: 3, Menor Valor: 0 Maior Valor: 76 Média: 3, Menor Valor: 0 Maior Valor: 75 Média: 3, Menor Valor: 0 Maior Valor: 67 Média: 3, Teste 5 Teste 6 Teste 7 Teste 8 Menor Valor: 0 Maior Valor: 79 Média: 3, Menor Valor: 0 Maior Valor: 75 Média: 3, Menor Valor: 0 Maior Valor: 75 Média: 3, Menor Valor: 0 Maior Valor: 67 Média: 3, Teste 9 Teste 10 Teste 11 Teste 12 Menor Valor: 0 Maior Valor: 80 Média: 3, Menor Valor: 0 Maior Valor: 66 Média: 3, Menor Valor: 0 Maior Valor: 80 Média: 3, Menor Valor: 0 Maior Valor: 79 Média: 4, d) Fazer uma tabela com os resultados. Analisar e comparar com a teoria. Conforme análise dos dados a seguir, percebe-se que o melhor caso (menor valor) em todos os testes resultou em 1 comparação somente. O fato de a mediana também resultar em 1 mostra que para a maioria dos elementos amostrados não houve colisão. A média dos valores sendo pouco maior que 1 mostra que o número de colisões foi baixo para a grande maioria dos elementos da tabela, ou seja, houve uma boa distribuição dos dados na tabela hash com endereçamento aberto. O pior caso (maior valor) nos permite visualizar o agrupamento máximo dentro dos dados amostrados, ou seja, regiões da tabela onde houve maior concentração dos dados e mais colisões. Estatísticas de 1000 URLs Cadastradas - Número de Comparações T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 Menor Valor Maior Valor Média 1,437 1,497 1,435 1,432 1,42 1,568 1,572 1,32 1,515 1,337 1,371 1,396 Mediana Para URLs não cadastradas o menor valor corresponde às posições vazias da tabela hash com endereçamento linear, ou seja. Nesse caso a implementação não está contando a comparação necessária para identificar a posição vazia (nula), por isso o resultado é zero. Se essa comparação for necessária para alguma análise, deverá ser considerada 1 comparação a mais para todos os resultados. Nesta implementação essa comparação está sendo desconsiderada para as estatísticas apresentadas a seguir. O pior caso permite visualizar os agrupamentos maiores dentro da amostra. A média de comparações entre 3 e 4 operações dentro da amostragem sugere uma boa distribuição. A mediana de valor 1 reforça esse ponto, considerando que para a maioria das URLs pesquisadas houve somente 1 comparação para identificar a não existência da mesma.

13 Estatísticas de 1000 URLs NÃO Cadastradas - Número de Comparações T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 Menor Valor Maior Valor Média 3,538 3,656 3,536 3,15 3,182 3,536 3,616 3,576 3,183 3,084 3,77 4,095 Mediana A seguir são exibidos os gráficos para melhor visualização dos resultados: Estatísticas de 1000 URLs Cadastradas Número de Comparações Menor Valor Maior Valor Média Mediana Estatísticas de 1000 URLs Não Cadastradas Número de Comparações Menor Valor Maior Valor Média Mediana

14 Considerações Finais A implementação de tabelas hashing mostrou-se uma técnica altamente eficiente, eficaz e robusta para criação de estruturas de indexação de dados, com elevado ganho de desempenho nos resultados das pesquisas. A implementação exige muitos testes e especial cuidado na elaboração da estrutura de dados e da função hash utilizada. Muitas variações da função hash podem ser testadas e é possível alcançar ainda melhoria na distribuição dos dados, dependendo da função hash utilizada. A estrutura de tabela hash com listas encadeadas se mostrou mais eficaz para pesquisas na base de dados utilizada neste trabalho.

15 Anexos (código fonte) 1 2 package table; 3 4 import inputfile.txtfile; 5 import list.findresults; 6 import table.hashtablelistset; 7 8 /** 9 * Teste de tabela hash com listas encadeadas 10 danilo.leite 11 */ 12 public class TestHashTableListSet { public static void main(string[] args) { txtfile arquivourl = new txtfile(); 19 hashtablelistset listaurl; 20 arquivourl.sethashtablels(); 21 //String lista = arquivourl.getlisturl(); 22 listaurl = arquivourl.gethashtablels(); 23 // exibir o conteúdo da tabela hash 24 listaurl.showhashtable(); 25 System.out.println(); 26 System.out.println("*****Estatísticas para 1000 URLs CADASTRADAS*****"); 27 listaurl.findstats(true); 28 System.out.println(); 29 System.out.println("*****Estatísticas para 1000 URLs NÃO CADASTRADAS (ALTERADAS)*****"); 30 listaurl.findstats(false); } } 1 package table; 2 3 import inputfile.txtfile; 4 import list.findresults; 5 6 /** 7 * Teste de tabela hash com endereçamento aberto linear 8 danilo.leite 9 */ 10 public class TestHashTableOpen { public static void main(string[] args) { txtfile arquivourl = new txtfile(); 15 hashtableopenadress listaurl; 16 arquivourl.sethashtableopen();

16 17 //String lista = arquivourl.getlisturl(); 18 listaurl = arquivourl.gethashtableopen(); 19 // exibir o conteúdo da tabela hash 20 listaurl.showhashtableopen(); 21 System.out.println(); 22 System.out.println("*****Estatísticas para 1000 URLs CADASTRADAS*****"); 23 listaurl.findstats(true); 24 System.out.println(); 25 System.out.println("*****Estatísticas para 1000 URLs NÃO CADASTRADAS (ALTERADAS)*****"); 26 listaurl.findstats(false); } } 31 1 package table; 2 3 import inputfile.txtfile; 4 import list.listset; 5 import list.findresults; 6 import vectorint.vectorint; 7 8 /** tabela hash com listas encadeadas 9 * 10 danilo.leite 11 */ 12 public class hashtablelistset { 13 private final int TABLE_SIZE = 1071; // tamanho da tabela hash 14 private ListSet[] htable; 15 private ListSet aux; 16 private final int NUMBER_COMPARES = 1000; // número de URLs a serem sorteadas public hashtablelistset(){ 19 htable = new ListSet[TABLE_SIZE]; 20 } public int hash(string url){ 23 int h = -1; // retorno da função hash para posicionar na tabela 24 int n = url.length(); // tamanho da string 25 if (n == 0) 26 return h; 27 long codurl = 0; 28 for(int i = 0; i < n; i++){ 29 codurl = (long) (codurl + url.charat(i)*math.pow(2, n-i)/(i+1)); //gera um código inteiro baseado nos caracteres da string 30 } 31 codurl = (long) codurl/n; 32 h = (int) (codurl % TABLE_SIZE); // o resultado do hash é o codurl dividido pelo tamanho da tabela hash

17 33 return h; 34 } public void add(string url){ 37 int posicao = hash(url); 38 if (posicao == -1) 39 return; 40 if (this.htable[posicao] == null) 41 this.htable[posicao] = new ListSet(); 42 this.htable[posicao].add(url); 43 } public FindResults find(string url){ 46 FindResults results = new FindResults(); 47 int posicao = hash(url); 48 if (posicao == -1) 49 return results; 50 results = this.htable[posicao].findinlist(url); // pesquisa na posição da tabela onde está a lista encadeada 51 results.sethashposition(posicao); // guarda a posição da tabela hash 52 return results; // retorna posição, número de comparações, resultado da pesquisa 53 } 54 // realiza pesquisa sobre N URLs sorteadas e fornece estatísticas de números de comparações: 55 // menor valor, maior valor, média e mediana 56 public void findstats(boolean allexist){ 57 // allexist: parâmetro para indicar se na pesquisa realizada estão sendo utilizadas URLs existentes ou não existentes na base 58 // allexist será verdadeiro se todas as URLs pesquisadas existem na base 59 // allexist será falso se todas as URLs pesquisadas não existem na base 60 int minorvalue; // menor valor 61 int majorvalue; // maior valor 62 double mediavalue; // media 63 double medianavalue; // mediana 64 int sumvalues = 0; // soma dos valores 65 int rest; 66 boolean allregistered = true; 67 boolean allnotregistered = true; // flags para indicar se todas as URLs pesquisadas são cadastradas ou não 68 // allregistered será falso caso 1 URL não seja encontrada; allnotregistered será falso caso 1 URL seja encontrada; 69 int[] comparevalues = new int[this.number_compares]; // armazena a quantidade de comparações 70 FindResults result = new FindResults(); // resultados de uma pesquisa 71 txtfile arquivourl = new txtfile(); 72 arquivourl.sortlines(this.number_compares); // seleciona aleatoriamente [NUMBER_COMPARES] do arquivo 73 String newurl; 74 if (!allexist){ // se prentende realizar pesquisas com URLs inexistentes (alteradas)

18 75 // alterar as URLs em 1 caractere: o caracter 'X' irá sobrepor 1 caractere da URL aproximadamente no meio da String 76 for(int n = 0; n < this.number_compares; n++){ 77 newurl = arquivourl.getsortlist()[n]; 78 newurl = newurl.substring(0, (int) newurl.length()/2) + 'X' + newurl.substring((int) (newurl.length()/2)+2, newurl.length()-1); // substitui 1 caracter por 'X' 79 arquivourl.setsortlistitem(newurl, n); // atualiza 80 } 81 } 82 // realiza as pesquisas e monta vetor com número de comparações das pesquisas 83 for(int i = 0; i < this.number_compares; i++) { 84 result = this.find(arquivourl.getsortlist()[i]); 85 comparevalues[i] = result.getnumberofcomparison(); 86 if (result.isfound()){ // se foi encontrado 87 if (allnotregistered) allnotregistered = false; // se houver uma ocorrência encontrada, será falso 88 } 89 else 90 if (allregistered) allregistered = false; // se uma ocorrência não for encontrada, será falso 91 } 92 // ordenar os resultados das comparações 93 VectorInt vet = new VectorInt(); // classe que contém o método de ordenação 94 comparevalues = vet.selectionorder(comparevalues); 95 // fim ordenação 96 // comparevalues = 97 // calcula as estatísticas 98 minorvalue = comparevalues[0]; // após a ordenação, o primeiro valor é o menor valor 99 majorvalue = comparevalues[this.number_compares-1]; // o maior valor encontra-se na última posição 100 for(int j = 0; j < this.number_compares; j++){ 101 // calcular aqui as medias percorrendo o vetor 102 sumvalues = sumvalues + comparevalues[j]; // faz o somatório 103 } 104 mediavalue = (double) sumvalues/this.number_compares; // calcula a média de comparações 105 // calcula a mediana 106 rest = this.number_compares % 2; // verificar se o tamanho do vetor é par 107 boolean ispair = (rest == 0); // se o resto da divisão for zero o tamanho do vetor é par 108 if (ispair) {// mediana no caso de vetor tamanho par 109 medianavalue = (double) (comparevalues[(this.number_compares/2)] + comparevalues[(this.number_compares/2)+1])/2; 110 }else 111 { 112 // mediana no caso de vetor tamanho ímpar

19 113 medianavalue = comparevalues[(this.number_compares/2)+1]; 114 } 115 System.out.printf("Menor Valor: %d\n", minorvalue); 116 System.out.printf("Maior Valor: %d\n", majorvalue); 117 System.out.printf("Média: %f\n", mediavalue); 118 System.out.printf("Mediana: %f\n", medianavalue); 119 if (allregistered) 120 System.out.println("TODAS as URLs pesquisadas foram encontradas."); 121 if (allnotregistered) 122 System.out.println("NENHUMA das URLs pesquisadas foi encontrada."); } // método para teste: visualizar conteúdo da tabela hash com listas encadeadas 128 public void showhashtable(){ 129 for(int i = 0; i < TABLE_SIZE; i++){ 130 System.out.printf("Linha %d ==> ",i); 131 if (this.htable[i] == null){ 132 System.out.print("Posição vazia"); 133 } 134 else{ 135 this.htable[i].showlist(); 136 } 137 System.out.println(); 138 } 139 } 140 // método para teste: visualizar o número de colisões por posição da tabela hash 141 public void showhashtablerecordsperline(){ 142 int majorline = 0; 143 int quantity = 0; 144 for(int i = 0; i < TABLE_SIZE; i++){ 145 System.out.printf("Linha %d ==> ",i); 146 if (this.htable[i] == null){ 147 System.out.print("Posição vazia"); 148 } 149 else{ 150 quantity = this.htable[i].sizelist(); 151 if (quantity > majorline) 152 majorline = quantity; 153 System.out.printf("%d registros",quantity); 154 } 155 System.out.println(); 156 } 157 System.out.printf("Número máximo de colisões: %d registros na mesma posição\n",majorline); 158 } } 161

20 1 package table; 2 3 import inputfile.txtfile; 4 import list.findresults; 5 import vectorint.vectorint; 6 7 /** tabela hash com endereçamento aberto linear 8 * 9 danilo.leite 10 */ 11 public class hashtableopenadress { 12 private final int TABLE_SIZE = 21392; // tamanho da tabela hash linear 13 private String[] htableopen; 14 private String aux; 15 private final int NUMBER_COMPARES = 1000; // número de URLs a serem sorteadas public hashtableopenadress(){ 18 htableopen = new String[TABLE_SIZE]; 19 } public int hash(string url){ 22 int h = -1; // retorno da função hash para posicionar na tabela 23 int n = url.length(); // tamanho da string 24 if (n == 0) 25 return h; 26 long codurl = 0; 27 for(int i = 0; i < n; i++){ 28 codurl = (long) (codurl + url.charat(i)*math.pow(2, n-i)/(i+1)); //gera um código inteiro baseado nos caracteres da string 29 } 30 codurl = (long) codurl/n; 31 h = (int) (codurl % TABLE_SIZE); // o resultado do hash é o codurl dividido pelo tamanho da tabela hash 32 return h; 33 } 34 // incluir elemento na tabela 35 public void add(string url){ 36 int posicao = hash(url); 37 if (posicao == -1) 38 return; 39 if (this.htableopen[posicao] == null) 40 this.htableopen[posicao] = url; 41 else // em caso de colisão (posição ocupada) 42 { // encontrar nova posição vazia 43 do { 44 posicao = posicao+1; 45 } while (this.htableopen[posicao]!= null); 46 this.htableopen[posicao] = url; // inclui em nova posição vazia 47 } 48 } 49

21 50 public FindResults find(string url){ 51 FindResults results = new FindResults(); 52 int posicao = hash(url); 53 if ((posicao == -1) (this.htableopen[posicao] == null)) 54 return results; 55 results.incnumberofcomparison();// incrementa número de comparações 56 // se encontrar na primeira posição 57 if (this.htableopen[posicao].equals(url)){ 58 results.setfound(true); 59 results.sethashposition(posicao); 60 return results; 61 } 62 posicao = posicao + 1; // proxima posição 63 while ((this.htableopen[posicao]!= null) && (!this.htableopen[posicao].equals(url))){ 64 posicao = posicao + 1; 65 results.incnumberofcomparison();// incrementa número de comparações 66 } 67 // se não achou 68 if (this.htableopen[posicao] == null){ 69 // termina a busca e retorna resultados 70 results.setfound(false); 71 results.sethashposition(posicao); 72 return results; 73 } 74 // se achou (os testes anteriores deram falso) 75 results.setfound(true); 76 results.sethashposition(posicao); 77 return results; 78 } // realiza pesquisa sobre N URLs sorteadas e fornece estatísticas de números de comparações: 81 // menor valor, maior valor, média e mediana 82 public void findstats(boolean allexist){ 83 // allexist: parâmetro para indicar se na pesquisa realizada estão sendo utilizadas URLs existentes ou não existentes na base 84 // allexist será verdadeiro se todas as URLs pesquisadas existem na base 85 // allexist será falso se todas as URLs pesquisadas não existem na base 86 int minorvalue; // menor valor 87 int majorvalue; // maior valor 88 double mediavalue; // media 89 double medianavalue; // mediana 90 int sumvalues = 0; // soma dos valores 91 int rest; 92 boolean allregistered = true; 93 boolean allnotregistered = true; // flags para indicar se todas as URLs pesquisadas são cadastradas ou não 94 // allregistered será falso caso 1 URL não seja encontrada; allnotregistered será falso caso 1 URL seja encontrada;

22 95 int[] comparevalues = new int[this.number_compares]; // armazena a quantidade de comparações 96 FindResults result = new FindResults(); // resultados de uma pesquisa 97 txtfile arquivourl = new txtfile(); 98 arquivourl.sortlines(this.number_compares); // seleciona aleatoriamente [NUMBER_COMPARES] do arquivo 99 String newurl; 100 if (!allexist){ // se prentende realizar pesquisas com URLs inexistentes (alteradas) 101 // alterar as URLs em 1 caractere: o caracter 'X' irá sobrepor 1 caractere da URL aproximadamente no meio da String 102 for(int n = 0; n < this.number_compares; n++){ 103 newurl = arquivourl.getsortlist()[n]; 104 newurl = newurl.substring(0, (int) newurl.length()/2) + 'X' + newurl.substring((int) (newurl.length()/2)+2, newurl.length()-1); // substitui 1 caracter por 'X' 105 arquivourl.setsortlistitem(newurl, n); // atualiza 106 } 107 } 108 // realiza as pesquisas e monta vetor com número de comparações das pesquisas 109 for(int i = 0; i < this.number_compares; i++) { 110 result = this.find(arquivourl.getsortlist()[i]); 111 comparevalues[i] = result.getnumberofcomparison(); 112 if (result.isfound()){ // se foi encontrado 113 if (allnotregistered) allnotregistered = false; // se houver uma ocorrência encontrada, será falso 114 } 115 else 116 if (allregistered) allregistered = false; // se uma ocorrência não for encontrada, será falso 117 } 118 // ordenar os resultados das comparações 119 VectorInt vet = new VectorInt(); // classe que contém o método de ordenação 120 comparevalues = vet.selectionorder(comparevalues); 121 // fim ordenação 122 // calcula as estatísticas 123 minorvalue = comparevalues[0]; // após a ordenação, o primeiro valor é o menor valor 124 majorvalue = comparevalues[this.number_compares-1]; // o maior valor encontra-se na última posição 125 for(int j = 0; j < this.number_compares; j++){ 126 // calcular aqui as medias percorrendo o vetor 127 sumvalues = sumvalues + comparevalues[j]; // faz o somatório 128 } 129 mediavalue = (double) sumvalues/this.number_compares; // calcula a média de comparações 130 // calcula a mediana 131 rest = this.number_compares % 2; // verificar se o tamanho do vetor é par

23 132 boolean ispair = (rest == 0); // se o resto da divisão for zero o tamanho do vetor é par 133 if (ispair) {// mediana no caso de vetor tamanho par 134 medianavalue = (double) (comparevalues[(this.number_compares/2)] + comparevalues[(this.number_compares/2)+1])/2; 135 }else 136 { 137 // mediana no caso de vetor tamanho ímpar 138 medianavalue = comparevalues[(this.number_compares/2)+1]; 139 } 140 System.out.printf("Menor Valor: %d\n", minorvalue); 141 System.out.printf("Maior Valor: %d\n", majorvalue); 142 System.out.printf("Média: %f\n", mediavalue); 143 System.out.printf("Mediana: %f\n", medianavalue); 144 if (allregistered) 145 System.out.println("TODAS as URLs pesquisadas foram encontradas."); 146 if (allnotregistered) 147 System.out.println("NENHUMA das URLs pesquisadas foi encontrada."); } // método para teste: visualizar conteúdo da tabela hash 153 public void showhashtableopen(){ 154 for(int i = 0; i < TABLE_SIZE; i++){ 155 System.out.printf("Linha %d ==> ",i); 156 if (this.htableopen[i] == null){ 157 System.out.print("\n"); 158 } 159 else{ 160 System.out.println(this.htableOpen[i]); 161 } 162 //System.out.println(); 163 } 164 } 165 } 1 package list; 2 3 /** classe para retornar os resultados de uma pesquisa na lista ou em uma posição da tabela hash 4 * deverá conter o número de comparações e o resultado da pesquisa (verdadeiro ou falso) 5 * se a pesquisa for na tabela hash retornará também a posição na tabela 6 * dessa forma poderão ser retornadas mais informações sobre a pesquisa 7 danilo.leite 8 */ 9 public class FindResults { 10 private int numberofcomparison; // número de comparações na lista 11 private boolean found; // resultado da pesquisa

24 12 private int hashposition; // posição na tabela hash (quando for o caso) public FindResults(){ 15 this.numberofcomparison = 0; 16 this.found = false; 17 this.hashposition = -1; // posição inicial inexistente; somente será utilizada para tabela hash 18 } public int getnumberofcomparison() { 21 return this.numberofcomparison; 22 } public void incnumberofcomparison() { 26 this.numberofcomparison = this.numberofcomparison + 1; 27 } public boolean isfound() { 30 return this.found; 31 } public void setfound(boolean found) { 34 this.found = found; 35 } public int gethashposition() { 38 return this.hashposition; 39 } public void sethashposition(int hashposition) { 42 this.hashposition = hashposition; 43 } 44 } 1 package list; 2 3 /**define a estrutura de um elemento da lista 4 * composta de uma String para URL e um apontador para o próximo elemento da lista 5 danilo.leite 6 */ 7 public class ListElement { 8 private String url; 9 private ListElement next; public ListElement(){ 12 } public String geturl() { 15 return url; 16 } public void seturl(string url) { 19 this.url = url;

25 20 } 1 package list; 2 3 /**define estrutura e as operações da lista encadeada 4 * 5 danilo.leite 6 */ 7 public class ListSet { 8 private ListElement first; // primeiro elemento da lista atua como âncora (referência para a lista) 9 private ListElement aux,newelement; 10 private boolean found; // resultado da última pesquisa findinlist // inicializa a lista vazia 13 public ListSet(){ 14 this.first = null; // a ideia é sempre guardar o primeiro elemento como uma âncora 15 } // ao adicionar elemento na lista, deverá sempre colocar na primeira posição 18 public void add(string url){ 19 if (this.first == null){ 20 this.first = new ListElement(); 21 this.first.seturl(url); 22 this.first.setnext(null); // o último elemento da lista é sempre vazio (nulo) 23 } 24 else{ 25 this.newelement = new ListElement(); // cria novo 26 this.newelement.seturl(url); // atribui a url 27 this.aux = this.first; // guarda a primeira posição da lista em aux 28 this.newelement.setnext(this.aux); // coloca no novo elemento na primeira posição apontando para aux 29 this.first = this.newelement; // atribui o novo elemento à variável first (âncora), que aponta para o antigo primeiro elemento 30 } 31 } // exibe o resultado da pesquisa na lista: retorna número de comparações na lista e atribui true ou false à variável this.found 34 public FindResults findinlist(string url){ 35 FindResults results = new FindResults(); // o resultado inicial é número de comparações = 0 e resultado da pesquisa = falso 36 if (this.first == null){ 37 return results; // não houve pesquisa 38 } 39 else{ 40 aux = first; 41 while (aux!= null){ 42 results.incnumberofcomparison(); // incrementa o número de comparações em + 43 if (aux.geturl().equals(url)){ 44 results.setfound(true);// encontrou

26 45 break; 46 } 47 aux = aux.getnext(); 48 } 49 } 50 return results; 51 } // exibe o conteúdo da lista 54 public void showlist(){ 55 if (this.first == null){ 56 System.out.println("Lista vazia"); 57 } 58 else{ 59 aux = first; 60 int i = 1; 61 while (aux!= null){ 62 System.out.printf("%d.["+aux.getUrl()+"];",i); 63 aux = aux.getnext(); 64 i = i+1; 65 } 66 } 67 } // exibe o tamanho da lista 70 public int sizelist(){ 71 int i = 0; 72 if (this.first == null){ 73 return i; 74 } 75 else{ 76 aux = first; 77 while (aux!= null){ 78 i = i+1; 79 aux = aux.getnext(); 80 } 81 } 82 return i; 83 } /** 86 the found 87 */ 88 public boolean isfound() { 89 return this.found; 90 } 91 } 1 package list; 2 3 /** teste de lista encadeada 4 * 5 danilo.leite 6 */ 7 public class TestList { 8

27 9 public static ListSet lista = new ListSet(); public static void main(string[] args) { 12 // TODO code application logic here 13 lista = new ListSet(); 14 lista.add(" 15 lista.add(" 16 lista.add(" 17 lista.add(" lista.showlist(); 20 } } 1 package inputfile; 2 3 import java.io.bufferedreader; 4 import java.io.filereader; 5 import java.io.ioexception; 6 import java.util.random; 7 import table.hashtablelistset; 8 import table.hashtableopenadress; 9 import vectorint.vectorint; /** 12 * funções de manipulação de arquivo texto e integração com tabela hash 13 danilo.leite 14 */ 15 public class txtfile { private int numlinhas = 0; 18 private String listurl; // lista de urls do arquivo no formato String -- testes de importação 19 private hashtablelistset hashtablels; 20 private hashtableopenadress hashtableopen; 21 private final int RANGE_LIMIT = 10696; // limite para o sorteio das URLs 22 private String[] sortlist;// lista de URLs sorteadas 23 private String arquivo; public txtfile(){ 26 this.hashtablels = new hashtablelistset(); 27 this.hashtableopen = new hashtableopenadress(); 28 this.arquivo = "c:\\users\\danilo.leite\\documents\\netbeansprojects\\hashing\\src\ \inputfile\\urls2.txt"; 29 } public void setlisturl() { String taginicio = "<pre><p>"; 34 String tagfim = "</p></pre>"; 35 String txturl = new String();

28 36 try { 37 //abrir arquivo 38 BufferedReader br = new BufferedReader(new FileReader(this.arquivo)); 39 while (br.ready()) { 40 String linha = br.readline(); 41 if (br.ready()) { 42 this.numlinhas = this.numlinhas + 1; 43 } 44 if (linha.contains(taginicio)) { 45 linha = linha.replacefirst(taginicio, ""); // remover tag início 46 } 47 if (linha.contains(tagfim)) { 48 linha = linha.replacefirst(tagfim, ""); // remover tag fim 49 } 50 //txturl = txturl + linha + "#"; // # para separar as linhas 51 if (txturl!= null) 52 txturl = txturl + '\n'; 53 txturl = txturl + linha; 54 } 55 br.close(); 56 this.listurl = txturl; 57 } catch (IOException ioe) { 58 ioe.printstacktrace(); 59 } 60 } public String getlisturl() { 63 return this.listurl; 64 } public int getnumlinhas() { 67 return this.numlinhas; 68 } public hashtablelistset gethashtablels() { 71 return this.hashtablels; 72 } public void sethashtablels() { 75 String taginicio = "<pre><p>"; 76 String tagfim = "</p></pre>"; 77 try { 78 //abrir arquivo 79 BufferedReader br = new BufferedReader(new FileReader(this.arquivo)); 80 while (br.ready()) { 81 String linha = br.readline(); 82 if (br.ready()) { 83 this.numlinhas = this.numlinhas + 1; 84 } 85 if (linha.contains(taginicio)) {

29 86 linha = linha.replacefirst(taginicio, ""); // remover tag início 87 } 88 if (linha.contains(tagfim)) { 89 linha = linha.replacefirst(tagfim, ""); // remover tag fim 90 } 91 if (linha!= null) 92 this.hashtablels.add(linha); // adiciona URL na hashtablels 93 } 94 br.close(); 95 } catch (IOException ioe) { 96 ioe.printstacktrace(); 97 } 98 } public void sethashtableopen() { 101 String taginicio = "<pre><p>"; 102 String tagfim = "</p></pre>"; 103 this.numlinhas = 0; 104 try { 105 //abrir arquivo 106 BufferedReader br = new BufferedReader(new FileReader(this.arquivo)); 107 while (br.ready()) { 108 String linha = br.readline(); 109 if (br.ready()) { 110 this.numlinhas = this.numlinhas + 1; 111 } 112 if (linha.contains(taginicio)) { 113 linha = linha.replacefirst(taginicio, ""); // remover tag início 114 } 115 if (linha.contains(tagfim)) { 116 linha = linha.replacefirst(tagfim, ""); // remover tag fim 117 } 118 if (linha!= null) 119 this.hashtableopen.add(linha); // adiciona URL na hashtableopen 120 } 121 br.close(); 122 } catch (IOException ioe) { 123 ioe.printstacktrace(); 124 } 125 } public hashtableopenadress gethashtableopen() { 128 return this.hashtableopen; 129 } // sorteia e seleciona um determinado número de linhas (URLs) do arquivo 132 public void sortlines(int numbersortlines){ 133 String taginicio = "<pre><p>";

30 134 String tagfim = "</p></pre>"; 135 this.sortlist = new String[numberSortLines]; // cria um vetor de [numbersortlines] posições para armazenar as URLs sorteadas 136 int[] sortedlines = new int[numbersortlines]; // vetor de inteiros para guardar as posições sorteadas 137 Random rdm = new Random(); 138 int pos = 0; // posição no arquivo 139 String linha = ""; // variável para armazenar linha do arquivo 140 // sortear as [numbersortlines] URLs e adicionar em resultlines 141 try { 142 //abrir arquivo 143 BufferedReader br = new BufferedReader(new FileReader(this.arquivo)); 144 // selecionar [numbersortlines] posições para extrair as URLs para pesquisa 145 for(int i = 0; i < numbersortlines; i++) { 146 sortedlines[i] = rdm.nextint(range_limit); // gera posição randomicamente dentro do range da tabela 147 // (entre 0 e RANGE_LIMIT-1) 148 } 149 // ordena vetor de posições 150 VectorInt vet = new VectorInt(); // classe que contém o método de ordenação 151 sortedlines = vet.selectionorder(sortedlines); 152 // fim ordenação 153 for(int i = 0; i < numbersortlines; i++) { 154 // posiciona na próxima linha sorteada 155 for(int j = pos; j < sortedlines[i]-1; j++){ 156 br.readline(); 157 } 158 if (pos < sortedlines[i]){ 159 pos = sortedlines[i]; // atualiza posição no arquivo 160 linha = br.readline(); 161 } 162 if (br.ready()) { 163 if (linha.contains(taginicio)) { 164 linha = linha.replacefirst(taginicio, ""); // remover tag início 165 } 166 if (linha.contains(tagfim)) { 167 linha = linha.replacefirst(tagfim, ""); // remover tag fim 168 } 169 } 170 //this.sortlist[i] = Integer.toString(sortedLines[i])+"."+linha; // teste para verificar a aleatoriedade 171 this.sortlist[i] = linha; // teste para verificar a aleatoriedade 172 } 173 br.close(); 174 } 175 catch (IOException ioe) {

31 176 ioe.printstacktrace(); 177 } } public String[] getsortlist() { 182 return this.sortlist; 183 } // alterar a URL em uma determinada posição da lista 186 public void setsortlistitem(string newurl, int index) { 187 this.sortlist[index] = newurl; 188 } } package inputfile; 2 3 /** 4 * teste de importação de dados do arquivo texto 5 danilo.leite 6 */ 7 public class TestTxtFile { 8 9 public static void main(string[] args) { txtfile arquivourl = new txtfile(); 12 arquivourl.setlisturl(); 13 System.out.println(arquivoUrl.getListURL()); 14 System.out.printf("Número de linhas: %d", arquivourl.getnumlinhas()); 15 System.out.println(); 16 } } 1 package inputfile; 2 3 /** 4 * teste do sorteio das URLs 5 danilo.leite 6 */ 7 public class TestSortList { 8 public static void main(string[] args) { 9 txtfile arquivourl = new txtfile(); 10 arquivourl.sortlines(1000); 11 for(int i = 0; i < 1000; i++) { 12 System.out.println(arquivoUrl.getSortList()[i]); 13 } 14 System.out.println(); 15 } 16 }