[code] //COME�A O PROGRAMA---------------------------------------------------------------------------------------------
public static void main(String[] args) throws IOException {
String[] aux = CAMINHO_ARQUIVO.split(".");
Scanner scanner = null;
if(aux[aux.length - 1].equalsIgnoreCase("pdf")){
PdfHandler handler = new PdfHandler(CAMINHO_ARQUIVO);//chama a fun��o pdf para ler um arquivo pdf
String[] textoPaginas = handler.getText();
String texto = "";
for(String pagina : textoPaginas) {
texto +=pagina;
}
scanner = new Scanner(texto);
}//FECHANDO IFR
else{//iniciando else pro WORD
WordDocumentHandler handler = new WordDocumentHandler(CAMINHO_ARQUIVO);
String[] textoPaginas = handler.getText();
String texto = null;
for(String pagina : textoPaginas) {
texto +=pagina;
}
scanner = new Scanner(texto);
}//fechando else do word
//vc abre o arquivo de texto e joga todas as palavras no scanner
Hashtable<String, Integer> histogram = new Hashtable<String, Integer>(); /* cria o histograma */
//Object[] myArray = null;
//MyComparator myComparator = new MyComparator();
while(scanner.hasNext()){//dai ele percorre todas as palavras do scanner
String word = scanner.next(); //pega a palavra atual
if(!verificaSW(word) && !NumberUtils.isNumber(word) && (word.length() > 1)
&& (word.replaceAll("[0-9]", "").length() == word.length())){ //se ele não for uma STOP_WORD
if(!palavraDesconsiderada(word)){ // se n�o tiver palavras com caracteres inv�lidos
if(!histogram.containsKey(word.toUpperCase())){ //esse if verifica se a palavra ja existe no histograma ou n�o
histogram.put(word.toUpperCase(), 1); //vc insere a palavra e o valor 1
}else{//se j� existe no histograma
int value = histogram.get(word.toUpperCase()); //acrescenta um n�mero no valor da ocorr�ncia
histogram.put(word.toUpperCase(), ++value);
}
}
}
}
/*********************************************************************************************************************************/
//ORDENAÇÃO USANDO COMPARATOR
ArrayList myArray = new ArrayList(histogram.entrySet()); /*primeiro eu set em um vetor a minha tabela hash*/
Collections.sort(myArray, new MyComparator()); //aqui eu chamo a classe para ordenar o vetor
Iterator itr = myArray.iterator();
String key="";
int value=0;
int cnt=0;
int lcaux=0; //variável que guarda maior ocorrência
while(itr.hasNext()){
cnt++;
Map.Entry e=(Map.Entry)itr.next();
key = (String)e.getKey();
value = ((Integer)e.getValue()).intValue();
if(value>=lcaux){ //laço para atribuir a lc a maior ocorrência
lcaux=value;
}
//System.out.println(key + ":" + value); //mostra cadas palavra com sua ocorrência
}
// System.out.println("Vamos ver qual é o maior: " + lcaux); Só verificando que lc está com o valor da maior ocorrência
/********************************************************************************************************************************/
/PARTE DO LIMIAR DE CORTE: PEGANDO AS PALAVRAS COM UM LIMIAR DE CORTE DE 65%/
double lc=lcaux0.65;
//System.out.println("valor do limiar de corte: " + lc); //Só verificando que lc está com o valor da maior ocorrência
ArrayList myArray2 = new ArrayList(histogram.entrySet()); //primeiro eu set em um vetor a minha tabela hash
Collections.sort(myArray2, new MyComparator()); // aqui eu chamo a classe para ordenar o vetor
Iterator itr2 = myArray2.iterator();
String key2="";
int value2=0;
while(itr2.hasNext()){
cnt++;
Map.Entry e2=(Map.Entry)itr2.next();
key2 = (String)e2.getKey();
value2 = ((Integer)e2.getValue()).intValue();
Cluster novoCluster = new Cluster();
while(value2>=lc){ //laço para atribuir a lc a maior ocorrência
novoCluster.addPalavra(key2);
}
}
}//final da classe do histograma[/code]
Nesse pedaço de código:
while(value2>=lc){ //laço para atribuir a lc a maior ocorrência
novoCluster.addPalavra(key2);
}
A condição (value2 >= lc) permanece inalterado e portanto o while roda continuamente até estourar a memória da JVM. Confira essa condição pq vc precisa garantir q o while pare em algum momento.
Main uma coisa no trecho:
Cluster novoCluster = new Cluster();
Tenha certeza de q realmente esse new ai pq, geralmente, news dentro de laço são errados e podem causar problemas de memória.
Carra… show… sem erros até o momento… vou continuar mexendo aki e qlqr coisa posto tá?
Brigada… Brigada mesmo pela ajuda!!!
té mais :lol:
Olha eu de novo…
fiz uma método chamada mostraCluster dentro da classe Cluster pra mostar o meu hashmap… como faço para chamar ele da minha outra classe?
Aí está meu método
[code]public void mostraCluster() {
Iterator itr = ((List) palavras).iterator();
String key="";
String value="";
int cnt=0;
while(itr.hasNext()){
cnt++;
Map.Entry e=(Map.Entry)itr.next();
key = (String)e.getKey();
//value = (String)e.getValue;
System.out.println(key + ":" + value);
}//fim mostraCluster [/code]
Cluster c = new Cluster();
c.mostraCluster();
É isso?
Era isso sim…
eu tava fazendo certo porém tava com um erro no cluster… mas brigada mesmo assim…
Agora… começou a complicar…
Vc me indicou a usar uma HashMap<String, List> certo? tá dando tudo certo até agora… porém… não sei como imprimir agora… pq o q eu fiz não tá certo? não tá imprimindo nem a key nem os value.
esse é minha cluster… nela tem o mostraCluster
[code]package histograma;
//import java.util.ArrayList;
import java.util.HashMap;
//import java.util.Iterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
public class Cluster {
private String radical;
//private List palavras;
Map<String, List> palavras = new HashMap<String, List>(); //declara palavras como hasMap
private String palavraRepresentante;
public String getPalavraRepresentante() {
return palavraRepresentante;
}
public void setPalavraRepresentante(String palavraRepresentante) {
this.palavraRepresentante = palavraRepresentante;
}
public String getRadical() {
return radical;
}
public void setRadical(String radical) {
this.radical = radical;
}
public Map<String, List<String>> getPalavras() {
return palavras;
}
public void setPalavras(Map<String, List<String>> palavras) {
this.palavras = palavras;
}
public void addPalavra(String palavra) {
String radical = null;
// aqui vc coloca o código q extrai o radical. */
if (palavras.containsKey(radical)) { //verifica se o radical existem no hashmap
palavras.get(radical).add(palavra); //add a palavra a lista
}
else {
List<String> pl = new LinkedList<String>(); //atribui uma nova lista
pl.add(palavra); //add a palavra a essa nova lista
palavras.put(radical, pl); //escreve o radical e a palavra a lista
}
}//fim addPalavra
public void mostraCluster() {
ArrayList palavras2 = new ArrayList(palavras.entrySet());
Iterator itr = palavras2.iterator();
String key="";
List<String> value=" ";
//int value;
int cnt=0;
while(itr.hasNext()){
//Map.Entry e=(Map.Entry)itr.next();
System.out.println(key + ":" + value);
Iterator itr2 = palavras2.listIterator();
while(itr2.hasNext()){
System.out.println(value);
}
}
}//fim mostraCluster
}[/code]
Tem certeza q está compilando? Pq se palavras for do tipo HashMap então a linha…
Iterator itr = ((List<String>) palavras).iterator();
… devia dar erro.
Para imprimir faça:
public void mostraCluster() {
for (Map.Entry<String, List<String>> entrada : palavras.entrySet()) {
System.out.print(entrada.getKey() + ": [");
imprimePalavras(entrada.getValue());
System.out.print("]");
System.out.println();
}
}
private void imprimePalavras(List<String> palavras) {
Iterator<String> i = palavras.iterator();
if (i.hasNext()) {
System.out.print(i.next());
while (i.hasNext()) {
System.out.print(", " + i.next());
}
}
}
Caraca Véi… tá quase tudo perfeito…
Agora vou implementar a questão do radical pra fazer mais testes.
Valew pela ajuda até agora!!! VAlew mesmo!!! Mais pra frente continuo por aki… Valew
Olá, olha eu aqui novamente…
SEguinte… estou com mais um pequeno problema
Quando o radical já existe no HashMap ele não está inserindo a palavra na lista dakele radical e sim está criando de qlqr forma uma lista nova e inserindo ali.
a parte q faz a adição da palavra está logo abaixo
Ah… o radical tb não está sendo inserido.
hashMap<String, List>, no primeiro String tem q ter o radical e a List tem q ter as palavras q tenham akele mesmo radical
public void addPalavra(String palavra) {
String radical = null;
// aqui vc coloca o código q extrai o radical. */
radical = palavra.substring(0);
if (palavras.containsKey(radical)) { //verifica se o radical existem no hashmap
palavras.get(radical).add(palavra); //add a palavra a lista
}
else {
List<String> pl = new LinkedList<String>(); //atribui uma nova lista
pl.add(palavra); //add a palavra a essa nova lista
palavras.put(radical, pl); //escreve o radical e a palavra a lista
}
}//fim addPalavra
obrigada mais uma vez
Olha eu testei esse código usando algumas palavras e radicais arbitrarios e tudo funcionou perfeitamente.
Defina um conjunto arbitrário de palavras e chame o método addPalavra(String) e p/ cada vez q cada chamada chame em seguida o método mostraCluster() e verifique o resultado. Talvez vc esteja com algum problema com o processo de extração do radical.
Cara… valew, valew mesmo… tá perfeito…
Eu q mosquei mais uma vez… tava extraindo o radical errado!!!
Até mais!
Opa opa… voltei… com mais uma dúvida
Tenho essa classe:
public class Cluster {
private String radical;
//private List<String> palavras;
Map<String, List<String>> palavras = new HashMap<String, List<String>>(); //declara palavras como hasMap
private String palavraRepresentante;
public String getPalavraRepresentante() {
return palavraRepresentante;
}
public void setPalavraRepresentante(String palavraRepresentante) {
this.palavraRepresentante = palavraRepresentante;
}
public String getRadical() {
return radical;
}
public void setRadical(String radical) {
this.radical = radical;
}
public Map<String, List<String>> getPalavras() {
return palavras;
}
public void setPalavras(Map<String, List<String>> palavras) {
this.palavras = palavras;
}
public void addPalavra(String palavra) {
String radical = null;
ExtratorRadical rad = new ExtratorRadical(palavra);
radical = rad.getRadical();
//radical = palavra.substring(0,1); //pega a primeira letra de uma string
//System.out.print(radical + ", ");
if (palavras.containsKey(radical)) { //verifica se o radical existe no hashmap
palavras.get(radical).add(palavra); //add a palavra a lista
}
else {
List<String> pl = new LinkedList<String>(); //atribui uma nova lista
pl.add(palavra); //add a palavra a essa nova lista
palavras.put(radical.toUpperCase(), pl); //escreve o radical e a palavra a lista
}
}//fim addPalavra
public void mostraCluster() {
for (Map.Entry<String, List<String>> entrada : palavras.entrySet()) {
System.out.print(entrada.getKey() + ": [");
imprimePalavras(entrada.getValue());
System.out.print("]");
System.out.println();
}
}
private void imprimePalavras(List<String> palavras) {
Iterator<String> i = palavras.iterator();
if (i.hasNext()) {
System.out.print(i.next());
while (i.hasNext()) {
System.out.print(", " + i.next());
}
}
}
}
Preciso, em outra classe, criar um Map onde tenho <Integer, List>, onde irei copiar todoas as palavras, separadas por grupos. Exemplo:
1 --> Informatica, informatização
2 --> educação
3 --> Maravilha, Maravilhoso, maravilhado
e assim por diante.
Estou levando outro baile pra isso!!!
Desde já, Obrigada