Как отсортировать HashSet?

Для списков мы используем метод Collections.sort(List). Что, если мы хотим отсортировать a HashSet?

Ответ 1

HashSet не гарантирует какой-либо порядок своих элементов. Если вам нужна эта гарантия, рассмотрите возможность использования TreeSet для хранения ваших элементов.

Однако, если вам нужно, чтобы ваши элементы были отсортированы для этого случая, просто временно создайте список и сортируйте его так:

Set<?> yourHashSet = new HashSet<>();

...

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

Ответ 2

Добавьте все свои объекты в TreeSet, вы получите отсортированный набор. Ниже приведен грубый пример.

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]

Ответ 3

Используйте java.util.TreeSet в качестве фактического объекта. Когда вы перебираете эту коллекцию, значения возвращаются в четко определенном порядке.

Если вы используете java.util.HashSet то порядок зависит от внутренней хеш-функции, которая почти наверняка не является лексикографической (в зависимости от содержимого).

Ответ 4

Вместо этого вы можете использовать TreeSet.

Ответ 5

Java 8 способ сортировки:

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 Это пример того, как сортировать HashSet вашего объекта по размеру.

* Collectors.toList() собирается собирать результат сортировки в список, который вам нужно будет захватить с помощью List<Foo> sortedListOfFoo =

Ответ 6

Вы можете использовать сборщики Java 8 и TreeSet

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

Ответ 7

Вы можете использовать TreeSet, как указано в других ответах.

Вот немного более подробная информация о том, как его использовать:

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);

Вывод:

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

Ответ 8

Элементы в HashSet не могут быть отсортированы. Всякий раз, когда вы помещаете элемент в HashSet, он портит порядок всего набора. Это делает это для производительности. Если вам не нужен порядок, HashSet станет наиболее эффективным набором для быстрой вставки и поиска.

TreeSet будет сортировать все элементы автоматически каждый раз, когда вы вставляете элемент.

Возможно, вы пытаетесь отсортировать только один раз. В этом случае TreeSet - не лучший вариант, поскольку он должен постоянно определять размещение вновь добавленных элементов.

Наиболее эффективным решением является использование ArrayList. Создайте новый список и добавьте все элементы, а затем отсортируйте его один раз. Если вы хотите сохранить только уникальные элементы (удалите все дубликаты, как это делает set, затем поместите список в LinkedHashSet, он сохранит порядок, который вы уже отсортировали)

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
// The above line is not copying the objects! It only copies references.

Теперь у вас есть отсортированный набор, если вы хотите его в форме списка, а затем преобразовать его в список.

Ответ 9

По моему скромному мнению, ответ LazerBanana должен быть самым рейтинговым и принятым, потому что все остальные ответы, указывающие на java.util.TreeSet (или сначала преобразовать в список, а затем вызвать Collections.sort(...) в преобразованном списке), не делали ' Он задал вопрос об OP как о HashSet объектов, которые есть у вашего HashSet, т.е. имеют ли эти элементы предопределенный естественный порядок или нет, и это не дополнительный вопрос, а обязательный вопрос.

Вы просто не можете пойти и начать складывать свои HashSet элементы в TreeSet, если тип элемента уже не реализовать Comparable интерфейс или если вы явно не передавая Comparator для TreeSet конструктора.

Из TreeSet JavaDoc,

Создает новый пустой набор деревьев, отсортированный в соответствии с естественным порядком его элементов. Все элементы, вставленные в набор, должны реализовывать интерфейс Comparable. Кроме того, все такие элементы должны быть взаимно сопоставимы: e1.compareTo(e2) не должно генерировать исключение ClassCastException для любых элементов e1 и e2 в наборе. Если пользователь пытается добавить элемент в набор, который нарушает это ограничение (например, пользователь пытается добавить строковый элемент в набор, элементы которого являются целыми числами), вызов add вызовет исключение ClassCastException.

Вот почему только все ответы на основе потоков Java8 - где вы определяете свой компаратор на месте - имеют смысл только потому, что реализация сопоставимых в POJO становится необязательной. Программист определяет компаратор по мере необходимости. Попытка собрать в TreeSet не задавая этот фундаментальный вопрос, также неверна (ответ ниндзя). Предполагать, что тип объекта является String или Integer, также неверно.

Сказав это, другие проблемы, такие как,

Производительность сортировки
Memory Foot Print (сохранение оригинального набора и создание новых отсортированных наборов каждый раз, когда выполняется сортировка или требуется сортировка набора на месте и т.д. И т.д.)

должны быть и другие важные моменты тоже. Просто указывать на API не должно быть только намерением.

Поскольку исходный набор уже содержит только уникальные элементы, и это ограничение также поддерживается отсортированным набором, поэтому исходный набор необходимо удалить из памяти, поскольку данные дублируются.

Ответ 10

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);
    }
  }
 }

input - ved prakash sharma apple ved banana

Выход - яблочный банан пракаш шарма ved

Ответ 11

вы можете сделать это следующими способами:

Способ 1:

Создайте список и сохраните в нем все значения hashset
сортировать список, используя Collections.sort()
Сохраните список обратно в LinkedHashSet, поскольку он сохраняет порядок вставки

Способ 2:

Создайте набор treeSet и сохраните в нем все значения.

Способ 2 более предпочтителен, потому что другой метод требует много времени для передачи данных вперед и назад между хэшсет и списком.

Ответ 12

Вы можете использовать библиотеку гуавы для того же

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

Ответ 13

Мы не можем решить, что элементы HashSet будут отсортированы автоматически. Но мы можем сортировать их путем преобразования в TreeSet или любой Список, такой как ArrayList или LinkedList и т.д.

// 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");

Ответ 14

SortedSet был добавлен начиная с Java 7https://docs.oracle.com/javase/8/docs/api/java/util/SortedSet.html

Ответ 15

Если вы хотите, чтобы конец Collection имел вид Set, и если вы хотите определить свой собственный natural order, а не TreeSet, тогда -

1. Преобразуйте HashSet в List
2. Пользовательская сортировка List с помощью Comparator
3. Преобразуйте обратно List в LinkedHashSet, чтобы поддерживать порядок
4. Отобразите LinkedHashSet

Пример программы -

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);
    }
}

Вывод -

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

Здесь коллекция была отсортирована как -

Первый - по убыванию длины String
Второе - по убыванию алфавитной иерархии String

Ответ 16

Вы можете обернуть его в TreeSet следующим образом:

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);

вывод:
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);

выход:
предметы из моего набора [шесть, четыре, пять, два, эльф]
TreeSet элементы [эльф, пять, четыре, шесть, два]

требование для этого метода состоит в том, что объекты набора/списка должны быть сопоставимы (реализовать интерфейс Comparable)

Ответ 17

Эта простая команда сделала трюк для меня:

myHashSet.toList.sorted

Я использовал это в заявлении печати, поэтому, если вам действительно нужно сохранить порядок, вам может понадобиться использовать TreeSets или другие структуры, предложенные в этом потоке.