🕯 Паттерн Строитель (Builder)

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

Использование:

🔹 Когда нужно создать объект с большим количеством параметров, и не все из них обязательны.
🔹 Когда процесс создания объекта требует выполнения нескольких шагов или дополнительных проверок.
🔹 В случаях, когда один и тот же код должен создавать разные представления объекта (например, текстовое и графическое).

Преимущества:

1️⃣ Упрощает создание сложных объектов, делая процесс понятным и читаемым.
2️⃣ Позволяет создавать объекты с разными вариациями без необходимости дублирования кода.
3️⃣ Разделяет логику создания объекта от его структуры, что упрощает поддержку и модификацию кода.

Недостатки:

1️⃣ Увеличивает сложность кода за счёт создания дополнительных классов и методов.
2️⃣ Может быть избыточным для простых объектов с небольшим количеством параметров.
3️⃣ Требует дополнительного внимания при проектировании, чтобы избежать путаницы между обязательными и необязательными шагами.

📌 Паттерн Builder полезен, если объект имеет много параметров и их нужно задавать гибко. Например, при создании сложных конфигураций для HTTP-запросов (заголовки, тело, параметры), построении графических интерфейсов или генерации HTML-документов. Builder помогает сделать код более понятным и избежать создания конструкций с длинными и неудобными конструкторами.

💡 Глубокий взгляд на реализацию Arrays.sort()

А вы задумывались, что скрывается под капотом Arrays.sort()? Быстрая сортировка? Пузырёк? Или, может, что-то ещё?

На самом деле, Arrays.sort() – это больше, чем просто сортировка. Этот метод использует адаптивные алгоритмы и оптимизации, которые подстраиваются под тип данных и размер массива. А главное – в его реализации предусмотрена защита от худших случаев, таких как неудачное распределение данных, чтобы всегда обеспечивать стабильную производительность.

1️⃣ Примитивы: Dual-Pivot Quicksort

Для массивов примитивных типов (int, double и т.д.) используется Dual-Pivot Quicksort. Он выбирает два опорных элемента, которые делят массив на три части: элементы меньше первого опорного, между опорными и больше второго, с последующей рекурсивной сортировкой каждой части.

🔍 Как это выглядит:

if (arr[left] > arr[right]) {
    swap(arr, left, right); 
}
int pivot1 = arr[left];
int pivot2 = arr[right];

int i = left + 1, lt = left + 1, gt = right - 1;
while (i <= gt) {
    if (arr[i] < pivot1) {
        swap(arr, i++, lt++); // Элементы меньше первого опорного
    } else if (arr[i] > pivot2) {
        swap(arr, i, gt--);   // Элементы больше второго опорного
    } else {
        i++; // Элементы между опорными
    }
}
swap(arr, left, --lt);
swap(arr, right, ++gt);

📌 Почему это эффективно?

- Использование двух опорных элементов снижает глубину рекурсии.
- Разбиение на три части позволяет сбалансировать массив быстрее, чем в классическом Quicksort.
- Работает in-place, избегая лишних выделений.
- Даже на отсортированных или случайных данных Dual-Pivot Quicksort показывает стабильную производительность.

2️⃣ Ссылочные типы: Timsort

Если вы сортируете объекты (String, Integer и т.д.), то под капотом работает Timsort – гибридный алгоритм, который сочетает Merge Sort и Insertion Sort. Он адаптивно обрабатывает массивы, находя уже отсортированные последовательности (run'ы) и минимизируя количество операций для их слияния.

🔍 Как это выглядит:

int runLen = 32; // Минимальная длина run
for (int i = 0; i < array.length; i += runLen) {
    insertionSort(array, i, Math.min((i + runLen - 1), array.length - 1));
}

while (stackSize > 1) { 
    if (runLen[stackSize - 2] <= runLen[stackSize - 1]) {
        mergeRun(stackSize - 2, stackSize - 1); // Слияние соседних run'ов
    }
}

📌 Почему это эффективно?

- Timsort автоматически находит уже отсортированные подмассивы, уменьшая объём работы.
- Работает с заранее выделенными буферами для быстрого слияния подмассивов.
- Сохраняет порядок равных элементов, что важно для многих задач.
- Производительность близка к O(n) на частично отсортированных данных.

3️⃣ Небольшие массивы: Insertion Sort

Для массивов с небольшим количеством элементов (до 32) используется Insertion Sort (сортировка вставками). Он работает, проходя по массиву и вставляя каждый элемент на своё место в уже отсортированной части, сдвигая элементы, которые больше текущего, вправо. Этот алгоритм применяется, так как на малых объёмах данных он оказывается быстрее более сложных методов благодаря низким накладным расходам и простоте реализации.

🔍 Как это выглядит:

for (int i = left + 1; i <= right; i++) {
    int key = array[i];
    int j = i - 1;
    while (j >= left && array[j] > key) {
        array[j + 1] = array[j];
        j--;
    }
    array[j + 1] = key;
}

📌 Почему это эффективно?

- Алгоритм не требует дополнительной памяти и выполняется in-place.
- Сложность O(n^2) на больших данных компенсируется эффективностью на длине до 32 элементов.
- Использует уже загруженные данные в кэше процессора, что ускоряет доступ к памяти.

☄️ Проверь себя

Хочешь узнать, насколько ты прокачан в разработке? Тест для айтишников, чтобы проверить знания. Отличный способ отвлечься и сравнить результаты с друзьями!

👉 Пройти

💡 Как избежать катастрофы при переходе на PostgreSQL: руководство по спасению базы данных

Переход на PostgreSQL — это не просто замена одного инструмента другим. Неправильный подход может привести к потере данных, снижению производительности и длительным простоям. Особенно это касается хранимых процедур: различия между PL/pgSQL и языками, такими как PL/SQL или T-SQL, могут вызывать ошибки, которые сложно обнаружить заранее.

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

🔗 Читать статью
🔗 Зеркало

🖥 Топ-10 советов по настройке PostgreSQL

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

Вот несколько советов, которые помогут повысить производительность вашей базы данных:

👉 Переходите по ссылке

🔒 Pessimistic vs Optimistic Locking

🔵 Pessimistic Locking

- Запись недоступна для других потоков до тех пор, пока текущий поток не закончит работу с ней.
- Даже чтение данных другими потоками невозможно, пока лок не снят.
- Пример: EntityManager.lock(entity, LockModeType.PESSIMISTIC_WRITE) в JPA.
- Минусы: снижает производительность при высоком уровне конкурентного доступа.
- Когда применять: при критической необходимости точности данных.

🔵 Optimistic Locking

- Не блокирует данные при чтении, но проверяет версию записи при сохранении.
- Пример: аннотация @Version в JPA (колонка для хранения версии).
- Если версия изменена другим потоком, выбрасывается OptimisticLockException.
- Минусы: требует обработки конфликтов.
- Когда применять: при большом количестве чтений и низкой вероятности конфликтов.

💬 Какой подход вы чаще используете в своих проектах?

🏢📊 Как сократить расходы на инфраструктуру в 20 раз: опыт внедрения мультитенантной архитектуры

Снизить затраты на инфраструктуру в десятки раз — не фантастика, а реальность. Мультитенантная архитектура помогает не только экономить деньги, но и упрощает подключение новых клиентов, масштабирование и обслуживание системы. Такой подход значительно облегчает работу и открывает новые возможности для роста.

Хотите узнать, как правильно её внедрить, избежать типичных ошибок и достичь впечатляющих результатов? Ознакомьтесь с реальным опытом, который вдохновит на изменения. 🍹

🔗 Читать статью
🔗 Зеркало

❓ Что такое GraphQL?

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

❗️ Ключевые особенности GraphQL

🔵 Запросы по потребности

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

Пример:

query {
  user(id: "1") {
    name
    email
  }
}

Ответ:

{
  "data": {
    "user": {
      "name": "John Doe",
      "email": "[email protected]"
    }
  }
}

🔵 Единая точка входа (Single Endpoint)

В отличие от REST, где для разных операций используются разные URL (например, /users, /posts), в GraphQL всё взаимодействие происходит через единый эндпоинт, например, /graphql.

🔵 Гибкость и вложенные запросы

Можно запрашивать сложные связанные данные в одном запросе.

Пример:

query {
  user(id: "1") {
    name
    posts {
      title
      comments {
        text
      }
    }
  }
}

Ответ:

{
  "data": {
    "user": {
      "name": "John Doe",
      "posts": [
        {
          "title": "My First Post",
          "comments": [
            { "text": "Great post!" },
            { "text": "Very helpful, thanks!" }
          ]
        }
      ]
    }
  }
}

🔵 Строгая типизация

GraphQL API имеет чётко описанную схему данных. Это позволяет клиентам знать, какие поля доступны, и снижает вероятность ошибок.

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

type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post]
}

type Post {
  id: ID!
  title: String!
  comments: [Comment]
}

type Comment {
  id: ID!
  text: String!
}

🔵 Поддержка мутаций

GraphQL поддерживает не только чтение данных, но и их изменение через мутации.

Пример мутации:

mutation {
  createUser(input: { name: "Jane", email: "[email protected]" }) {
    id
    name
    email
  }
}

Ответ:

{
  "data": {
    "createUser": {
      "id": "2",
      "name": "Jane",
      "email": "[email protected]"
    }
  }
}

🔵 Реактивность через подписки (Subscriptions)

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

Пример:

subscription {
  messageAdded {
    id
    text
  }
}

🔼 Преимущества GraphQL

- Экономия трафика: Возвращает только запрошенные данные.
- Меньше запросов: Вложенные данные можно получить за один запрос.
- Документация встроена в схему: Инструменты вроде GraphiQL позволяют изучать API прямо в процессе разработки.
- Гибкость для клиентов: Клиент управляет структурой ответа.

🔽 Недостатки GraphQL

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

👀 Задачи с собеседований: Проверка, является ли бинарное дерево деревом поиска (middle)

— Как определить, является ли заданное бинарное дерево деревом поиска (BST)?

💡 Ключевые моменты:

- Бинарное дерево поиска (BST) — это бинарное дерево, в котором для каждого узла все значения в левом поддереве меньше значения узла, а все значения в правом поддереве больше.
- Для проверки можно использовать рекурсивный подход с отслеживанием допустимых диапазонов значений для каждого узла.
- Как изменить реализацию для работы с любыми типами данных в узлах дерева?

Реализация с числами в узлах на картинке 👆🏻