⌨️ Что такое Heap и Stack память в Java? Какая разница между ними?

Heap (куча) используется Java Runtime для выделения памяти под объекты и классы. Создание нового объекта также происходит в куче. Это же является областью работы сборщика мусора. Любой объект, созданный в куче, имеет глобальный доступ и на него могут ссылаться из любой части приложения.

Stack (стек) это область хранения данных также находящееся в общей оперативной памяти (RAM). Всякий раз, когда вызывается метод, в памяти стека создается новый блок, который содержит примитивы и ссылки на другие объекты в методе. Как только метод заканчивает работу, блок также перестает использоваться, тем самым предоставляя доступ для следующего метода. Размер стековой памяти намного меньше объема памяти в куче. Стек в Java работает по схеме LIFO (Последний-зашел-Первый-вышел)

Различия между Heap и Stack памятью:

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

✔️ Всякий раз, когда создается объект, он всегда хранится в куче, а в памяти стека содержится лишь ссылка на него. Память стека содержит только локальные переменные примитивных типов и ссылки на объекты в куче.

✔️ Объекты в куче доступны с любой точки программы, в то время как стековая память не может быть доступна для других потоков.

✔️ Стековая память существует лишь какое-то время работы программы, а память в куче живет с самого начала до конца работы программы.

✔️ Если память стека полностью занята, то Java Runtime бросает исключение java.lang.StackOverflowError. Если заполнена память кучи, то бросается исключение java.lang.OutOfMemoryError: Java Heap Space.

✔️ Размер памяти стека намного меньше памяти в куче.

✔️ Из-за простоты распределения памяти, стековая память работает намного быстрее кучи.

Для определения начального и максимального размера памяти в куче используются -Xms и -Xmx опции JVM. Для стека определить размер памяти можно с помощью опции -Xss.

#java #heap #stack #memory

⌨️ Что такое default методы интрефейса?

Java 8 позволяет добавлять неабстрактные реализации методов в интерфейс, используя ключевое слово default:

interface Example {
    int process(int a);
    default void show() {
        System.out.println("default show()");
    }
}

✔️Если класс реализует интерфейс, он может, но не обязан, реализовать методы по-умолчанию, уже реализованные в интерфейсе. Класс наследует реализацию по умолчанию.

✔️Если некий класс реализует несколько интерфейсов, которые имеют одинаковый метод по умолчанию, то класс должен реализовать метод с совпадающей сигнатурой самостоятельно. Ситуация аналогична, если один интерфейс имеет метод по умолчанию, а в другом этот же метод является абстрактным - никакой реализации по умолчанию классом не наследуется.

✔️Метод по умолчанию не может переопределить метод класса java.lang.Object.

✔️Помогают реализовывать интерфейсы без страха нарушить работу других классов.

✔️Позволяют избежать создания служебных классов, так как все необходимые методы могут быть представлены в самих интерфейсах.

✔️Дают свободу классам выбрать метод, который нужно переопределить.

✔️Одной из основных причин внедрения методов по умолчанию является возможность коллекций в Java 8 использовать лямбда-выражения.

Вызывать default метод интерфейса в реализующем этот интерфейс классе можно используя ключевое слово super вместе с именем интерфейса:

interface Paper {
    default void show() {
        System.out.println("default show()");
    }
}

class Licence implements Paper {
    public void show() {
        Paper.super.show();
    }
}

⌨️ Что такое static метод интерфейса?

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

✔️Статические методы в интерфейсе являются частью интерфейса без возможности переопределить их для объектов класса реализации;

✔️Методы класса java.lang.Object нельзя переопределить как статические;

✔️Статические методы в интерфейсе используются для обеспечения вспомогательных методов, например, проверки на null, сортировки коллекций и т.д.

Вызывать static метод интерфейса можно используя имя интерфейса:

interface Paper {
    static void show() {
        System.out.println("static show()");
    }
}

class Licence {
    public void showPaper() {
        Paper.show();
    }
}

⌨️ Switch Expressions

В Java 12 появился новый синтаксис для switch, который позволяет возвращать значение используя стрелки ->, что делает код более компактным и удобным. Теперь switch может использоваться как выражение, а не только как оператор, что упрощает его применение в логике.

Ранее switch использовался как оператор, и код мог выглядеть громоздко:

String day = "MONDAY";
int numLetters;
switch (day) {
    case "MONDAY":
    case "FRIDAY":
    case "SUNDAY":
        numLetters = 6;
        break;
    case "TUESDAY":
        numLetters = 7;
        break;
    default:
        numLetters = 8;
}
System.out.println(numLetters); // Вывод: 6

Со Switch Expressions можно переписать этот код более лаконично:

String day = "MONDAY";
int numLetters = switch (day) {
    case "MONDAY", "FRIDAY", "SUNDAY" -> 6;
    case "TUESDAY" -> 7;
    default -> 8;
};
System.out.println(numLetters); // Вывод: 6

Теперь switch может вернуть значение, и нет необходимости в break.

#java #switch

⌨️ Использование java.util.stream.Collectors для обработки коллекций

Код:

import java.util.List;
import java.util.stream.Collectors;

public class StreamCollectorsExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Примеры использования Collectors
        // Преобразование элементов коллекции в строку
        String numbersAsString = numbers.stream()
                                        .map(Object::toString)
                                        .collect(Collectors.joining(", "));
        System.out.println("Числа в виде строки: " + numbersAsString);
        
        // Получение среднего значения всех элементов коллекции
        double average = numbers.stream()
                                 .collect(Collectors.averagingInt(Integer::intValue));
        System.out.println("Среднее значение: " + average);
        
        // Фильтрация элементов и сборка их в новую коллекцию
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(num -> num % 2 == 0)
                                           .collect(Collectors.toList());
        System.out.println("Четные числа: " + evenNumbers);
        
        // Группировка элементов по условию
        System.out.println("Числа по остатку от деления на 3: " + numbers.stream()
                                                                      .collect(Collectors.groupingBy(num -> num % 3)));
    }
}

⚙️Этот пример демонстрирует использование класса Collectors из пакета java.util.stream для более эффективной обработки коллекций в Java. Методы класса Collectors предоставляют различные операции для сбора (collecting) элементов из потока данных в различные структуры данных или для выполнения агрегатных операций над элементами потока.

⌨️ var в Java 10+: удобство или ловушка?

Java 10 принес с собой var — возможность объявлять переменные без явного указания типа. Это делает код короче, но может иметь последствия.

Пример:

var list = new ArrayList<String>();

➡️ Компилятор сам выводит тип. Вроде удобно. Но давай разберем плюсы и минусы.

✔️ Плюсы использования var:

1. 👍 Меньше шаблонного кода

Не надо повторять длинные типы:

   var map = new HashMap<String, List<Integer>>();
   

2. 👍 Лучшая читаемость при очевидных типах

Когда справа всё ясно — var делает код чище.

3. 👍 Удобно для циклов

   for (var entry : map.entrySet()) { ... }
   

➡️ особенно в сочетании с лямбдами и stream API.

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

1. 🟢 Потеря явности типа

   var result = someMethod();  // Что за тип?
   

➡️ Нужно смотреть реализацию метода или IDE-подсказки.

2. 🟢 Повышается риск ошибок

Пример: можно случайно получить Object, если возвращается не тот тип.

3. 🟢 Плох для публичного API

В методах и сигнатурах var использовать нельзя — и это правильно: API должно быть прозрачным.

📌 Лучшие практики:

✔️ Используй var, когда тип очевиден
❌ Избегай в сложных выражениях с неочевидным выводом типа
❌ Не используй в публичных API или при работе в больших командах без согласованных правил

🗣️ Запомни: var — это инструмент, не костыль. Он не делает Java динамической. Используй его с умом — для читаемости, а не ради моды.

⌨️ Есть ли какие-либо рекомендации о том, какие поля следует использовать при подсчете hashCode()?

Общий совет: выбирать поля, которые с большой долью вероятности будут различаться. Для этого необходимо использовать уникальные, лучше всего примитивные поля, например, такие как id, uuid. При этом нужно следовать правилу, если поля задействованы при вычислении hashCode(), то они должны быть задействованы и при выполнении equals().

#java #hashCode #equals

⌨️ Поддержка лямбда выражений в своём коде

В Java лямбда-выражения используются с функциональными интерфейсами, которые имеют ровно один абстрактный метод. Например, стандартный функциональный интерфейс Function из пакета java.util.function представляет собой типичный пример.

Для нашего примера используем встроенный функциональный интерфейс IntUnaryOperator. Он выглядит вот так:

@FunctionalInterface
public interface IntUnaryOperator {
    int applyAsInt(int operand);
}

Этот интерфейс представляет функцию, которая принимает один аргумент типа int и возвращает значение типа int.

import java.util.function.IntUnaryOperator;

public class Main {
    public static int applyOperation(int number, IntUnaryOperator operator) {
        return operator.applyAsInt(number);
    }

    public static void main(String[] args) {
        int number = 5;

        // Лямбда-выражение для удвоения значения
        IntUnaryOperator doubleOperation = x -> x * 2;
        System.out.println("Double: " + applyOperation(number, doubleOperation)); // Double: 10

        // Лямбда-выражение для увеличения значения на 10
        IntUnaryOperator addTenOperation = x -> x + 10;
        System.out.println("Add Ten: " + applyOperation(number, addTenOperation)); // Add Ten: 15
    }
}

В нашем примере метод applyOperation принимает два параметра: число и функциональный интерфейс IntUnaryOperator. Лямбда-выражение используется для определения конкретной функции.

#java #lambda #IntUnaryOperator

☕️Использование метода computeIfAbsent() из интерфейса Map.

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

Пример кода с объяснением:

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> wordLengths = new HashMap<>();
        String word = "apple";

        // Использование computeIfAbsent для вычисления и вставки значения в Map
        wordLengths.computeIfAbsent(word, String::length);

        // Вывод длины слова "apple", которая была вычислена и вставлена в Map
        System.out.println("Длина слова apple: " + wordLengths.get(word));
    }
}

🔒В этом примере мы используем метод computeIfAbsent() для wordLengths, чтобы вычислить и вставить длину слова "apple" в Map, если она отсутствует. Если значение уже присутствует, метод возвращает текущее значение.

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

⌨️ Generics и стирание типов

При компиляции все параметры обобщённых типов удаляются («стираются»), и на их место подставляется либо ограничивающий тип (T extends Number → Number), либо Object.
Это нужно для совместимости с «сырыми» классами до появления Generics в Java 5.

Последствия стирания типов:

1️⃣ Нельзя создавать массивы обобщённого типа:

// Ошибка компиляции!
List<String>[] array = new List<String>[10];

2️⃣ Нельзя проверить во время выполнения, является ли объект именно List<String>:

List<String> list = List.of("a", "b");
if (list instanceof List<String>) { … } // компилятор не пропустит

3️⃣ Перегрузка методов с разными параметрами-дженериками конфликтует:

// Ошибка name clash: стираются оба в process(Collection)
void process(Collection<String> c) { … }
void process(Collection<Integer> c) { … }

Стиpaниe типов позволяет Java Generics не увеличивать размер байт-кода и оставаться совместимой с ранними версиями платформы, но налагает ограничения на проверку и создание обобщённых типов во время выполнения.

🧪 Тесты с JUnit 5 — основные аннотации

JUnit 5 — это не просто @Test. Он принёс гибкость, читаемость и мощные возможности для модульного тестирования.

Вот мини-шпаргалка по ключевым аннотациям, которые ты реально будешь использовать.

1. ✅ @Test — запуск теста

@Test
void shouldReturnTrueWhenInputIsValid() {
    assertTrue(MyService.validate("test"));
}

➡️ Основная аннотация. Методы с ней — это тесты.

2. 🧱 @BeforeEach и @AfterEach — подготовка и очистка

@BeforeEach
void init() {
    db.connect();
}

@AfterEach
void cleanup() {
    db.disconnect();
}

➡️ Выполняются до и после каждого теста. Удобно для настройки окружения.

3. 🏗 @BeforeAll и @AfterAll — один раз на весь класс

@BeforeAll
static void globalSetup() {
    System.out.println("Запускаем все тесты");
}

➡️ Статические методы, которые выполняются один раз перед/после всех тестов.


4. 🎯 @DisplayName — читаемое имя теста

@DisplayName("Должен вернуть true при корректном email")
@Test
void validEmailTest() {
    assertTrue(EmailValidator.isValid("test@example.com"));
}

➡️ Название будет красиво отображаться в отчётах и IDE.

5. 🧪 @Nested — группировка тестов

@Nested
class WhenUserIsAdmin {
    @Test
    void shouldHaveFullAccess() { ... }
}

➡️Логическая структура внутри тест-класса. Удобно для сценариев.

6. ⚙️ @ParameterizedTest + @ValueSource — параметризованные тесты

@ParameterizedTest
@ValueSource(strings = {"admin", "user", "guest"})
void roleShouldNotBeNull(String role) {
    assertNotNull(role);
}

➡️ Запускает один и тот же тест с разными значениями.

7. 🚫 @Disabled — временно отключить тест

@Disabled("Фича ещё не реализована")
@Test
void futureFeatureTest() {
    fail("не должно запускаться");
}

➡️ Полезно, когда фича в разработке, а тест уже написан.

🗣 Запомни:JUnit 5 — это про читаемость, контроль и минимум лишнего кода. Используй аннотации не ради галочки, а чтобы тесты были понятны даже спустя полгода.

🔄 stream().map().filter().collect() — читаемо и мощно

Java Stream API — это как grep | awk | sort в Linux, только в Java-стиле.
Самая частая связка: map → filter → collect. И она может заменить кучу шаблонного кода.

Допустим, у нас есть список:

List<String> names = List.of("Alice", "bob", "CHARLIE", "dave");

👉 Хочешь получить отфильтрованные, приведённые к верхнему регистру имена, которые длиннее 3 символов?

До Stream API:

List<String> result = new ArrayList<>();
for (String name : names) {
    String upper = name.toUpperCase();
    if (upper.length() > 3) {
        result.add(upper);
    }
}

С stream():

List<String> result = names.stream()
    .map(String::toUpperCase)
    .filter(s -> s.length() > 3)
    .collect(Collectors.toList());

➡️ Читаемо, как SQL: "преобразуй → отфильтруй → собери".


✔️ Разберём подробнее:

1. `map()` — преобразование

   .map(String::trim)
   .map(String::toLowerCase)
   

🔄 Применяет функцию ко всем элементам. Тип может измениться.

2. `filter()` — отбор

   .filter(s -> s.startsWith("a"))
   

❓ Оставляет только те элементы, которые удовлетворяют условию.

3. `collect()` — сборка результата

   .collect(Collectors.toSet())
   .collect(Collectors.joining(", "))
   

🧺 Собирает результат обратно в список, множество, строку и т.д.

📌 Реальный пример — фильтруем активных пользователей по возрасту:

List<User> users = getUsers();

List<String> activeAdults = users.stream()
    .filter(User::isActive)
    .filter(u -> u.getAge() >= 18)
    .map(User::getName)
    .collect(Collectors.toList());

➡️ Без лишних if, for и add() — код фокусируется на логике, а не на реализации.

🗣 Запомни: Цепочка map().filter().collect() — это про читаемый и декларативный код.
Не пиши как императивный робот, пиши как человек: что ты хочешь получить — а не как это сделать.

☕️ final в Java — стоп-сигнал для изменений

В Java final — это как «не трогай»: запрет на изменение.
Но что именно он запрещает? Всё зависит от того, где его поставить: переменная, метод, класс.

Разберёмся 👇

1. 📦 final переменные — нельзя переназначить

final int port = 8080;
port = 9090; // ❌ ошибка компиляции

➡️ Значение фиксируется один раз. Для примитивов — это само значение, для объектов — это ссылка.

final List<String> list = new ArrayList<>();
list.add("Hello");         // ✅ можно
list = new ArrayList<>();  // ❌ нельзя

🧠 Важно: final не делает объект неизменяемым. Только ссылку.

2. 🔒 final методы — нельзя переопределить в наследниках

class Animal {
    final void sleep() {
        System.out.println("Zzz...");
    }
}

class Dog extends Animal {
    // ❌ Нельзя переопределить sleep()
}

➡️ Полезно, если хочешь защитить логику метода от изменений в подклассах.

3. 🧱 final классы — нельзя наследовать вообще

final class Utility {
    static void log(String msg) { ... }
}

class MyUtil extends Utility {} // ❌ ошибка

➡️ Применяют для:

🟢 утилитарных классов (Math, String)
🟢 защиты от подмены логики (SecurityManager, System)

🎯 Частые применения в дикой природе:

🟢 final аргументы в методах → защищает от случайного переназначения
🟢 final поля + @Immutable → хорошая практика для DTO
🟢final классы → в record, enum, String, LocalDate и т.д.


🗣 Запомни:final = контроль. Это способ сказать «вот это трогать нельзя». Используй его осознанно — чтобы сделать поведение предсказуемым и безопасным.

☕️Text Blocks в Java: читаемые строки без \n и слёз

До Java 13 работа с многострочными строками была болью. JSON? HTML? SQL? Только через "\n" + и кучу экранирования.
Но с Text Blocks всё стало проще, понятнее и читаемо.

Сравни:

❌ До:

String html = "<html>\n" +
              "  <body>Hello</body>\n" +
              "</html>";

✅ После (Text Block):

String html = """
    <html>
      <body>Hello</body>
    </html>
    """;

➡️ Стало чище, короче и как в оригинале. Это обычная String, просто оформленная красиво.

✔️ Преимущества Text Blocks:

1. 👍 Читаемость на уровне "как есть"
Код больше не превращается в кашу. Особенно полезно для:

SQL-запросов:

     String query = """
         SELECT id, name
         FROM users
         WHERE active = true
         ORDER BY created_at DESC
         """;
     

HTML/JSON шаблонов:

     String json = """
         {
           "name": "Alice",
           "role": "admin"
         }
         """;
     

2. 👍 Меньше экранирования
Забудь про \", \\n, \\t — теперь можно писать почти как в блокноте.

3. 👍 Автоматическое выравнивание
Java сама уберёт начальные отступы на основе самой "узкой" строки.

Пример:

   String msg = """
           Line 1
           Line 2
       Line 3
       """;
   

➡️ Результат будет:

Line 1
Line 2
Line 3

4. 👍 Интеграция с .formatted()
Нельзя вставить переменные прямо в Text Block?
Используем .formatted() — коротко и читабельно:

String user = "Bob";
String template = """
    {
      "user": "%s",
      "access": "granted"
    }
    """.formatted(user);
````
   ```java
   String s = """
       Hello""";
   System.out.println(s.length());  // 6, а не 5 (есть \n)
   

3. 🟢 Нет интерполяции переменных
Нельзя писать так:

   String name = "Eve";
   String wrong = """
       Hello, $name!
       """;  // ❌ не сработает
   

Вместо этого:

   String right = """
       Hello, %s!
       """.formatted(name);
   

🗣️ Запомни: Text Blocks делают строки в Java человечными. Это не просто сахар — это инструмент, чтобы твой код говорил с тобой на одном языке. Используй их для всего, что требует форматирования — и забудь про + "\n".

🏭 Factory в Java: просто, без бойлерплейта

Factory-паттерн — это способ создавать объекты, не раскрывая логику создания. Но в Java он часто обрастает шаблонами, абстракциями и XML'ем. Зачем? Можно проще.

Допустим, у нас есть интерфейс:

interface Notification {
    void send(String message);
}

И реализации:

class EmailNotification implements Notification {
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

class SmsNotification implements Notification {
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

➡️ А теперь сама Factory — без лишнего:

class NotificationFactory {
    public static Notification create(String type) {
        return switch (type) {
            case "email" -> new EmailNotification();
            case "sms"   -> new SmsNotification();
            default      -> throw new IllegalArgumentException("Unknown type");
        };
    }
}

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

Notification n = NotificationFactory.create("email");
n.send("Hello world!");

✔️ Что получили:

1. 👍 Централизованное создание объектов
Меняем реализацию в одном месте.

2. 👍 Гибкость без наследования
Можно возвращать любые классы — хоть анонимные, хоть лямбды.

3. 👍 Без бойлерплейта
Никаких XML, DI-фреймворков и пяти уровней абстракции.


⚠️ Но не переусердствуй:

1. 🟢 Не делай фабрику ради фабрики
Если new работает — не трогай.

2. 🟢 Не забывай про enum
Часто enum c фабрикой — читается лучше, чем строки.

🗣️ Запомни: Factory — это не про паттерны ради паттернов. Это про чистый код и простую подмену реализаций. Не усложняй — Java и так может быть элегантной.

🚀 Кеширование с @Cacheable — быстро и просто в Spring

Когда метод тяжёлый (долго считает, лезет в БД или API) — зачем вызывать его 100 раз, если результат тот же?
Решение: кеш. В Spring это делается одной аннотацией.

✅ Что делает @Cacheable?

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

@Cacheable("users")
public User getUserById(Long id) {
    System.out.println("Fetching from DB...");
    return userRepository.findById(id).orElseThrow();
}

Первый вызов: метод выполнится → результат кешируется.
Следующие вызовы с тем же id: результат берётся из кеша.

⚙️ Как включить кеш?

1. Добавь зависимость (если ещё нет):

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

2. Включи кеш в @Configuration:

@EnableCaching
@SpringBootApplication
public class MyApp { }

Spring по умолчанию использует простой in-memory кеш (ConcurrentHashMap), но можно подключить Caffeine, Redis, Ehcache и т.д.

🔍 Продвинутые фишки:

🎯 Ключ кеша по полям:

@Cacheable(value = "products", key = "#category + ':' + #limit")
public List<Product> getTopProducts(String category, int limit) { ... }

⛔️ Пропуск кеша при null:

@Cacheable(value = "data", unless = "#result == null")
public Data fetchData(String key) { ... }

🔁 Обновление кеша вручную:

@CachePut("users")
public User updateUser(User user) { ... }

🧹 Очистка кеша:

@CacheEvict(value = "users", key = "#id")
public void deleteUser(Long id) { ... }

🗣 Запомни:@Cacheable — это «копим и не дёргаем зря».
С ним ты ускоряешь работу приложения без лишнего кода, особенно если есть дорогие вызовы (БД, сеть, парсинг).

☕️ Java - Полный Курс по Java

Этот курс охватывает основы Java, включая установку JDK, работу с переменными, условными операторами, циклами и объектно-ориентированным программированием. Подходит для тех, кто только начинает знакомство с языком

🤩 Java Фишки и трюки || #Видео

⌨️ Что такое класс Object? Какие в нем есть методы?

Object это базовый класс для всех остальных объектов в Java. Любой класс наследуется от Object и, соответственно, наследуют его методы:

public boolean equals(Object obj) – служит для сравнения объектов по значению;

int hashCode() – возвращает hash код для объекта;

String toString() – возвращает строковое представление объекта;

Class getClass() – возвращает класс объекта во время выполнения;

protected Object clone() – создает и возвращает копию объекта;

void notify() – возобновляет поток, ожидающий монитор;

void notifyAll() – возобновляет все потоки, ожидающие монитор;

void wait() – остановка вызвавшего метод потока до момента пока другой поток не вызовет метод notify() или notifyAll() для этого объекта;

void wait(long timeout) – остановка вызвавшего метод потока на определённое время или пока другой поток не вызовет метод notify() или notifyAll() для этого объекта;

void wait(long timeout, int nanos) – остановка вызвавшего метод потока на определённое время или пока другой поток не вызовет метод notify() или notifyAll() для этого объекта;

protected void finalize() – может вызываться сборщиком мусора в момент удаления объекта при сборке мусора.

#java #Object #methods