⌛ Сохраняйте шпаргалку с иерархией исключений

══════ Навигация ══════
Вакансии • Задачи • Собесы

🐸 Библиотека джависта

#Enterprise

🛡 AI-ассистент в IDE без вендорлока

Устали от того, что Copilot и JetBrains AI Assistant — это чёрные ящики с непонятными тарифами? Есть альтернатива.
Continue — open source плагин (Apache 2.0) для IntelliJ-based IDE, который даёт полный контроль над AI-помощником:

→ Выбираете модель сами: GPT-4, Claude, локальный Ollama
→ Контролируете, куда уходит код — можете поднять модель локально или выбрать проверенного провайдера
→ Настраиваете под команду через config.json

Что умеет

▪️ Автодополнение с контекстом проекта (не просто строка, а весь файл)
▪️ Чат, который понимает архитектуру — спроси про конкретный класс
▪️ Команды над выделенным кодом: рефакторинг, генерация тестов, упрощение
▪️ Агентный режим — Continue + MCP инструменты собирают патч сразу в нескольких файлах

Подводные камни

▪️ Качество = модель + контекст. Дешёвая LLM даст поверхностный код
▪️ Любой AI-код требует ревью. YOLO — не метод
▪️ Облачные провайдеры = риск утечки. Выбирайте осознанно

📌 Итог

Continue превращает IDE в персонализированный инструмент, а не в терминал к чужому облаку. Особенно актуально для команд с требованиями к приватности и гибкости стека.

🔗 Детали

══════ Навигация ══════
Вакансии • Задачи • Собесы

🐸 Библиотека джависта

#Enterprise

👀 Внутреннее устройство List.of()

List.of() появился в Java 9 и произвёл революцию в создании коллекций. Но под капотом это не просто обёртка над ArrayList — это целая иерархия оптимизированных классов.

📦 Сигнатура и варианты

Java предоставляет 12 перегруженных методов:

// Специализированные версии для 0-10 элементов
static <E> List<E> of()
static <E> List<E> of(E e1)
static <E> List<E> of(E e1, E e2)
// ... до 10 параметров
static <E> List<E> of(E e1, E e2, ..., E e10)
// Varargs для 11+ элементов
static <E> List<E> of(E... elements)

Зачем столько перегрузок?

— Избежать overhead создания varargs массива
— Каждая перегрузка возвращает оптимизированный класс
— Специализация для частых случаев (1-2 элемента)

🔍 Внутренняя реализация

→ Разные классы для разного размера:

// 0 элементов — singleton
static <E> List<E> of() {
    return ImmutableCollections.EMPTY_LIST;  // Переиспользуется!
}

// 1 элемент — List12 (List of 1 or 2)
static <E> List<E> of(E e1) {
    return new ImmutableCollections.List12<>(e1);
}

// 2 элемента — тот же List12
static <E> List<E> of(E e1, E e2) {
    return new ImmutableCollections.List12<>(e1, e2);
}

// 3+ элементов — ListN
static <E> List<E> of(E e1, E e2, E e3) {
    return ImmutableCollections.listFromTrustedArray(e1, e2, e3);
}

→ Структура List12 (для 1-2 элементов):

static final class List12<E> extends AbstractImmutableList<E> {
    private final E e0;  // Всегда присутствует
    private final E e1;  // null если один элемент
    
    List12(E e0) {
        this.e0 = Objects.requireNonNull(e0);
        this.e1 = null;
    }
    
    List12(E e0, E e1) {
        this.e0 = Objects.requireNonNull(e0);
        this.e1 = Objects.requireNonNull(e1);
    }
    
    public int size() {
        return e1 != null ? 2 : 1;
    }
    
    public E get(int index) {
        if (index == 0) return e0;
        else if (index == 1 && e1 != null) return e1;
        throw new IndexOutOfBoundsException();
    }
}

→ Структура ListN (для 3+ элементов):

static final class ListN<E> extends AbstractImmutableList<E> {
    private final E[] elements;  // Хранит все элементы
    
    ListN(E... elements) {
        // Копирование + null-check каждого элемента
        this.elements = elements.clone();
        for (E e : this.elements) {
            Objects.requireNonNull(e);
        }
    }
    
    public int size() {
        return elements.length;
    }
    
    public E get(int index) {
        return elements[index];
    }
}

⚠️ Подводные камни

1. Null элементы запрещены.
2. Varargs создаёт массив.
3. Не Serializable.
4. SubList тоже immutable.

📊 Performance бенчмарк

→ Создание списка из 3 элементов:

List.of("A", "B", "C"):                ~5 ns
Arrays.asList("A", "B", "C"):          ~8 ns
new ArrayList<>(Arrays.asList(...)):   ~25 ns

List.of() в 5 раз быстрее ArrayList!

→ Memory footprint:

List.of(1, 2, 3):           48 байт
Arrays.asList(1, 2, 3):     ~72 байт (backing array + wrapper)
new ArrayList<>(3 items):   ~112 байт (default capacity 10)

List.of() в 2.3 раза компактнее!

🔗 Документация

══════ Навигация ══════
Вакансии • Задачи • Собесы

🐸 Библиотека джависта

#CoreJava

🐸 Библиотека джависта

#DevLife

🔍 Задачка с реального собеса

Что будет результатом кода? Смотри правильный ответ.

══════ Навигация ══════
Вакансии • Задачи • Собесы

🐸 Библиотека джависта

#CoreJava

✔️ Collections Challenge: Реализация Custom HashMap

Напишите упрощённую версию HashMap с нуля 👇

📦 Задание

Реализуйте SimpleHashMap<K, V> — собственную реализацию хеш-таблицы без использования готовых Map.

📋 Требования

1. Основная функциональность

→ put() — добавить/обновить пару ключ-значение
→ get() — получить значение по ключу (null если нет)
→ remove() — удалить элемент, вернуть старое значение
→ containsKey() — проверка наличия ключа
→ size() — текущее количество элементов
→ keySet() — множество всех ключей

2. Внутренняя структура

→ Использовать массив buckets (корзин)
→ Collision resolution через связный список (chaining)
→ Начальная ёмкость — 16 элементов
→ Load factor — 0.75

3. Обязательные фичи

→ Автоматическое расширение (resize) при превышении load factor
→ Корректная работа с null ключами
→ Правильный расчёт hashCode (учитывать equals/hashCode contract)
→ Обработка коллизий

Ставьте → 🔥, если нравится формат. Если нет → 🤔

💬 Пишите решение в комментариях, главное прячьте под спойлер.

🐸 Библиотека собеса по Java

#practise

🐸 Библиотека джависта

#DevLife

👑 Магия IntelliJ IDEA: Live Templates с контекстом

Пишешь sout → Tab → System.out.println(). Знакомо? Но IDEA умеет гораздо больше.

Live Templates анализируют контекст кода и подставляют нужные переменные автоматически.

🔹 Что умеет

— soutv → выведет переменную под курсором с её именем
— soutm → выведет имя текущего метода и класса
— soutp → выведет все параметры метода
— psvm → создаст main method
— iter → foreach по коллекции под курсором
— ifn / inn → null-check или not-null check переменной

🔹 Зачем это нужно

— Отладка в 2 нажатия без написания println вручную
— Быстрая генерация шаблонного кода (циклы, проверки)
— Автоматическое использование переменных из контекста

🔹 Как использовать

— Поставь курсор на переменную → пиши soutv → Tab
— Внутри метода → soutp → Tab (выведет все параметры)
— Создай свой template: Settings → Editor → Live Templates
— Можно задать контекст (Java, Kotlin, внутри метода/класса)

🎯 Бонус: psfs → создаст public static final String, lazy → ленивую инициализацию.

══════ Навигация ══════
Вакансии • Задачи • Собесы

🐸 Библиотека джависта

#Enterprise

🐸 Библиотека джависта

#DevLife

👀 Внутреннее устройство PriorityQueue

PriorityQueue — это реализация интерфейса Queue на основе двоичной кучи. Элементы всегда упорядочены по приоритету, минимальный элемент всегда в голове.

📦 Базовая структура

PriorityQueue использует min-heap реализацию:

public class PriorityQueue<E> {
    transient Object[] queue;  // массив-куча
    private int size = 0;
    private final Comparator<? super E> comparator;
    
    private static final int DEFAULT_INITIAL_CAPACITY = 11;
}

Главные особенности:

→ O(log n) для add и poll (вставка/удаление с перестройкой).
→ O(1) для peek (доступ к минимуму).
→ O(n) для remove(Object) и contains.
→ Не гарантирует полную сортировку, только min в голове.
→ Не потокобезопасна (для concurrent используйте PriorityBlockingQueue).

🔍 Как устроено хранение

Binary Heap — complete binary tree в массиве

PriorityQueue с элементами: [2, 5, 8, 9, 12, 10, 15]

Куча (min-heap):
           2
         /   \
       5       8
      / \     / \
     9  12  10  15

Массив queue[]:
[2, 5, 8, 9, 12, 10, 15]
 0  1  2  3   4   5   6

Индексация:
- Родитель узла i:     (i - 1) / 2
- Левый ребёнок узла i: 2 * i + 1
- Правый ребёнок узла i: 2 * i + 2

Свойство min-heap:

Каждый родитель ≤ своих детей. Это НЕ полная сортировка — только гарантия минимума в корне.

⚡️ Операции добавления и удаления

➕ add(E element) / offer(E element) — добавление

1. Элемент добавляется в конец массива: queue[size++] = element.
2. Вызывается siftUp(size-1) для восстановления heap property:
— Элемент "всплывает" вверх, пока не станет больше родителя.
— Сравнения через Comparator или Comparable.

Алгоритм siftUp:

void siftUp(int k) {
    E x = queue[k];
    while (k > 0) {
        int parent = (k - 1) >>> 1;  // деление на 2
        E e = queue[parent];
        if (compare(x, e) >= 0) break;  
        queue[k] = e;  // родитель опускается
        k = parent;    // поднимаемся выше
    }
    queue[k] = x;  // вставляем элемент
}

Сложность: O(log n) — высота дерева.

➖ poll() — удаление минимального элемента

1. Сохраняется минимум: E result = queue[0].
2. Последний элемент перемещается в корень: queue[0] = queue[--size].
3. Вызывается siftDown(0) для восстановления heap:
— Элемент "тонет" вниз, меняясь с меньшим ребёнком.

Алгоритм siftDown:

void siftDown(int k) {
    E x = queue[k];
    int half = size >>> 1;  // size / 2
    while (k < half) {  
        int child = (k << 1) + 1;  // левый ребёнок
        E c = queue[child];
        int right = child + 1;
        if (right < size && compare(c, queue[right]) > 0) {
            child = right;  // правый меньше
            c = queue[child];
        }
        if (compare(x, c) <= 0) break; 
        queue[k] = c;  // ребёнок поднимается
        k = child;     // опускаемся ниже
    }
    queue[k] = x;
}

Сложность: O(log n).

🔎 peek() — доступ к минимуму

E peek() {
    return (size == 0) ? null : (E) queue[0];
}

Сложность: O(1) — прямой доступ к корню.

🔍 contains(Object o) — проверка наличия

1. Линейный поиск по массиву queue[].
2. Сравнение через equals().

Сложность: O(n) — требуется обход массива.

➖ remove(Object o) — удаление элемента

1. Линейный поиск элемента: O(n).
2. Удаление найденного:
— Перемещение последнего элемента на место удаляемого.
— siftDown() или siftUp() для восстановления heap.

Сложность: O(n) поиск + O(log n) восстановление = O(n).

⚖️ Важные нюансы

1️⃣ Comparator vs Comparable

Элементы должны быть сравниваемыми. Без Comparator/Comparable → ClassCastException.

2️⃣ НЕ полностью отсортирована

Heap гарантирует только минимум в корне.

3️⃣ Iterator не гарантирует порядок

Для sorted iteration используйте poll() в цикле:

4️⃣ Null элементы НЕ допускаются

✅ Подходит

— Нужен доступ к минимуму/максимуму
— Динамическая сортировка
— Алгоритмы с приоритетами
— Top K проблема

🔗 Документация: JavaDoc (Java 17)

Ставьте 🔥, если хотите ещё разбор.

══════ Навигация ══════
Вакансии • Задачи • Собесы

🐸 Библиотека джависта

#CoreJava

🔥 Optional.orElseThrow()

Как обычно обрабатываете отсутствие значения? Проверяете на null, кидаете исключение вручную, пишите if-else?

Optional умеет делать это элегантно.

🔹 Что делает orElseThrow()

Возвращает значение из Optional, если оно есть. Если пусто — кидает исключение. Можно передать свой Supplier для кастомного исключения.

🔹 Пример

Optional<User> userOpt = findUserById(123);

// Вместо:
if (!userOpt.isPresent()) {
    throw new UserNotFoundException("User not found");
}
User user = userOpt.get();

// Пишем:
User user = userOpt.orElseThrow(
    () -> new UserNotFoundException("User not found")
);

Без параметра кидает NoSuchElementException:

User user = userOpt.orElseThrow(); // Java 10+

🔹 Зачем это нужно

— Компактный код без if-блоков.
— Явная обработка отсутствия значения.
— Чистый, декларативный стиль без boilerplate.

══════ Навигация ══════
Вакансии • Задачи • Собесы

🐸 Библиотека джависта

#Enterprise

🐸 Библиотека джависта

#DevLife