Dicas de ordenação utilizando Collections

Olá amigos, eu preciso pegar a lista de comandos executados no bash do Linux e ordenar os comandos que mais são utilizados. Para abstrair esse problema, inicialmente, não estou carregando a lista .bash_history, mas criei um array para testar se eu conseguia fazer isso, porém como eu sou um pouco receoso quanto a performance queria que os amigos dessem algumas dicas se a forma que fiz está robusto, coerente, com boa performance e o código está limpo.

Essa é a classe que representa um comando:

package _4_collection;

public class Comando implements Comparable {
	Integer prioridade;
	String comando;

	public Comando(Integer prioridade, String comando) {
		this.prioridade = prioridade;
		this.comando = comando;
	}
	
	public Integer getPrioridade() {
		return prioridade;
	}
	
	public void setPrioridade(Integer prioridade) {
		this.prioridade = prioridade;
	}
	
	public String getComando() {
		return comando;
	}
	
	public void setComando(String comando) {
		this.comando = comando;
	}
	
	public int compareTo(Object obj) {
		Comando outroComando = (Comando) obj;
		String atributos = prioridade + comando;
		String outrosAtributos = outroComando.getComando() + outroComando.getPrioridade();
		return atributos.compareTo(outrosAtributos);
	}
	
	public boolean equals(Object o) {
		// se nao for um parametro nulo retornara false
		if(o == null) return false;
		// se nao for um objeto da classe Comando retornara false
		if(! (this.getClass().equals(o.getClass()))) return false;
		// se for um objeto da classe Comando fara cast down
		Comando outro = (Comando) o;
		// verifica se as prioridades sao iguais
		boolean prioridadesIguais = this.getPrioridade() == outro.getPrioridade();
		// verifica se os comandos sao iguais
		boolean comandosIguais = false;
		if(this.getComando() != null)
			comandosIguais = this.getComando().equals(outro.getComando());
		else
			comandosIguais = outro.getComando() == null;
		// retornara o resultado da comparacao
		return prioridadesIguais && comandosIguais;
	}
	
	public int hashCode() {
		String atributos = prioridade + comando;
		return atributos.hashCode();
	}
	
	public String toString() {
		return "Comando: "+ comando +"\nPrioridade: "+ prioridade +"\n\n";
	}
}

Essa é a classe que define a regra de ordenação:

package _4_collection;

import java.util.Comparator;

public class RegraOrdenacao implements Comparator<Object> {
	public int compare(Object o1, Object o2) {
		Comando cmd1 = (Comando) o1;
		Comando cmd2 = (Comando) o2;
		return	cmd1.getPrioridade() < cmd2.getPrioridade() ? -1 :
					(cmd1.getPrioridade() > cmd2.getPrioridade() ? +1 : 0); 
	}
}

Essa é a classe para testar a ordenação do array historicoBash:

package _4_collection;

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import _4_collection.RegraOrdenacao;

public class OrdenaListaString {

	public static void main(String[] args) {
		String[] historicoBash = {"who", "ls /", "pwd", "ls /", "ls /home", "ls /"};
		
		Map<String, Integer> historicoDeChaves = new HashMap<String, Integer>();
		// 
		for(String bh: historicoBash) {			
			// A chave (comando) existe na tabela hash?
			if(historicoDeChaves.containsKey(bh)) {
				// incrementa o valor da chave, ou seja pontua o comando
				int hierarquiza = historicoDeChaves.get(bh) + 1;
				historicoDeChaves.put(bh, hierarquiza);
			} else {
				// insere uma nova chave (comando) com pontuacao 1
				historicoDeChaves.put(bh, 1);
			}
		}	

		List<Comando> comandosHierarquizados = new LinkedList<Comando>();
		
		// pega todas as todasAsChaves (todos comandos) da tabela hash
		Set<String> todasAsChaves = historicoDeChaves.keySet();
		// objeto de buscaChave das todasAsChaves (comandos) da tabela hash
		Iterator<String> buscaChave = todasAsChaves.iterator();
		
		// existe ainda chave (comando) para procurar na tabela hash?
		while(buscaChave.hasNext()) {
			// pega a chave na posicao atual de buscaChave
			Object chave = buscaChave.next();
			
			Comando cmd = new Comando(historicoDeChaves.get(chave), (String) chave);
			
			comandosHierarquizados.add(cmd);			
		}

		Comparator<Object> crescente = new RegraOrdenacao();
        Comparator<Object> decrescente = Collections.reverseOrder(crescente);
        
        Collections.sort(comandosHierarquizados, decrescente);
        
        System.out.println(comandosHierarquizados);
	}
}

Topicos relacionados