Что можно использовать если важен порядок у структуры Set

Упорядоченные Set-подобные структуры в Java

Set по определению — это коллекция уникальных элементов без гарантии порядка. Однако часто требуется сохранять порядок добавления элементов или сортировать элементы. Для этого существуют несколько решений.

1. LinkedHashSet — сохранение порядка добавления

LinkedHashSet — это реализация Set, которая сохраняет порядок вставки элементов через двусвязный список.

import java.util.*;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        // Обычный HashSet не гарантирует порядок
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Cherry");
        System.out.println(hashSet);
        // Вывод: [Apple, Banana, Cherry] или другой порядок
        
        // LinkedHashSet сохраняет порядок добавления
        Set<String> linkedSet = new LinkedHashSet<>();
        linkedSet.add("Apple");
        linkedSet.add("Banana");
        linkedSet.add("Cherry");
        System.out.println(linkedSet);
        // Вывод: [Apple, Banana, Cherry] (гарантированный порядок)
    }
}

Характеристики:

• Время добавления: O(1)
• Время поиска: O(1)
• Память: больше, чем HashSet (двусвязный список)
• Порядок: сохраняется в порядке добавления

Когда использовать: когда нужны уникальные элементы в порядке добавления.

// Реальный пример: логирование уникальных ошибок в порядке их появления
public class ErrorLog {
    private Set<String> uniqueErrors = new LinkedHashSet<>();
    
    public void logError(String errorMessage) {
        uniqueErrors.add(errorMessage);
    }
    
    public void printLog() {
        for (String error : uniqueErrors) {
            System.out.println(error);
            // Ошибки выводятся в порядке первого появления
        }
    }
}

2. TreeSet — сортировка элементов

TreeSet — это реализация Set, которая сохраняет элементы в отсортированном порядке используя красно-чёрное дерево.

import java.util.*;

public class TreeSetExample {
    public static void main(String[] args) {
        // Элементы автоматически сортируются
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(5);
        treeSet.add(2);
        treeSet.add(8);
        treeSet.add(1);
        System.out.println(treeSet);
        // Вывод: [1, 2, 5, 8] (отсортировано)
        
        // Со строками — по алфавиту
        Set<String> treeSet2 = new TreeSet<>();
        treeSet2.add("Zebra");
        treeSet2.add("Apple");
        treeSet2.add("Mango");
        System.out.println(treeSet2);
        // Вывод: [Apple, Mango, Zebra]
    }
}

Характеристики:

• Время добавления: O(log n)
• Время поиска: O(log n)
• Память: больше, чем HashSet
• Порядок: сортированный (по умолчанию по natural order)

Пользовательский компаратор:

public class CustomComparatorExample {
    static class Person {
        String name;
        int age;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + " (" + age + ")";
        }
    }
    
    public static void main(String[] args) {
        // Сортировка по возрасту
        Set<Person> people = new TreeSet<>((p1, p2) -> {
            int ageCompare = Integer.compare(p1.age, p2.age);
            if (ageCompare != 0) return ageCompare;
            return p1.name.compareTo(p2.name);
        });
        
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 30));
        
        for (Person p : people) {
            System.out.println(p);
        }
        // Вывод:
        // Bob (25)
        // Alice (30)
        // Charlie (30)
    }
}

Когда использовать: когда нужны уникальные элементы в отсортированном порядке.

3. Сравнение: HashSet vs LinkedHashSet vs TreeSet

4. List + сортировка — альтернатива

Если нужна упорядоченность и уникальность, можно использовать List с фильтрацией:

public class ListWithUniqueness {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Apple");  // Дубликат!
        
        // Способ 1: преобразовать в Set и обратно (теряется порядок)
        List<String> unique = new ArrayList<>(new LinkedHashSet<>(list));
        System.out.println(unique);
        // Вывод: [Apple, Banana]
        
        // Способ 2: Java Stream (Java 8+)
        List<String> uniqueStream = list.stream()
            .distinct()  // Оставляет уникальные
            .collect(Collectors.toList());
        System.out.println(uniqueStream);
        // Вывод: [Apple, Banana]
    }
}

5. LinkedList для случаев, когда нужен порядок + деквость

Линейный контейнер с быстрым доступом к началу/концу:

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("First");
        list.add("Second");
        list.add("Third");
        
        // Быстрое удаление с начала
        list.removeFirst();  // O(1)
        // Быстрое добавление в конец
        list.addLast("Fourth");  // O(1)
        
        System.out.println(list);
        // Вывод: [Second, Third, Fourth]
    }
}

6. Практические примеры

Пример 1: LRU Cache с LinkedHashSet

public class LRUCache {
    private final int capacity;
    private final LinkedHashSet<Integer> cache;
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
        // LinkedHashSet с access-order (через переопределение removeEldestEntry)
        this.cache = new LinkedHashSet<Integer>(capacity) {
            @Override
            protected boolean removeEldestEntry(java.util.Map.Entry eldest) {
                return size() > capacity;
            }
        };
    }
    
    public void add(int key) {
        cache.remove(key);  // Удалить если уже есть
        cache.add(key);     // Добавить в конец (самый свежий)
    }
    
    public void print() {
        System.out.println(cache);
    }
}

Пример 2: Уникальные IP адреса в порядке первого появления

public class IPLogger {
    private Set<String> uniqueIPs = new LinkedHashSet<>();
    
    public void logIP(String ip) {
        uniqueIPs.add(ip);
    }
    
    public void printIPsInOrder() {
        for (String ip : uniqueIPs) {
            System.out.println(ip);
        }
    }
}

Пример 3: Топ-N элементов в отсортированном порядке

public class TopNElements {
    public static void main(String[] args) {
        Set<Integer> topN = new TreeSet<>((a, b) -> b.compareTo(a));
        
        int[] data = {3, 7, 2, 9, 1, 5};
        for (int num : data) {
            topN.add(num);
        }
        
        System.out.println(topN);
        // Вывод: [9, 7, 5, 3, 2, 1]
    }
}

Итог и рекомендации

Вывод: выбирайте структуру в зависимости от приоритета — скорость, порядок добавления или сортировка.