Hashset vs Treeset

Eu sempre amei árvores, que agradável O(n*log(n))e a arrumação delas. No entanto, todo engenheiro de software que eu já conheci me perguntou claramente por que eu usaria um TreeSet. Do fundo do CS, acho que não importa muito o que você usa, e não me importo de mexer com funções de hash e buckets (no caso de Java).

Em quais casos devo usar um HashSetover a TreeSet?

O HashSet é muito mais rápido que o TreeSet (tempo constante versus tempo de log para a maioria das operações, como adicionar, remover e conter), mas não oferece garantias de pedidos como o TreeSet.

HashSet

• a classe oferece desempenho de tempo constante para as operações básicas (adicionar, remover, conter e tamanho).
• não garante que a ordem dos elementos permaneça constante ao longo do tempo
• O desempenho da iteração depende da capacidade inicial e do fator de carga do HashSet.
  • É bastante seguro aceitar o fator de carga padrão, mas convém especificar uma capacidade inicial com o dobro do tamanho em que você espera que o conjunto cresça.

TreeSet

• garante o log (n) custo do tempo para as operações básicas (adicionar, remover e conter)
• garante que os elementos do conjunto sejam classificados (ascendente, natural ou o especificado por você através de seu construtor) (implementa SortedSet)
• não oferece nenhum parâmetro de ajuste para o desempenho da iteração
• oferece alguns métodos úteis para lidar com o conjunto ordenado como first(), last(), headSet(), e tailSet()etc

Pontos importantes:

• Ambos garantem uma coleção de elementos sem duplicação
• Geralmente é mais rápido adicionar elementos ao HashSet e depois converter a coleção em um TreeSet para uma travessia classificada sem duplicação.
• Nenhuma dessas implementações é sincronizada. Ou seja, se vários encadeamentos acessam um conjunto simultaneamente e pelo menos um dos encadeamentos modifica o conjunto, ele deve ser sincronizado externamente.
• LinkedHashSet é, em certo sentido, intermediário entre HashSete TreeSet. Implementado como uma tabela de hash com uma lista vinculada em execução, no entanto, fornece iteração ordenada por inserção que não é igual à travessia classificada garantida pelo TreeSet .

Portanto, a escolha do uso depende inteiramente de suas necessidades, mas acho que, mesmo que você precise de uma coleção ordenada, ainda deve preferir o HashSet para criar o conjunto e depois convertê-lo em TreeSet.

• por exemplo SortedSet<String> s = new TreeSet<String>(hashSet);

Uma vantagem ainda não mencionada de a TreeSeté que ela possui uma "localidade" maior, o que é uma abreviação para dizer (1) se duas entradas estão próximas na ordem, as TreeSetcoloca próximas umas das outras na estrutura de dados e, portanto, na memória; e (2) esse posicionamento tira proveito do princípio de localidade, que diz que dados semelhantes são frequentemente acessados ​​por um aplicativo com frequência semelhante.

Isso contrasta com a HashSet, que espalha as entradas por toda a memória, independentemente de quais sejam suas chaves.

Quando o custo de latência da leitura de um disco rígido é milhares de vezes o custo da leitura do cache ou da RAM e quando os dados são realmente acessados ​​com a localidade, TreeSetpode ser uma escolha muito melhor.

HashSeté O (1) para acessar elementos, então isso certamente importa. Mas manter a ordem dos objetos no conjunto não é possível.

TreeSeté útil se a manutenção de um pedido (em termos de valores e não do pedido de inserção) for importante para você. Mas, como você observou, você está negociando uma ordem por um tempo mais lento para acessar um elemento: O (log n) para operações básicas.

Dos javadocs paraTreeSet :

Essa implementação fornece o tempo de log (n) garantido para as operações básicas ( add, removee contains).

1.HashSet permite objeto nulo.

2.TreeSet não permitirá objeto nulo. Se você tentar adicionar valor nulo, ele lançará uma NullPointerException.

3.HashSet é muito mais rápido que TreeSet.

por exemplo

 TreeSet<String> ts = new TreeSet<String>();
 ts.add(null); // throws NullPointerException

 HashSet<String> hs = new HashSet<String>();
 hs.add(null); // runs fine

Baseando-se na adorável resposta visual do Maps por @shevchyk, aqui está minha opinião:

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   Property   ║       HashSet       ║      TreeSet      ║     LinkedHashSet   ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║  no guarantee order ║ sorted according  ║                     ║
║   Order      ║ will remain constant║ to the natural    ║    insertion-order  ║
║              ║      over time      ║    ordering       ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ Add/remove   ║        O(1)         ║     O(log(n))     ║        O(1)         ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║   NavigableSet    ║                     ║
║  Interfaces  ║         Set         ║       Set         ║         Set         ║
║              ║                     ║    SortedSet      ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║    not allowed    ║                     ║
║  Null values ║       allowed       ║ 1st element only  ║      allowed        ║
║              ║                     ║     in Java 7     ║                     ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║              ║   Fail-fast behavior of an iterator cannot be guaranteed      ║
║   Fail-fast  ║ impossible to make any hard guarantees in the presence of     ║
║   behavior   ║           unsynchronized concurrent modification              ║
╠══════════════╬═══════════════════════════════════════════════════════════════╣
║      Is      ║                                                               ║
║ synchronized ║              implementation is not synchronized               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

A razão pela qual a maioria usa HashSeté que as operações são (em média) O (1) em vez de O (log n). Se o aparelho contiver itens padrão, você não estará "brincando com as funções de hash", como foi feito para você. Se o conjunto contiver classes personalizadas, você precisará implementar hashCodepara usá-lo HashSet(embora o Java Efetivo mostre como), mas se você usar um, TreeSetprecisará fazê-lo Comparableou fornecer um Comparator. Isso pode ser um problema se a classe não tiver uma ordem específica.

Às vezes, usei TreeSet(ou realmente TreeMap) para conjuntos / mapas muito pequenos (<10 itens), embora não tenha verificado se há algum ganho real ao fazê-lo. Para conjuntos grandes, a diferença pode ser considerável.

Agora, se você precisar da classificação, TreeSetserá apropriado, embora, mesmo assim, se as atualizações sejam frequentes e a necessidade de um resultado classificado seja pouco frequente, às vezes copiar o conteúdo para uma lista ou matriz e classificá-los pode ser mais rápido.

Se você não estiver inserindo elementos suficientes para resultar em rehashings frequentes (ou colisões, se o seu HashSet não puder ser redimensionado), um HashSet certamente oferecerá o benefício do acesso em tempo constante. Mas em conjuntos com muito crescimento ou retração, você pode obter um desempenho melhor com o Treesets, dependendo da implementação.

O tempo amortizado pode estar próximo de O (1) com uma árvore vermelho-preta funcional, se a memória me servir. O livro de Okasaki teria uma explicação melhor do que eu consigo. (Ou veja sua lista de publicações )

As implementações do HashSet são, obviamente, muito, muito mais rápidas - menos sobrecarga porque não há pedidos. Uma boa análise das várias implementações do Conjunto em Java é fornecida em http://java.sun.com/docs/books/tutorial/collections/implementations/set.html .

A discussão lá também aponta uma interessante abordagem de "meio termo" para a questão Tree vs Hash. O Java fornece um LinkedHashSet, que é um HashSet com uma lista vinculada "orientada a inserção" sendo executada, ou seja, o último elemento da lista vinculada também é o mais recentemente inserido no Hash. Isso permite evitar a irregularidade de um hash não ordenado sem incorrer no aumento do custo de um TreeSet.

O TreeSet é uma das duas coleções classificadas (a outra é o TreeMap). Ele usa uma estrutura de árvore Vermelho-Preto (mas você sabia disso) e garante que os elementos estejam em ordem crescente, de acordo com a ordem natural. Opcionalmente, você pode construir um TreeSet com um construtor que permita fornecer à coleção suas próprias regras para o que o pedido deve ser (em vez de depender da ordem definida pela classe dos elementos) usando um Comparable ou Comparator

e Um LinkedHashSet é uma versão ordenada do HashSet que mantém uma lista duplamente vinculada em todos os elementos. Use esta classe em vez do HashSet quando se importar com a ordem da iteração. Quando você itera através de um HashSet, o pedido é imprevisível, enquanto um LinkedHashSet permite iterar pelos elementos na ordem em que foram inseridos.

Muitas respostas foram dadas, com base em considerações técnicas, especialmente em relação ao desempenho. Segundo mim, escolha entre TreeSete HashSetimporta.

Mas prefiro dizer que a escolha deve ser conduzida primeiro por considerações conceituais .

Se, para os objetos que você precisa manipular, uma ordem natural não faz sentido, não use TreeSet.
É um conjunto classificado, pois é implementado SortedSet. Portanto, isso significa que você precisa substituir a função compareTo, que deve ser consistente com o que retorna a função equals. Por exemplo, se você tiver um conjunto de objetos de uma classe chamada Student, não creio que umTreeSetfaria sentido, uma vez que não há ordenação natural entre os alunos. Você pode encomendá-los pela nota média, ok, mas isso não é um "pedido natural". A função compareToretornaria 0 não apenas quando dois objetos representam o mesmo aluno, mas também quando dois alunos diferentes têm a mesma nota. No segundo caso, equalsretornaria falso (a menos que você decida fazer com que o último retorne verdadeiro quando dois alunos diferentes tiverem a mesma nota, o que tornaria a equalsfunção um significado enganoso, sem dizer um significado errado.)
Observe esta consistência entre equalse compareToé opcional, mas altamente recomendado. Caso contrário, o contrato da interface Setserá quebrado, tornando seu código enganoso para outras pessoas, resultando também em comportamento inesperado.

Esse link pode ser uma boa fonte de informações sobre esta questão.

Por que ter maçãs quando você pode comer laranjas?

Sério, garotos e garotas - se sua coleção é grande, lida e escrita em bilhões de vezes, e você está pagando por ciclos de CPU, então a escolha da coleção é relevante SOMENTE se você PRECISA ter um desempenho melhor. No entanto, na maioria dos casos, isso realmente não importa - alguns milissegundos aqui e ali passam despercebidos em termos humanos. Se realmente importava muito, por que você não está escrevendo código no assembler ou C? [indique outra discussão]. Portanto, o ponto é se você está feliz usando a coleção que escolheu e resolve o seu problema (mesmo que não seja especificamente o melhor tipo de coleção para a tarefa). O software é maleável. Otimize seu código sempre que necessário. Tio Bob diz que a otimização prematura é a raiz de todo mal. Tio Bob diz isso

Edição da mensagem ( reescrita completa ) Quando o pedido não importa, é quando. Ambos devem fornecer Log (n) - seria útil verificar se um é mais de cinco por cento mais rápido que o outro. O HashSet pode testar O (1) em um loop e deve revelar se é.

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class HashTreeSetCompare {

    //It is generally faster to add elements to the HashSet and then
    //convert the collection to a TreeSet for a duplicate-free sorted
    //Traversal.

    //really? 
    O(Hash + tree set) > O(tree set) ??
    Really???? Why?



    public static void main(String args[]) {

        int size = 80000;
        useHashThenTreeSet(size);
        useTreeSetOnly(size);

    }

    private static void useTreeSetOnly(int size) {

        System.out.println("useTreeSetOnly: ");
        long start = System.currentTimeMillis();
        Set<String> sortedSet = new TreeSet<String>();

        for (int i = 0; i < size; i++) {
            sortedSet.add(i + "");
        }

        //System.out.println(sortedSet);
        long end = System.currentTimeMillis();

        System.out.println("useTreeSetOnly: " + (end - start));
    }

    private static void useHashThenTreeSet(int size) {

        System.out.println("useHashThenTreeSet: ");
        long start = System.currentTimeMillis();
        Set<String> set = new HashSet<String>();

        for (int i = 0; i < size; i++) {
            set.add(i + "");
        }

        Set<String> sortedSet = new TreeSet<String>(set);
        //System.out.println(sortedSet);
        long end = System.currentTimeMillis();

        System.out.println("useHashThenTreeSet: " + (end - start));
    }
}