public class BitSet implements Cloneable, Serializable {
    private long[] words;
    private int wordsInUse = 0;
    // другие поля и методы...
}
Массив words динамически расширяется по мере необходимости. Параметр wordsInUse отслеживает количество используемых элементов в массиве.

private void ensureCapacity(int wordsRequired) {
    if (words.length < wordsRequired) {
        // логика увеличения размера массива...
    }
}
Этот процесс автоматический и управляется самим классом BitSet, что позволяет пользователю не беспокоиться о ручном управлении памятью.

public void and(BitSet set) {
    for (int i = 0; i < wordsInUse; i++) {
        words[i] &= set.words[i];
    }
    recalculateWordsInUse();
}
Это позволяет применять операции ко всему набору битов за один проход, минимизируя затраты времени.

private static int wordIndex(int bitIndex) {
    return bitIndex >> 6; // Эквивалентно делению на 64
}

public void set(int bitIndex) {
    int wordIndex = wordIndex(bitIndex);
    words[wordIndex] |= (1L << bitIndex);
}
Здесь метод wordIndex вычисляет индекс элемента массива, в котором находится нужный бит, а побитовый сдвиг устанавливает значение этого бита.

import java.util.BitSet;

public class Main {
    public static void main(String[] args) {
        BitSet bitset = new BitSet(10);
        bitset.set(0);
        bitset.set(3);
        bitset.set(5);
        bitset.set(7);
        bitset.flip(0, 6);
        bitset.clear(7);
        
        for (int i = 0; i < 10; i++) {
            System.out.print(bitset.get(i) ? "1" : "0");
        }
    }
}

BitSet bitSet = new BitSet();
bitSet.set(2); // Устанавливает бит с индексом 2 в true
bitSet.set(4, 7); // Устанавливает биты с индексами 4, 5 и 6 в true
Если указать диапазон, все биты в этом диапазоне будут установлены в true.

bitSet.clear(2); // Сбрасывает бит с индексом 2 в false
bitSet.clear(4, 7); // Сбрасывает биты с индексами 4, 5 и 6 в false
Полезно для обнуления значений или удаления флагов.

boolean value = bitSet.get(2); // Получает значение бита с индексом 2
BitSet subSet = bitSet.get(4, 7); // Получает поднабор битов с 4 до 6
Возвращаемое значение может быть true или false, а в случае диапазона — новый BitSet.

bitSet.flip(2); // Инвертирует бит с индексом 2
bitSet.flip(4, 7); // Инвертирует биты с 4 до 6
Если бит был true, он станет false, и наоборот.

System.out.println("Length: " + bitSet.length()); // Логическая длина BitSet
System.out.println("Size: " + bitSet.size()); // Текущий размер внутреннего массива
Эти методы полезны для анализа содержимого BitSet и его текущего состояния.

int numberOfBits = bitSet.cardinality(); // Количество установленных битов
Полезно, когда нужно узнать, сколько значений true содержится в наборе.

BitSet bitSet1 = new BitSet();
bitSet1.set(1);
bitSet1.set(3);

BitSet bitSet2 = new BitSet();
bitSet2.set(2);
bitSet2.set(3);

bitSet1.and(bitSet2); // AND операция между bitSet1 и bitSet2
bitSet1.or(bitSet2);  // OR операция между bitSet1 и bitSet2
bitSet1.xor(bitSet2); // XOR операция между bitSet1 и bitSet2
Эти методы полезны для выполнения сложных битовых операций между двумя наборами.

boolean hasIntersection = bitSet1.intersects(bitSet2); // true, если есть общие биты
Метод возвращает true, если есть хотя бы один бит, который установлен в true в обоих наборах.

boolean isEmpty = bitSet.isEmpty(); // true, если все биты сброшены
Полезно для проверки пустоты множества.

bitSet.stream().forEach(System.out::println); // Выводит индексы установленных битов
Это удобный способ итерирования по установленным битам с использованием функциональных возможностей Java.

BitSet largeSet = new BitSet();
for (int i = 0; i < 1000000; i++) {
    if (i % 2 == 0) {
        largeSet.set(i);
    }
}

System.out.println("Количество установленных битов: " + largeSet.cardinality());
В этом примере BitSet используется для хранения большого количества булевых значений, что значительно экономит память по сравнению с использованием массивов boolean[].

NavigableSet<Integer> navigableSet = new TreeSet<>();
navigableSet.add(5);
navigableSet.add(2);
navigableSet.add(9);

System.out.println(navigableSet); // [2, 5, 9]

NavigableSet<String> navigableSet = new ConcurrentSkipListSet<>();
navigableSet.add("banana");
navigableSet.add("apple");
navigableSet.add("cherry");

System.out.println(navigableSet); // [apple, banana, cherry]

import java.util.*;

public class Main {
    public static void main(String[] args) {
        NavigableSet<Integer> set = new TreeSet<>(Arrays.asList(10, 20, 30, 40, 50));
        System.out.println(set.lower(30));
        System.out.println(set.floor(30));
        System.out.println(set.ceiling(25));
        System.out.println(set.higher(50));
    }
}

NavigableSet<Integer> set = new TreeSet<>(Arrays.asList(1, 2, 3, 4, 5));
System.out.println(set.lower(3)); // Output: 2

System.out.println(set.floor(3)); // Output: 3
System.out.println(set.floor(6)); // Output: 5

System.out.println(set.ceiling(3)); // Output: 3
System.out.println(set.ceiling(0)); // Output: 1

System.out.println(set.higher(3)); // Output: 4
System.out.println(set.higher(5)); // Output: null

NavigableSet<String> set = new TreeSet<>(Arrays.asList("apple", "banana", "cherry"));
System.out.println(set.pollFirst()); // Output: apple
System.out.println(set.pollLast());  // Output: cherry
System.out.println(set);             // Output: [banana]

NavigableSet<String> set = new TreeSet<>(Arrays.asList("apple", "banana", "cherry"));
NavigableSet<String> descendingSet = set.descendingSet();
System.out.println(descendingSet); // Output: [cherry, banana, apple]

NavigableSet<Integer> set = new TreeSet<>(Arrays.asList(1, 2, 3, 4, 5));
NavigableSet<Integer> subSet = set.subSet(2, true, 4, false);
System.out.println(subSet); // Output: [2, 3]

NavigableSet<Integer> headSet = set.headSet(4, true);
System.out.println(headSet); // Output: [1, 2, 3, 4]

NavigableSet<Integer> tailSet = set.tailSet(3, false);
System.out.println(tailSet); // Output: [4, 5]

NavigableSet<Integer> temperatures = new TreeSet<>(Arrays.asList(10, 15, 20, 25, 30));
NavigableSet<Integer> comfortableTemperatures = temperatures.subSet(15, true, 25, true);
System.out.println(comfortableTemperatures); // Output: [15, 20, 25]

NavigableSet<LocalDate> dates = new TreeSet<>(Arrays.asList(
    LocalDate.of(2023, 8, 20),
    LocalDate.of(2023, 9, 5),
    LocalDate.of(2023, 10, 10)
));

LocalDate today = LocalDate.of(2023, 8, 25);
LocalDate nextDate = dates.ceiling(today);

System.out.println(nextDate); // Output: 2023-09-05