Hoe sorteer ik een HashSet?

Voor lijsten gebruiken we de methode Collections.sort(List). Wat als we een HashSet willen sorteren?


Antwoord 1, autoriteit 100%

Een HashSet garandeert geen enkele volgorde van zijn elementen. Als je deze garantie nodig hebt, overweeg dan om een ​​TreeSet te gebruiken om je elementen vast te houden.

Als u echter alleen uw elementen gesorteerd wilt hebben voor deze ene gebeurtenis, maak dan tijdelijk een lijst aan en sorteer die:

Set<?> yourHashSet = new HashSet<>();
...
List<?> sortedList = new ArrayList<>(yourHashSet);
Collections.sort(sortedList);

Antwoord 2, autoriteit 57%

Voeg al uw objecten toe aan de TreeSet, je krijgt een gesorteerde set. Hieronder is een onbewerkt voorbeeld.

HashSet myHashSet = new HashSet();
myHashSet.add(1);
myHashSet.add(23);
myHashSet.add(45);
myHashSet.add(12);
TreeSet myTreeSet = new TreeSet();
myTreeSet.addAll(myHashSet);
System.out.println(myTreeSet); // Prints [1, 12, 23, 45]

Antwoord 3, autoriteit 18%

Java 8-manier om het te sorteren zou zijn:

fooHashSet.stream()
  .sorted(Comparator.comparing(Foo::getSize)) //comparator - how you want to sort it
  .collect(Collectors.toList()); //collector - what you want to collect it to

*Foo::getSize het is een voorbeeld van hoe je de HashSet van YourItem’s natuurlijk op grootte kunt sorteren.

*Collectors.toList() gaat het resultaat van het sorteren in een lijst verzamelen. U moet het vastleggen met List<Foo> sortedListOfFoo =


Antwoord 4, autoriteit 15%

Je kunt in plaats daarvan een TreeSet gebruiken .


Antwoord 5, autoriteit 11%

Gebruik java.util.TreeSet als het eigenlijke object. Wanneer u deze verzameling herhaalt, komen de waarden terug in een goed gedefinieerde volgorde.

Als je java.util.HashSet gebruikt, dan hangt de volgorde af van een interne hashfunctie die vrijwel zeker niet lexicografisch is (op basis van inhoud).


Antwoord 6, autoriteit 8%

Voor het geval je geen TreeSet wilt gebruiken, kun je dit proberen met java stream voor beknopte code.

set = set.stream().sorted().collect(Collectors.toCollection(LinkedHashSet::new));

Antwoord 7, autoriteit 5%

U kunt Java 8-collectors en TreeSet gebruiken

list.stream().collect(Collectors.toCollection(TreeSet::new))


Antwoord 8, autoriteit 4%

Elementen in HashSet kunnen niet worden gesorteerd. Telkens wanneer u elementen in HashSet plaatst, kan dit de volgorde van de hele set verpesten. Het is bewust zo ontworpen voor prestaties. Als de bestelling je niet interesseert, is HashSet de meest efficiënte set voor frequente toevoegingen en vragen.

TreeSet is het alternatief dat u kunt gebruiken. Wanneer u de boomset herhaalt, krijgt u automatisch gesorteerde elementen.
Maar het zal de boom aanpassen om te proberen gesorteerd te blijven elke keer dat je een element invoegt.

Misschien probeert u slechts één keer te sorteren. In dat geval is TreeSet niet de meest efficiënte optie omdat het steeds de plaatsing van nieuw toegevoegde elementen moet bepalen. Gebruik TreeSet alleen als u vaak wilt sorteren.

Als u maar één keer hoeft te sorteren, gebruikt u ArrayList. Maak een nieuwe lijst, voeg alle elementen toe en sorteer deze één keer. Als je alleen unieke elementen wilt behouden (verwijder alle duplicaten), plaats dan de lijst in een LinkedHashSet, deze behoudt de volgorde die je al hebt gesorteerd.

List<Integer> list = new ArrayList<>();
list.add(6);
list.add(4);
list.add(4);
list.add(5);
Collections.sort(list);
Set<Integer> unique = new LinkedHashSet<>(list); // 4 5 6

Je hebt nu een gesorteerde set als je deze in een lijstvorm wilt hebben, en converteer deze dan naar een lijst.


Antwoord 9, autoriteit 3%

U kunt TreeSet gebruiken zoals vermeld in andere antwoorden.

Hier is een beetje meer uitleg over hoe het te gebruiken:

TreeSet<String> ts = new TreeSet<String>();
ts.add("b1");
ts.add("b3");
ts.add("b2");
ts.add("a1");
ts.add("a2");
System.out.println(ts);
for (String s: ts)
    System.out.println(s);

Uitvoer:

[a1, a2, a3, a4, a5]
a1
a2
b1
b2
b3

Antwoord 10, autoriteit 3%

Op basis van het antwoord van @LazerBanana zal ik mijn eigen voorbeeld van een set plaatsen, gesorteerd op de id van het object:

Set<Clazz> yourSet = [...];
yourSet.stream().sorted(new Comparator<Clazz>() {
    @Override
    public int compare(Clazz o1, Clazz o2) {
        return o1.getId().compareTo(o2.getId());
    }
}).collect(Collectors.toList()); // Returns the sorted List (using toSet() wont work)

Antwoord 11, autoriteit 2%

Naar mijn bescheiden mening zou het antwoord van LazerBanana het best beoordeelde antwoord moeten zijn & geaccepteerd omdat alle andere antwoorden die verwijzen naar java.util.TreeSet (of eerst converteren naar lijst en vervolgens Collections.sort(...) op de geconverteerde lijst noemen) dat niet deden t nam de moeite om OP te vragen wat voor soort objecten uw HashSet heeft, dat wil zeggen of die elementen een vooraf gedefinieerde natuurlijke volgorde hebben of niet & dat is geen optionele vraag maar een verplichte vraag.

Je kunt gewoon niet naar binnen & begin met het plaatsen van uw HashSet-elementen in een TreeSet als het elementtype de Comparable-interface nog niet implementeert of als u de Comparator naar TreeSet-constructor.

Van TreeSet JavaDoc ,

Construeert een nieuwe, lege boomset, gesorteerd volgens de natuurlijke
ordening van zijn elementen. Alle elementen die in de set worden ingevoegd, moeten
Implementeer de Vergelijkbare interface. Bovendien zijn al dergelijke elementen
moeten onderling vergelijkbaar zijn: e1.compareTo(e2) mag geen gooien
ClassCastException voor alle elementen e1 en e2 in de set. Als de gebruiker
probeert een element aan de set toe te voegen dat deze beperking schendt
(de gebruiker probeert bijvoorbeeld een string-element toe te voegen aan een set waarvan de
elementen zijn gehele getallen), zal de add-aanroep een ClassCastException genereren.

Dat is de reden waarom alleen alle op Java8 stream gebaseerde antwoorden – waarbij u uw comparator ter plaatse definieert – alleen maar zinvol zijn omdat het implementeren van vergelijkbaar in POJO optioneel wordt. Programmeur definieert comparator als en wanneer dat nodig is. Proberen te verzamelen in TreeSet zonder deze fundamentele vraag te stellen, is ook onjuist ( Ninja’s antwoord). Ervan uitgaande dat objecttypen String of Integer zijn, is ook onjuist.

Dat gezegd hebbende, andere zorgen zoals ,

  1. Sorteerprestaties
  2. Memory Foot Print (de originele set behouden en nieuwe gesorteerde sets maken elke keer dat er wordt gesorteerd of de set op zijn plaats wil worden gesorteerd, enz.)

moeten ook de andere relevante punten zijn. Alleen maar verwijzen naar API zou niet alleen de bedoeling moeten zijn.

Aangezien de originele set al alleen unieke elementen bevat & die beperking wordt ook gehandhaafd door de gesorteerde set, dus de originele set moet uit het geheugen worden gewist omdat gegevens worden gedupliceerd.


Antwoord 12

1. Add all set element in list -> al.addAll(s);
2. Sort all the elements in list using -> Collections.sort(al);
 public class SortSetProblem {
 public static void main(String[] args) {
    ArrayList<String> al = new ArrayList();
    Set<String> s = new HashSet<>();
    s.add("ved");
    s.add("prakash");
    s.add("sharma");
    s.add("apple");
    s.add("ved");
    s.add("banana");
    System.out.println("Before Sorting");
    for (String s1 : s) {
        System.out.print("  " + s1);
    }
    System.out.println("After Sorting");
    al.addAll(s);
    Collections.sort(al);
    for (String set : al) {
        System.out.print(" " + set);
    }
  }
 }

invoer – ved prakash sharma appel ved banaan

Output – appel banaan prakash sharma ved


Antwoord 13

Als je wilt dat de Collection aan het einde de vorm heeft van Set en als je je eigen natural order wilt definiëren in plaats van die van TreeSet en dan –

1. Converteer de HashSet naar List
2. Sorteer de List op maat met behulp van Comparator
3. Converteer de List terug naar LinkedHashSet om de volgorde te behouden
4. Geef de LinkedHashSet
. weer

Voorbeeldprogramma –

package demo31;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
public class App26 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        addElements(set);
        List<String> list = new LinkedList<>();
        list = convertToList(set);
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                int flag = s2.length() - s1.length();
                if(flag != 0) {
                    return flag;
                } else {
                    return -s1.compareTo(s2);
                }
            }
        });
        Set<String> set2 = new LinkedHashSet<>();
        set2 = convertToSet(list);
        displayElements(set2);
    }
    public static void addElements(Set<String> set) {
        set.add("Hippopotamus");
        set.add("Rhinocerous");
        set.add("Zebra");
        set.add("Tiger");
        set.add("Giraffe");
        set.add("Cheetah");
        set.add("Wolf");
        set.add("Fox");
        set.add("Dog");
        set.add("Cat");
    }
    public static List<String> convertToList(Set<String> set) {
        List<String> list = new LinkedList<>();
        for(String element: set) {
            list.add(element);
        }
        return list;
    }
    public static Set<String> convertToSet(List<String> list) {
        Set<String> set = new LinkedHashSet<>();
        for(String element: list) {
            set.add(element);
        }
        return set;
    }
    public static void displayElements(Set<String> set) {
        System.out.println(set);
    }
}

Uitvoer –

[Hippopotamus, Rhinocerous, Giraffe, Cheetah, Zebra, Tiger, Wolf, Fox, Dog, Cat]

Hier is de collectie gesorteerd als –

Eerste – Aflopende volgorde van String lengte
Tweede – Aflopende volgorde van String alfabetische hiërarchie


Antwoord 14

u kunt dit op de volgende manieren doen:

Methode 1:

  1. Maak een lijst en sla alle hashset-waarden erin op
  2. sorteer de lijst met Collections.sort()
  3. Sla de lijst weer op in LinkedHashSet omdat de invoegvolgorde behouden blijft

Methode 2:

  • Maak een treeSet en sla alle waarden erin op.

Methode 2 heeft meer de voorkeur omdat de andere methode veel tijd kost om gegevens heen en weer tussen hashset en lijst over te dragen.


Antwoord 15

We kunnen niet besluiten dat de elementen van een HashSet automatisch worden gesorteerd. Maar we kunnen ze sorteren door ze te converteren naar TreeSet of een lijst zoals ArrayList of LinkedList enz.

// Create a TreeSet object of class E
TreeSet<E> ts = new TreeSet<E> ();
// Convert your HashSet into TreeSet
ts.addAll(yourHashSet);
System.out.println(ts.toString() + "\t Sorted Automatically");

Antwoord 16

U kunt de guavebibliotheek voor hetzelfde gebruiken

Set<String> sortedSet = FluentIterable.from(myHashSet).toSortedSet(new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        // descending order of relevance
        //required code
    }
});

Antwoord 17

SortedSet is toegevoegd sinds java 7
https://docs.oracle.com/javase/ 8/docs/api/java/util/SortedSet.html


Antwoord 18

Je kunt het als volgt in een TreeSet inpakken:

Set mySet = new HashSet();
mySet.add(4);
mySet.add(5);
mySet.add(3);
mySet.add(1);
System.out.println("mySet items "+ mySet);   
TreeSet treeSet = new TreeSet(mySet);   
System.out.println("treeSet items "+ treeSet);   

uitvoer :
mySet-items [1, 3, 4, 5]
treeSet-items [1, 3, 4, 5]

Set mySet = new HashSet();
mySet.add("five");
mySet.add("elf");
mySet.add("four");
mySet.add("six");
mySet.add("two");
System.out.println("mySet items "+ mySet);
TreeSet treeSet = new TreeSet(mySet);
System.out.println("treeSet items "+ treeSet);

uitvoer:
mySet-items [zes, vier, vijf, twee, elf]
treeSet items [elf, vijf, vier, zes, twee]

vereiste voor deze methode is dat de objecten van de set/lijst vergelijkbaar moeten zijn (imparable de Vergelijkbare interface)


Antwoord 19

Deze eenvoudige opdracht deed het voor mij:

myHashSet.toList.sorted

Ik heb dit in een printstatement gebruikt, dus als je de volgorde echt wilt voortzetten, moet je mogelijk TreeSets of andere structuren gebruiken die in deze thread worden voorgesteld.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes