Ciao a tutti....ho un grosso problema e non riesco a venirne a capo....ho un pezzo di codice che fornito in input un file di testo mi restituisce in output in ordine alfabetico le parole contenute nel testo con il numero di volte che compaiono.....
esempio molto spartano : input file.txt \"ciao come stai bene ciao ciao come bene ciao ciao bene\"
output : WORD [bene[3] , ciao[5] , come[2] , stai[1]]...in ordine alfabetico e il numero rappresenta le volte che compare nel testo.....il codice è in fondo al post
l'ordinamento avviene nell'interfaccia Comparable nel metodo compareTo che qui lavora in modo da mettere in ordine alfabetico le parole trovate...........però io avrei bisogno che mi ordinasse in ordine decrescente sul numero di volte che compare la parola in modo che in cima riesco ad avere la parola più frequente...nell'esempio di prima dovrebbe essere WORD [ciao[5] , bene[3] , come[2] , stai[1]]
sicuramente è un implementazione banale ma è da un pò che provo a fare diverse modifiche ma non riesco mai a ordinare nella maniera voluta.........
Qualcuno saprebbe dirmi come posso fare?sono in altro mare e mi serve assolutamente per un lavoro più ampio che sto svolgendo!!!!
Grazie mille...ciao
import java.io.*;
import java.util.*;
class Counter implements Comparable {
private String word;
private int count;
public Counter(String word) {
this.word = word;
count = 1;
}
public void increment() { count++; }
public String toString() {
return \"\\n\" + word + \" [\" + count + \"]\";
}
public boolean equals(Object obj) {
return obj instanceof Counter &&
((Counter)obj).word.equals(word);
}
public int hashCode() {
return word.hashCode();
}
public int compareTo(Object o) {
return word.compareTo(((Counter)o).word);
}
}
class CounterSet extends AbstractSet {
private Map set = new TreeMap();
public void addOrIncrement(String s) {
Counter c = new Counter(s);
if (set.containsKey(c))
((Counter)set.get(c)).increment();
else
set.put(c, c);
}
public Iterator iterator() {
return set.keySet().iterator();
}
public int size() {
return set.size();
}
public String toString() {
return set.keySet().toString();
}
}
class WordCount {
private FileReader file;
private StreamTokenizer st;
private CounterSet counts = new CounterSet();
WordCount(String filename)
throws FileNotFoundException {
try {
file = new FileReader(filename);
st = new StreamTokenizer(
new BufferedReader(file));
st.ordinaryChar('.');
st.ordinaryChar('-');
st.lowerCaseMode(true);
} catch(FileNotFoundException e) {
System.err.println(
\"Could not open \" + filename);
throw e;
}
}
void cleanup() {
try {
file.close();
} catch(IOException e) {
System.err.println(
\"file.close() unsuccessful\");
}
}
void countWords() {
try {
while(st.nextToken() !=
StreamTokenizer.TT_EOF) {
String s = \"a\";
switch(st.ttype) {
case StreamTokenizer.TT_EOL:
s = new String(\"EOL\");
break;
case StreamTokenizer.TT_NUMBER:
// s = Double.toString(st.nval);
break;
case StreamTokenizer.TT_WORD:
s = st.sval;
break;
default: // single character in ttype
s = String.valueOf((char)st.ttype);
}
if(s.length() > 3)
counts.addOrIncrement(s);
}
} catch(IOException e) {
System.err.println(
\"st.nextToken() unsuccessful\");
}
}
public Iterator iterator() {
return counts.iterator();
}
public String toString() {
return counts.toString();
}
}
public class KeyWordExtractor {
public static void main(String[] args)
throws FileNotFoundException {
for(int i = 0; i < args.length; i++){
WordCount wc = new WordCount(args);
wc.countWords();
System.out.println(\"WORD = \" + wc);
wc.cleanup();
}
}
}