Ler frequência de palavras

jTextArea2.setText(jTextArea2.getText() + "\n" + "texto = '" + keyString + "' contagem = '" + valueString + "'");

String texto = "texto palavra texto palavra texto";
		
		
		class ComparadorFrequencia<T> implements Comparable<ComparadorFrequencia<T>> {
			T objeto;
			int frequencia = 0;
				
			@Override
			public int compareTo(ComparadorFrequencia o) {				
				return o.frequencia - this.frequencia;
			}
			
			public ComparadorFrequencia(T objeto) {
				this.objeto = objeto;
			}
			
			public boolean equals (Object o) {
				if (!(o instanceof ComparadorFrequencia))
					return false;
				ComparadorFrequencia<T> aquele = (ComparadorFrequencia<T>)o;
				return this.objeto.equals(aquele.objeto);
			}
		} 
		
		StringTokenizer tokenizer = new StringTokenizer(texto);
		List<ComparadorFrequencia<String>> lista = new ArrayList<ComparadorFrequencia<String>>();
		List<String> palavras = new ArrayList<String>();
		
		while (tokenizer.hasMoreTokens()) {
			palavras.add(tokenizer.nextToken());
		}
		Collections.sort(palavras);
		
		for (String palavra : palavras) {
			int index = lista.indexOf(new ComparadorFrequencia<String>(palavra));
			if (index != -1) {
				ComparadorFrequencia<String> comparador = lista.get(index);
				comparador.frequencia++;
			}
			
			else  {
				ComparadorFrequencia<String> comparador = new ComparadorFrequencia<String>(palavra);
				comparador.frequencia++;
				lista.add(comparador);
			}
		}
		
		Collections.sort(lista);
		for (ComparadorFrequencia<String> comparador : lista) {
			System.out.println("Palavra: " + comparador.objeto + " frequencia: " + comparador.frequencia);
		}

import java.util.HashMap;
import java.util.Iterator;
import java.util.StringTokenizer;

SortedHashMap<String, Integer> map = new SortedHashMap<String, Integer>();

HashMap<String, Integer> lista = new HashMap<String, Integer>();
   String keyString;
     Integer valueString;

 private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        // TODO add your handling code here:
    

        jTextArea1.getText();
		StringTokenizer st = new StringTokenizer(jTextArea1.getText());

	     while (st.hasMoreTokens()) {
	    	String token = st.nextToken();
			if(lista.get(token) != null) {
				Integer total = lista.get(token);
				lista.put(token, total = total+1);
                                 
			} else {
				lista.put(token, 1);
			}
	     }
	     for (Iterator iter = lista.keySet().iterator(); iter.hasNext();) {
				 keyString = (String) iter.next();
				 valueString = lista.get(keyString);

      jTextArea2.setText(jTextArea2.getText() + "\n" + "texto = '" + keyString + "' contagem = '" + valueString + "'");
       jTextArea3.setText(jTextArea3.getText() +"\n" + valueString);

 map.put(new String(keyString), new Integer(valueString));


     }
  
	
    }                                        

   

    private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        

 Iterator iter = map.iterator();
   

 while (iter.hasNext()) {
  System.out.println(iter.next()); 

 }


    }

import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;

/**
 *
 * @author Michel A. Medeiros
 */
public class SortedHashMap  <E, T> extends HashMap<E, T> {
    public Iterator<Object> iterator() {
        Collection<T> collection = this.values();
        Object[] array = collection.toArray();
        Arrays.sort(array);
         return Arrays.asList(array).iterator();
     }  
}

private Map<String, Integer> mapa;                                                            
                                                                                              
private void resgataEOrdenaLista(String palavras) {                                           
	// garante ordem alfabética por padrão                                                    
	mapa = new TreeMap<String, Integer>();                                                    
	// cria um Scanner para ler                                                               
	Scanner scanner = new Scanner(palavras);                                                  
	// enquanto houver mais palavras                                                          
	while (scanner.hasNext()) {                                                               
		// pega a próxima palavra                                                             
		String palavra = scanner.next();                                                      
		// verifica se ela já existe no mapa                                                  
		Integer freq = mapa.get(palavra);                                                     
		// e adiciona-a com a nova frequência (1, se ela ainda não existia                    
		// ou incrementa 1 na frequência anterior, caso existisse)                            
		mapa.put(palavra, freq == null ? 1 : freq + 1);                                       
	}                                                                                         
}                                                                                             
                                                                                              
private void adicionaMapaAoTextArea(JTextArea textArea,                                       
		Set<Entry<String, Integer>> set) {                                                    
	// para cada entrada do mapa, adiciona uma linha ao final                                 
	for (Entry<String, Integer> e : set) {                                                    
		textArea.append("texto = '" + e.getKey());                                            
		textArea.append("', contagem = " + e.getValue());                                     
		textArea.append("\n");                                                                
	}                                                                                         
}                                                                                             
                                                                                              
private Set<Entry<String, Integer>> ordenaPorQuantidades() {                                  
	// o Comparator responsável por ordenar nosso Set de Entry                                
	Comparator<Entry<String, Integer>> comparator = new Comparator<Entry<String, Integer>>() {
                                                                                              
		@Override                                                                             
		public int compare(Entry<String, Integer> o1,                                         
				Entry<String, Integer> o2) {                                                  
			// se a contagem, retorna a comparação por Strings                                
			if (o1.getValue() == o2.getValue()) {                                             
				return o1.getKey().compareTo(o2.getKey());                                    
			}                                                                                 
			// senão, retorna por contagem mesmo                                              
			return o1.getValue().compareTo(o2.getValue());                                    
			// se quiser em ordem decrescente comente a linha acima e                         
			// decomente a linha abaixo:                                                      
			// return o2.getValue().compareTo(o1.getValue());                                 
		}                                                                                     
                                                                                              
	};                                                                                        
	// cria um Set ordenado pelo Compartator acima                                            
	Set<Entry<String, Integer>> entries = new TreeSet<Entry<String, Integer>>(                
			comparator);                                                                      
	// e adiciona o conteúdo do mapa                                                          
	entries.addAll(mapa.entrySet());                                                          
	return entries;                                                                           
}

// para pegar em ordem alfabética
resgataEOrdenaLista(jTextArea1.getText());
// se quiser nessa ordem mesmo, faça assim:
adicionaMapaAoTextArea(jTextArea2, mapa.entrySet());
// se quiser em ordem de aparição, use:
adicionaMapaAoTextArea(jTextArea2, ordenaPorQuantidades());