Java for Beginner
759 subscribers
744 photos
212 videos
12 files
1.24K links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
4. Как это работает

В GraphQL всё держится на схеме (schema).
Она описывает, какие типы данных доступны, какие поля у них есть и какие операции разрешены.


Пример схемы:

type User {
id: ID!
name: String!
avatar: String
posts(limit: Int): [Post]
}

type Post {
id: ID!
title: String!
likes: Int!
}

type Query {
user(id: ID!): User
}


type — описание структуры данных, аналог класса в Java.

Query — “входная точка”, через которую клиент получает данные.

! — обязательное поле.

[Post] — список постов.


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



5. Ключевые преимущества GraphQL

1. Гибкость запросов
Клиент формирует запрос под себя:

на мобильном — только name и avatar,
в вебе — name, posts, comments.
Сервер не меняется, меняется лишь запрос.


2. Один запрос — много данных
GraphQL позволяет собрать связанные сущности за один вызов.
В REST для этого нужно было несколько запросов, теперь достаточно одного.


3. Строгая типизация
Схема описана декларативно, и клиент может проверять запросы ещё до выполнения.
Ошибки, вроде “такого поля нет” или “тип не совпадает”, ловятся на этапе компиляции.


4. Эволюция без версий
GraphQL не требует /v1, /v2, /v3.
Добавил поле — клиенты, которые его не запрашивают, даже не заметят изменений.
Старые клиенты продолжают работать, новые используют расширенные возможности.


5. Самодокументируемость
GraphQL-сервер знает всю структуру данных.
Это позволяет автоматически генерировать документацию и визуальные IDE вроде GraphiQL или Apollo Sandbox, где можно исследовать схему и писать запросы интерактивно.


6. Почему GraphQL особенно популярен во фронтенде
Фронтенд-разработка — динамичная среда:
разные страницы требуют разные наборы данных, часто меняются требования, нужны быстрые итерации.


GraphQL идеально вписывается в этот процесс, потому что:
Разработчик фронтенда сам решает, какие поля ему нужны.
Не нужно ждать, пока backend добавит новый эндпоинт.
Данные приходят в предсказуемом виде, строго по типам.
Поддерживаются инструменты вроде Apollo Client или Relay, которые кэшируют и синхронизируют данные автоматически.


Именно поэтому GraphQL сегодня стал де-факто стандартом для фронтенд-команд крупных проектов.
REST чаще используется для внешних публичных API, gRPC — для связи микросервисов,
а GraphQL стал интерфейсом между фронтом и внутренним миром данных.



#Java #middle #GraphQL
👍2
Что выведет код?

import java.util.HashMap;
import java.util.Map;

public class Task111125 {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", null);

map.merge("a", 10, (oldVal, newVal) -> null);
map.merge("b", 20, (oldVal, newVal) -> oldVal + newVal);
map.merge("c", 30, (oldVal, newVal) -> oldVal + newVal);
map.merge("d", 40, (oldVal, newVal) -> oldVal + newVal);

System.out.println(map.get("a"));
System.out.println(map.get("b"));
System.out.println(map.get("c"));
System.out.println(map.get("d"));
}
}


#Tasks
🔥1
Вопрос с собеседований

Что такое ApplicationContext в Spring? 🤓


Ответ:

ApplicationContext
— это контейнер, управляющий созданием и связью бинов.

Он сканирует классы, применяет зависимости, обрабатывает аннотации и управляет жизненным циклом.

Это сердце Spring, реализующее IoC и DI.



#собеседование
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
История IT-технологий сегодня — 12 ноября


ℹ️ Кто родился в этот день

Дэвид Итан Каллер (родился 12 ноября 1959 г.) — американский учёный в области компьютерных систем; один из авторов TinyOS и руководителей работ по беспроводным сенсорным сетям (Berkeley Motes), PlanetLab и масштабируемым параллельным системам.


🌐 Знаковые события

1965 — в СССР запускается в сторону Венеры автоматическая межпланетная станция «Венера-2».

1980 — американская автоматическая межпланетная станция «Вояджер-1», отправленная 5 сентября 1977, пересекает орбиту Сатурна, проходя от него на расстоянии 124 000 км и в 4500 км от его спутника Титана.

#Biography #Birth_Date #Events #12Ноября
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3
Раздел 6. Коллекции в Java

Глава 5. Map — отображения (словари)

Основные методы: containsKey - глубокое погружение в механизм проверки существования ключей

Основная концепция метода containsKey заключается в предоставлении быстрого и эффективного способа проверки принадлежности ключа к домену Map. В отличие от метода get, который возвращает ассоциированное значение, containsKey фокусируется исключительно на факте существования связи, что делает его особенно полезным в сценариях предварительной проверки перед выполнением дорогостоящих операций или в логике условного выполнения.



Общий алгоритм работы containsKey

Процесс выполнения метода containsKey(key) представляет собой последовательность взаимосвязанных этапов, каждый из которых вносит свой вклад в общую эффективность и корректность операции:

Фаза предварительной обработки и валидации:
Анализ типа и состояния ключа на соответствие требованиям конкретной реализации Map
Проверка специальных случаев, таких как null-ключи, с учетом специфики реализации
Подготовка ключа к процессу поиска через вычисление производных характеристик


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


Фаза точного сравнения и верификации:
Выполнение точной проверки соответствия через механизмы сравнения, специфичные для реализации
Учет семантики равенства, которая может варьироваться от ссылочного до глубокого сравнения
Формирование итогового результата на основе всех проведенных проверок


Детальный разбор для HashMap

Процесс хэширования и определения бакета
В HashMap проверка существования начинается с вычисления хэш-кода ключа, однако система использует не просто результат метода hashCode(), а применяет дополнительную трансформацию для улучшения распределения. Этот процесс, известный как "вторичное хэширование" или "perturbation", включает битовые операции для смешивания старших и младших битов хэш-кода, что значительно уменьшает вероятность коллизий для ключей с плохими хэш-функциями.

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



#Java #для_новичков #beginner #Map #containsKey
👍1
Поиск в цепочке коллизий
После определения целевого бакета начинается процесс поиска в соответствующей цепочке.

Возможные сценарии значительно варьируются по сложности:
Бакет пуст: Самый оптимальный случай — система немедленно возвращает false, так как элемент гарантированно отсутствует. Эта проверка требует минимальных вычислительных ресурсов.
Бакет содержит один узел: Система выполняет многоуровневую проверку совпадения. Сначала сравниваются хэш-коды — быстрая предварительная проверка, которая позволяет быстро отсечь заведомо несовпадающие ключи. Если хэши совпали, выполняется проверка ссылочного равенства (==) — высокоэффективная операция, которая часто срабатывает для часто используемых или кэшированных ключей. Только если предыдущие проверки не дали результата, вызывается метод equals() для точного семантического сравнения.
Бакет содержит несколько узлов: Начинается последовательный обход цепочки.


В зависимости от внутренней структуры цепочки применяются различные стратегии поиска:
Для связных списков (короткие цепочки) выполняется линейный поиск с последовательной проверкой каждого узла
Для красно-черных деревьев (длинные цепочки в Java 8+) выполняется бинарный поиск с учетом порядка ключей, что значительно улучшает производительность для длинных цепочек


Эволюция обработки коллизий в современных HashMap


В Java 8 и выше были введены революционные улучшения в обработке коллизий. Когда цепочка достигает определенного порога (обычно 8 элементов), она автоматически преобразуется из связного списка в красно-черное дерево.


Это преобразование кардинально меняет сложность поиска в худшем случае:
В связном списке: O(n) в худшем случае
В красно-черном дереве: O(log n) в худшем случае

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



Особенности LinkedHashMap

В LinkedHashMap процесс проверки существования полностью наследует базовую логику HashMap, но с важным концептуальным отличием — хотя порядок элементов поддерживается, он не влияет на алгоритм поиска. Однако есть тонкие аспекты, связанные с семантикой доступа:

Сохранение семантики порядка доступа
При использовании LinkedHashMap в режиме access-order (когда карта создана с параметром accessOrder = true) важно отметить, что метод containsKey не считается операцией доступа и не влияет на порядок элементов. Это отличает его от метода get, который в таком режиме перемещает найденный элемент в конец списка доступа.

Эффективность при последовательном доступе
Хотя алгоритм поиска идентичен HashMap, характер использования LinkedHashMap часто предполагает последовательный доступ к элементам в порядке их добавления или последнего использования. Это может косвенно влиять на производительность containsKey через механизмы предсказания доступа к памяти и кэширования процессора.


#Java #для_новичков #beginner #Map #containsKey
👍2
Специфика TreeMap

В TreeMap механизм проверки существования фундаментально отличается от хэш-базированных реализаций, поскольку основан на свойствах упорядоченного бинарного дерева поиска:

Алгоритм поиска в красно-черном дереве
Поиск начинается с корневого узла и рекурсивно спускается вниз по дереву, следуя принципам бинарного поиска:
Если искомый ключ меньше ключа текущего узла — поиск продолжается в левом поддереве
Если искомый ключ больше ключа текущего узла — поиск продолжается в правом поддереве
При равенстве ключей — немедленное возвращение true

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


Механизмы сравнения ключей

TreeMap использует один из двух возможных механизмов сравнения, что значительно влияет на семантику проверки существования:
Естественный порядок: Если ключи реализуют интерфейс Comparable, используется их естественный порядок сортировки. Это требует, чтобы все ключи были взаимно сравнимы и следовали контракту Comparable.
Внешний компаратор: Если TreeMap создан с предоставленным Comparator, используется он. Это позволяет использовать ключи, не реализующие Comparable, или устанавливать альтернативный порядок сортировки.

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


Гарантии производительности благодаря балансировке
Красно-черное дерево, используемое в TreeMap, является самобалансирующейся структурой данных, что гарантирует:
Высота дерева всегда пропорциональна логарифму количества элементов
Время поиска остается O(log n) даже в худшем случае
Автоматическую адаптацию к любым последовательностям вставки и удаления

Балансировка достигается через сложные алгоритмы перекрашивания и вращения, которые выполняются автоматически при модификации дерева.



Специализированные реализации

ConcurrentHashMap

В ConcurrentHashMap механизм проверки существования оптимизирован для многопоточного доступа и обеспечивает уникальные гарантии:
Неблокирующее чтение: Операция containsKey в большинстве случаев не требует блокировок, что позволяет множеству потоков одновременно выполнять проверки существования.
Слабая согласованность (Weak Consistency): В условиях конкурентного доступа метод может не отражать самые последние изменения, но гарантирует eventual consistency.
Сегментированный доступ: В старых версиях поиск ограничивается одним сегментом, в новых — используются более тонкие механизмы изоляции.
Гарантии видимости: Обеспечиваются proper happens-before отношения для операций, выполненных в одном потоке.



EnumMap
EnumMap предоставляет наиболее эффективный механизм проверки существования:
Проверка превращается в простую операцию проверки наличия элемента в массиве по индексу
Индекс вычисляется на основе ordinal значения enum-константы
Сложность O(1) с минимальными накладными расходами
Гарантированная производительность независимо от размера коллекции


IdentityHashMap
Особенность проверки существования в IdentityHashMap — использование ссылочного равенства вместо семантического:
Сравнение ключей происходит через оператор ==, а не через equals()
Хэш-код вычисляется на основе System.identityHashCode()
Полезно для сценариев, где важно различать объекты по идентичности, а не по состоянию
Особенно эффективно для часто используемых или кэшированных объектов



WeakHashMap
В WeakHashMap семантика проверки существования тесно связана с системой сборки мусора:
Ключи могут быть автоматически удалены сборщиком мусора, если на них нет сильных ссылок
Результат containsKey может измениться без явного вызова методов удаления
Полезно для кэшей и временных ассоциаций, где автоматическое очищение является желательным поведением



#Java #для_новичков #beginner #Map #containsKey
👍1
Обработка особых случаев

Работа с null ключами
Разные реализации Map демонстрируют различное поведение при проверке null ключей:
HashMap: Специально обрабатывает null ключ, храня его в бакете с индексом 0. Проверка containsKey(null) возвращает true, если null ключ был ранее добавлен.
TreeMap: Не поддерживает null ключи — вызов containsKey(null) всегда выбрасывает NullPointerException.
ConcurrentHashMap: Не поддерживает null ключи — вызов containsKey(null) всегда возвращает false.
LinkedHashMap: Наследует поведение HashMap относительно null ключей.

Семантика равенства и сравнения
Процесс определения равенства ключей является критически важным для корректности операции containsKey.

Разные реализации используют различные стратегии:
HashMap и LinkedHashMap используют комбинацию проверок:
Сравнение хэш-кодов для быстрой предварительной проверки
Проверка ссылочного равенства (==) для оптимизации частого случая
Вызов equals() для точного определения семантического равенства

TreeMap: Использует либо естественный порядок (Comparable), либо предоставленный Comparator. Метод equals() ключей не используется напрямую для поиска.
IdentityHashMap: Использует исключительно ссылочное равенство (==).
EnumMap: Использует равенство enum-констант, которое по сути является ссылочным равенством.



Практические рекомендации

Эффективное использование containsKey
Паттерн проверки перед действием: Часто используется для предотвращения дублирования или выполнения условной логики:

if (!map.containsKey(key)) {
// Выполнить дорогостоящую операцию только если ключ отсутствует
Value value = computeExpensiveValue(key);
map.put(key, value);
}


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

Избегание избыточных проверок: В некоторых случаях более эффективно использовать get с проверкой на null:
// Вместо:
if (map.containsKey(key)) {
Value value = map.get(key);
// обработка value
}

// Можно использовать:
Value value = map.get(key);
if (value != null) {
// обработка value
}


Выбор реализации для различных сценариев

Для частых операций проверки существования:

HashMap с хорошими хэш-функциями — оптимальный выбор
EnumMap — для enum ключей (максимальная производительность)
IdentityHashMap — когда важна ссылочная семантика


Для отсортированных данных с проверкой существования:

TreeMap — когда нужна сортировка или проверка в диапазонах

Для многопоточных сценариев:
ConcurrentHashMap — для высококонкурентного доступа
Collections.synchronizedMap() — для низкой конкуренции


Оптимизация ключей
Неизменяемость: Использование immutable ключей гарантирует консистентность хэш-кодов и предотвращает subtle ошибки.

Эффективные equals() и hashCode():
Минимизация вычислительной сложности этих методов
Кэширование хэш-кода для сложных объектов
Использование быстрых алгоритмов сравнения
Обеспечение консистентности между equals() и hashCode()

Правильный размер коллекции: Предварительное задание адекватной емкости для HashMap уменьшает необходимость операций resize и улучшает распределение.


#Java #для_новичков #beginner #Map #containsKey
👍1
Что выведет код?

import java.util.HashMap;
import java.util.Map;

public class Task121125 {
public static void main(String[] args) {
Map<Key121125, String> map = new HashMap<>();

Key121125 k1 = new Key121125(1);
Key121125 k2 = new Key121125(1);

map.put(k1, "value");

System.out.println(map.containsKey(k1));
System.out.println(map.containsKey(k2));

k1.id = 2;

System.out.println(map.containsKey(k1));
System.out.println(map.containsKey(k2));
}

static class Key121125 {
int id;
Key121125(int id) { this.id = id; }

public boolean equals(Object o) {
return o instanceof Key121125 && this.id == ((Key121125) o).id;
}

public int hashCode() {
return id;
}
}
}


#Tasks
Вопрос с собеседований

Чем отличается @Autowired от @Qualifier? 🤓


Ответ:

@Autowired внедряет зависимость по типу.

Если несколько реализаций, используется
@Qualifier для указания конкретного бина.

Например,
@Qualifier("fastPaymentService") поможет выбрать нужную реализацию интерфейса PaymentService.


#собеседование
Please open Telegram to view this post
VIEW IN TELEGRAM
👍1🗿1