🤔 Почему синглтон называют антипаттерном?

Синглтон нарушает принципы SOLID, создавая скрытую глобальную зависимость. Это усложняет тестирование, расширение кода и может вызывать проблемы в многопоточности. Кроме того, он снижает гибкость архитектуры приложения, что делает его нежелательным для сложных систем.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Является ли пустым пул строк при старте jar файла или там есть какие-то значения?

Пул строк в Java не является пустым при старте JAR файла. Он изначально содержит несколько предопределенных строковых литералов, которые JVM использует для своей внутренней работы, а также строковые литералы, используемые в загруженных классах и стандартных библиотеках.

🚩Что изначально содержится

🟠Предопределенные строковые литералы
JVM и стандартные библиотеки Java используют различные строковые литералы для своей работы. Эти строки добавляются в пул строк при запуске JVM. Примеры таких строк включают имена основных классов и пакетов (например, "java/lang/Object", "java/lang/String").
🟠Строковые литералы, используемые в загруженных классах
Когда классы загружаются JVM, все строковые литералы, используемые в этих классах, добавляются в пул строк. Это включает строки, используемые в JAR файле, а также строки из стандартных библиотек Java, которые загружаются при старте.

🚩Пример строк в пуле при старте

Для демонстрации этого можно написать простой код, который проверяет, присутствуют ли определенные строки в пуле строк при старте программы.

public class StringPoolDemo {
    public static void main(String[] args) {
        // Проверка стандартных строк, которые могут быть в пуле строк
        String str1 = "java";
        String str2 = "lang";
        String str3 = "Object";

        // Вывод строк
        System.out.println("str1: " + str1);
        System.out.println("str2: " + str2);
        System.out.println("str3: " + str3);

        // Проверка строк в пуле строк
        System.out.println("Is 'java' in pool: " + (str1 == "java"));
        System.out.println("Is 'lang' in pool: " + (str2 == "lang"));
        System.out.println("Is 'Object' in pool: " + (str3 == "Object"));
    }
}

🚩Что происходит при старте JVM

🟠Инициализация JVM
При запуске JVM загружаются системные классы, такие как java.lang.Object, java.lang.String, java.lang.System, и другие. Строковые литералы, используемые в этих классах, добавляются в пул строк.
🟠Загрузка пользовательских классов
Когда JVM загружает пользовательские классы из JAR файла, все строковые литералы в этих классах также добавляются в пул строк.

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем идея Stream API?

Stream API — это инструмент для обработки коллекций и массивов с использованием функционального подхода. Он позволяет фильтровать, преобразовывать и агрегировать данные, используя методы, такие как map, filter, reduce. Stream API поддерживает ленивую обработку данных, что улучшает производительность, особенно с большими объёмами данных. Это упрощает написание кода и делает его более выразительным.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 За счет чего работают Lambda-выражения, что происходит "под капотом"?

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

🚩Как работают лямбда-выражения "под капотом"

Под капотом, лямбда-выражения в Java работают благодаря следующим ключевым концепциям и механизмам:

🟠Функциональные интерфейсы
Лямбда-выражения могут использоваться только в контексте функционального интерфейса, который является интерфейсом с одним абстрактным методом. Примеры функциональных интерфейсов: Runnable, Callable, Comparator, и интерфейсы из пакета java.util.function (Function, Predicate, Consumer, Supplier).

🟠Интерфейс `java.lang.invoke.MethodHandle` и `java.lang.invoke.LambdaMetafactory`
Лямбда-выражения компилируются в байт-код, который использует метод invokedynamic для создания инстанций функциональных интерфейсов. Этот механизм позволяет JVM динамически генерировать реализацию функционального интерфейса, используя метод-обработчик (MethodHandle).

🚩Что происходит при компиляции лямбда-выражения

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

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

🟠Что происходит под капотом
Компилятор преобразует лямбда-выражение в байт-код, который использует инструкцию invokedynamic. Инструкция invokedynamic указывает на метафабрику (LambdaMetafactory), которая отвечает за создание инстанции функционального интерфейса. Метафабрика создает реализацию функционального интерфейса, используя метод-обработчик (MethodHandle) для метода, определенного в лямбда-выражении.

🟠Преобразование в функциональный интерфейс
Лямбда-выражение name -> System.out.println(name) соответствует методу функционального интерфейса Consumer<String>. В байт-коде создается invokedynamic инструкция, которая ссылается на LambdaMetafactory для создания инстанции Consumer<String>.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Используешь в работе Lambda-выражения?

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

🟠Итерация по коллекциям
Использование лямбда-выражений с методом forEach позволяет компактно и удобно итерировать по элементам коллекций.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

🟠Фильтрация и преобразование коллекций
С использованием Stream API и лямбда-выражений можно легко фильтровать, сортировать и преобразовывать коллекции.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("A"))
    .collect(Collectors.toList());

filteredNames.forEach(System.out::println); // Вывод: Alice

🟠Сортировка коллекций
Лямбда-выражения упрощают сортировку коллекций с использованием метода sort.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.sort((name1, name2) -> name1.compareTo(name2));
names.forEach(System.out::println);

🟠Использование функциональных интерфейсов
Лямбда-выражения широко используются с функциональными интерфейсами, такими как Predicate, Function, Consumer и Supplier.

// Predicate
Predicate<String> startsWithA = s -> s.startsWith("A");
boolean result = startsWithA.test("Alice"); // true

// Function
Function<String, Integer> lengthFunction = s -> s.length();
int length = lengthFunction.apply("Hello"); // 5

// Consumer
Consumer<String> printConsumer = s -> System.out.println(s);
printConsumer.accept("Hello, World!"); // Вывод: Hello, World!

// Supplier
Supplier<String> stringSupplier = () -> "Hello, Supplier!";
String suppliedString = stringSupplier.get();
System.out.println(suppliedString); // Вывод: Hello, Supplier!

🟠Параллельные вычисления
Лямбда-выражения с использованием параллельных потоков позволяют легко выполнять параллельные вычисления.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream()
    .mapToInt(Integer::intValue)
    .sum();

System.out.println("Sum: " + sum); // Вывод: Sum: 15

🚩Пример использования в реальном проекте

Предположим, у нас есть список сотрудников, и мы хотим отфильтровать и отсортировать их по имени.

import java.util.*;
import java.util.stream.Collectors;

class Employee {
    private String name;
    private int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Employee{name='" + name + "', age=" + age + '}';
    }
}

public class LambdaExample {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", 30),
            new Employee("Bob", 25),
            new Employee("Charlie", 35),
            new Employee("David", 28)
        );

        // Фильтрация и сортировка сотрудников по имени
        List<Employee> filteredAndSorted = employees.stream()
            .filter(e -> e.getAge() > 27)
            .sorted(Comparator.comparing(Employee::getName))
            .collect(Collectors.toList());

        filteredAndSorted.forEach(System.out::println);
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём разница между final, finally, finalize?

final используется для обозначения констант и для запрета наследования или переопределения методов. finally — это блок, выполняющийся всегда в конце блока try-catch, независимо от исключений. finalize — это метод для очистки ресурсов перед удалением объекта сборщиком мусора.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 На базе чего работают Lambda выражения?

Лямбда-выражения в Java работают на основе нескольких ключевых концепций и механизмов, включая функциональные интерфейсы, инструкции invokedynamic, и использование java.lang.invoke.MethodHandle и java.lang.invoke.LambdaMetafactory.

🚩Основные компоненты

🟠Функциональные интерфейсы
Лямбда-выражения могут использоваться только в контексте функционального интерфейса. Функциональный интерфейс — это интерфейс, который имеет только один абстрактный метод. Примеры функциональных интерфейсов: Runnable, Callable, Comparator, и интерфейсы из пакета java.util.function (Function, Predicate, Consumer, Supplier).

🟠Инструкция `invokedynamic`
invokedynamic — это инструкция байт-кода, введенная в Java 7, которая позволяет динамически связывать вызовы методов во время выполнения. В случае лямбда-выражений, invokedynamic используется для создания инстанции функционального интерфейса.

🟠`java.lang.invoke.MethodHandle` и `java.lang.invoke.LambdaMetafactory`
MethodHandle — это легковесный, типобезопасный способ описания подлежащих вызову методов, конструкторов и полей. LambdaMetafactory — это утилита, используемая JVM для создания реализации функционального интерфейса на основе лямбда-выражения. При выполнении инструкции invokedynamic JVM вызывает LambdaMetafactory для создания экземпляра функционального интерфейса.

🚩Пример работы лямбда-выражения под капотом

1⃣Написание лямбда-выражения

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

2⃣Компиляция лямбда-выражения
Компилятор преобразует лямбда-выражение в байт-код, который использует инструкцию invokedynamic. Инструкция invokedynamic указывает на метод-обработчик (MethodHandle) для метода System.out.println(name).

3⃣Выполнение лямбда-выражения
При выполнении инструкции invokedynamic JVM вызывает LambdaMetafactory для создания инстанции функционального интерфейса Consumer<String>. LambdaMetafactory создает реализацию интерфейса Consumer<String> с методом accept, который вызывает System.out.println(name).

🚩Преобразование лямбда-выражения

// Лямбда-выражение
Consumer<String> consumer = name -> System.out.println(name);

// Компилируется в байт-код, который использует invokedynamic
Consumer<String> consumer = (Consumer<String>) LambdaMetafactory.metafactory(
    caller, 
    "accept", 
    MethodType.methodType(Consumer.class), 
    MethodType.methodType(void.class, Object.class), 
    MethodHandles.lookup().findVirtual(System.out.getClass(), "println", MethodType.methodType(void.class, String.class)), 
    MethodType.methodType(void.class, String.class)
).getTarget().invoke();

🚩Плюсы

➕Компактность
Лямбда-выражения позволяют писать более компактный и читаемый код.
➕Производительность
Использование invokedynamic и LambdaMetafactory позволяет JVM генерировать высокоэффективный байт-код для лямбда-выражений.
➕Гибкость
Лямбда-выражения могут использоваться в любых контекстах, где ожидается функциональный интерфейс.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Каким образом HashMap связан с Set?

HashMap и Set тесно связаны через реализацию, так как HashSet внутри использует HashMap для хранения элементов. HashSet управляет уникальностью элементов, полагаясь на ключи HashMap. Таким образом, каждый элемент Set является ключом в HashMap, что гарантирует уникальность.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Сколько функциональностей можно поместить в одно Lambda-выражение?

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

🚩Пример

🟠Использование `Consumer`
Consumer — это функциональный интерфейс, который принимает один аргумент и не возвращает результата.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Лямбда-выражение для Consumer
names.forEach(name -> System.out.println(name));

🟠Использование `Function`
Function — это функциональный интерфейс, который принимает один аргумент и возвращает результат.

Function<String, Integer> lengthFunction = str -> str.length();
int length = lengthFunction.apply("Hello");
System.out.println("Length: " + length); // Вывод: Length: 5

🟠Использование `Predicate`
Predicate — это функциональный интерфейс, который принимает один аргумент и возвращает логическое значение.

Predicate<String> startsWithA = str -> str.startsWith("A");
boolean result = startsWithA.test("Alice");
System.out.println("Starts with A: " + result); // Вывод: Starts with A: true

🚩Сложные лямбда-выражения

Хотя одно лямбда-выражение предназначено для реализации одной функциональности, вы можете включить в него более сложную логику, используя блоки кода {}.

Predicate<String> complexPredicate = str -> {
    if (str == null || str.isEmpty()) {
        return false;
    }
    return str.startsWith("A") && str.length() > 3;
};

boolean result = complexPredicate.test("Alice");
System.out.println("Complex Predicate: " + result); // Вывод: Complex Predicate: true

🚩Сочетание нескольких лямбда-выражений

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

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Alex");

// Фильтрация, преобразование и итерация
names.stream()
    .filter(name -> name.startsWith("A")) // Predicate
    .map(name -> name.toUpperCase()) // Function
    .forEach(name -> System.out.println(name)); // Consumer

🚩Вложенные лямбда-выражения

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

BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
Function<Integer, Function<Integer, Integer>> addPartial = a -> b -> add.apply(a, b);

Function<Integer, Integer> add5 = addPartial.apply(5);
int result = add5.apply(3); // 5 + 3 = 8
System.out.println("Result: " + result); // Вывод: Result: 8

Ставь 👍 и забирай 📚 Базу знаний

🤔 Char — символьный или числовой тип данных?

char в Java — это символьный тип данных, который используется для представления одиночных символов Unicode. При этом он хранится как 16-битное числовое значение, соответствующее коду символа в таблице Unicode. Это позволяет выполнять над символами арифметические операции, такие как инкремент или сравнение. Но основной его смысл — хранение символов.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Откуда берутся методы equals и hashcode?

Методы equals и hashCode являются методами класса java.lang.Object в Java. Все классы в Java, неявно или явно, наследуются от класса Object, поэтому они унаследуют эти методы.

🚩Класс `java.lang.Object`

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

🚩Метод `equals`

Метод equals используется для сравнения объектов на равенство. Метод equals должен следовать следующим правилам:
Симметричность: Для любых ненулевых значений x и y, x.equals(y) должно возвращать true, если и только если y.equals(x) возвращает true.
Транзитивность: Для любых ненулевых значений x, y и z, если x.equals(y) возвращает true и y.equals(z) возвращает true, то x.equals(z) должно возвращать true.
Согласованность: Для любых ненулевых значений x и y, повторные вызовы x.equals(y) должны возвращать одно и то же значение, пока объекты остаются неизменными.
Сравнение с null: Для любого ненулевого значения x, x.equals(null) должно возвращать false.

🚩Метод `hashCode`

Метод hashCode возвращает хеш-код объекта, который используется для повышения производительности в структурах данных, таких как HashMap, HashSet и Hashtable.
Подразумеваемый контракт: Метод hashCode должен следовать следующим правилам:
Согласованность: Если объект не изменяется, повторные вызовы метода hashCode должны возвращать одно и то же значение.
Согласованность с equals: Если два объекта равны согласно методу equals, их хеш-коды также должны быть равны.
Неравенство: Если два объекта не равны согласно методу equals, их хеш-коды не обязательно должны быть различными, но желательно минимизировать количество таких коллизий.

🚩Переопределение методов `equals` и `hashCode`

Чтобы обеспечить правильное поведение этих методов в пользовательских классах, их часто переопределяют.

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Alice", 25);

        System.out.println(person1.equals(person2)); // true
        System.out.println(person1.hashCode() == person2.hashCode()); // true
    }
}

🚩Генерация методов `equals` и `hashCode` в IDE

Современные IDE, такие как IntelliJ IDEA и Eclipse, могут автоматически генерировать методы equals и hashCode на основе полей класса. Это помогает избежать ошибок и обеспечить правильное соблюдение контрактов.

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем идея многопоточности?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему hashcode могут быть равны?

Хеш-коды могут быть равны для разных объектов из-за того, что они являются конечными представлениями данных, а количество возможных хеш-кодов ограничено. В Java метод hashCode возвращает значение типа int, что означает, что существует только \(2^{32}\) возможных значений хеш-кодов. Однако количество возможных объектов значительно больше, чем \(2^{32}\), что приводит к коллизиям хеш-кодов.

🚩Основные причины

🟠Ограниченный диапазон хеш-кодов
Хеш-коды представлены 32-битным целым числом, что дает \(2^{32}\) возможных значений. Это означает, что множество объектов должно быть отображено в это ограниченное пространство хеш-кодов, что приводит к коллизиям.

🟠Коллизии хеш-кодов
Коллизия возникает, когда два разных объекта имеют одинаковый хеш-код. Это неизбежно при использовании конечного диапазона хеш-кодов для представления множества объектов.

🚩Как работают коллизии

В Java структуры данных, такие как HashMap и HashSet, обрабатывают коллизии хеш-кодов, используя внутренние механизмы для разрешения коллизий. При коллизии хеш-кодов, когда два разных объекта имеют одинаковый хеш-код, они все равно могут быть правильно размещены и найдены в хеш-таблице.

public class Example {
    private int value;

    public Example(int value) {
        this.value = value;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Example example = (Example) obj;
        return value == example.value;
    }

    @Override
    public int hashCode() {
        return value % 10; // Искусственно создаем коллизии для демонстрации
    }

    public static void main(String[] args) {
        Example ex1 = new Example(1);
        Example ex2 = new Example(11);

        System.out.println(ex1.hashCode()); // 1
        System.out.println(ex2.hashCode()); // 1

        System.out.println(ex1.equals(ex2)); // false

        HashSet<Example> set = new HashSet<>();
        set.add(ex1);
        set.add(ex2);

        System.out.println(set.size()); // 2, так как объекты разные
    }
}

🚩Обработка коллизий

🟠Цепочки (Chaining)
Каждый элемент в хеш-таблице указывает на список (или другую структуру), содержащий все элементы с одинаковым хеш-кодом.
🟠Открытая адресация (Open Addressing)
В случае коллизии алгоритм ищет другую позицию в хеш-таблице для размещения элемента, используя определенную стратегию пробирования (linear probing, quadratic probing и т.д.).

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что знаешь про модели памяти в Java?

Модель памяти Java (Java Memory Model, JMM) определяет, как взаимодействуют потоки через память и как изменения, сделанные одним потоком, становятся видимыми для других потоков. Модель памяти Java является фундаментальной частью многопоточной среды в Java, обеспечивающей корректность и предсказуемость поведения многопоточных программ.

🚩Основные аспекты

🟠Взаимодействие потоков и памяти:

JMM определяет, как потоки взаимодействуют с переменными (данными), хранящимися в общей памяти. Каждая переменная в Java хранится в основной памяти (main memory), и потоки могут иметь локальные копии этих переменных в своих рабочих кешах.

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

🚩Гарантии JMM

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

🟠Видимость (Visibility)
Видимость означает, что изменения, сделанные одним потоком, становятся видимыми для других потоков. В JMM видимость изменений обеспечивается с помощью синхронизации.

🟠Произвольный порядок выполнения (Out-of-Order Execution)
JMM допускает оптимизации, такие как переупорядочивание инструкций, чтобы улучшить производительность, но гарантирует, что видимость и порядок выполнения будут сохраняться, как описано в спецификации.

public class VisibilityExample {
    private static boolean flag = false;
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread writer = new Thread(() -> {
            counter = 42;
            flag = true;
        });

        Thread reader = new Thread(() -> {
            while (!flag) {
                // Ждем пока флаг не станет true
            }
            System.out.println("Counter: " + counter);
        });

        writer.start();
        reader.start();

        writer.join();
        reader.join();
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Является ли коллекция HashMap потоко безопасной?

Нет, не является потоко безопасной. При одновременном доступе нескольких потоков возможны повреждения данных или ошибки. Для многопоточной работы используют ConcurrentHashMap или синхронизацию через Collections.synchronizedMap().

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Когда stream начинает свое выполнение?

В Java Streams API потоки данных (Stream) начинают своё выполнение только при вызове терминального операции. Это ключевая особенность, которая отличает ленивые (lazy) промежуточные операции от жадных (eager) терминальных операций.

🚩Промежуточные и терминальные операции

🟠Промежуточные операции (Intermediate Operations)
Промежуточные операции возвращают новый поток и не инициируют выполнение. Они являются ленивыми, то есть, они откладывают выполнение до тех пор, пока не будет вызвана терминальная операция. Примеры: filter, map, sorted, distinct, flatMap, и т.д. Промежуточные операции составляют цепочку, которая настраивает конвейер обработки данных.

Stream<String> stream = Stream.of("one", "two", "three")
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase);   

🟠Терминальные операции (Terminal Operations)
Терминальные операции запускают выполнение всего конвейера потоков. Они потребляют поток и возвращают либо результат, либо выполняют побочные действия. Примеры: forEach, collect, reduce, count, findFirst, findAny, allMatch, noneMatch, и т.д.

long count = stream.count(); // Запуск выполнения   

🚩Пример

Рассмотрим пример, где промежуточные операции filter и map не инициируют выполнение, а только настройку конвейера. Выполнение начинается только при вызове терминальной операции forEach.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // Настройка конвейера операций
        Stream<String> nameStream = names.stream()
            .filter(name -> {
                System.out.println("Filter: " + name);
                return name.length() > 3;
            })
            .map(name -> {
                System.out.println("Map: " + name);
                return name.toUpperCase();
            });

        System.out.println("Before terminal operation");

        // Терминальная операция, которая запускает выполнение
        nameStream.forEach(name -> System.out.println("Final result: " + name));

        System.out.println("After terminal operation");
    }
}

🚩Ожидаемый вывод

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

Before terminal operation
Filter: Alice
Map: Alice
Final result: ALICE
Filter: Bob
Filter: Charlie
Map: Charlie
Final result: CHARLIE
Filter: David
Map: David
Final result: DAVID
After terminal operation

Ставь 👍 и забирай 📚 Базу знаний

🤔 Массив — статическая структура данных или динамическая?

Является статической структурой данных, так как его размер задаётся при создании и не может изменяться. Однако содержимое массива можно изменять, а для работы с динамическими структурами лучше использовать коллекции, такие как ArrayList.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое модификатор default equals и hashcode?

Модификаторы доступа в Java определяют уровень доступа к классам, методам и переменным. Однако, если говорить о equals и hashCode в контексте модификаторов, то мы имеем в виду их реализацию по умолчанию, предоставляемую классом java.lang.Object.

🚩Реализация

🟠Метод `equals` по умолчанию
Метод equals в классе Object по умолчанию проверяет, являются ли два объекта одним и тем же экземпляром. Это проверка на ссылочное равенство.

public boolean equals(Object obj) {
    return (this == obj);
}

🟠Метод `hashCode` по умолчанию
Метод hashCode в классе Object по умолчанию возвращает уникальный целочисленный идентификатор для каждого объекта. Этот идентификатор обычно представляет собой адрес объекта в памяти.

public native int hashCode();

🚩Когда нужно переопределять

Переопределение методов equals и hashCode необходимо, когда вы хотите, чтобы два различных объекта были равны, если их состояния равны, а не если они являются одним и тем же объектом.

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public static void main(String[] args) {
        Person p1 = new Person("Alice", 25);
        Person p2 = new Person("Alice", 25);

        System.out.println(p1.equals(p2)); // true
        System.out.println(p1.hashCode() == p2.hashCode()); // true
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какую структуру данных реализует LinkedList?

Реализует связанную структуру данных — двусвязный список. Каждый узел содержит данные и ссылки на предыдущий и следующий элементы, что делает добавление и удаление эффективным, но доступ к элементам — медленным (линейный поиск).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое heap, stack?

В контексте Java, Heap (куча) и Stack (стек) являются областями памяти, используемыми JVM для управления памятью, необходимой для выполнения программы. Каждая из этих областей имеет свои характеристики и используется для разных целей.

🚩Heap (Куча)

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

🟠Особенности
Куча разделена на поколения: молодое поколение (Young Generation) и старое поколение (Old Generation).
Молодое поколение включает в себя области Eden Space и Survivor Spaces (S0 и S1).
Старое поколение хранит долгоживущие объекты.

🟠Управление памятью
Куча управляется сборщиком мусора (Garbage Collector), который автоматически освобождает память, занятую объектами, которые больше не используются.

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

public class Example {
    public static void main(String[] args) {
        Example obj = new Example(); // obj создается в куче
    }
}

🚩Stack (Стек)

Стек — это область памяти, используемая для управления вызовами методов и хранения локальных переменных, параметров методов и информации о возвратах.

🟠Особенности
Каждый поток имеет свой собственный стек.
Стек хранит кадры (frames) для каждого вызова метода. Каждый кадр содержит локальные переменные метода и информацию о вызовах.

🟠Управление памятью
Память в стеке автоматически управляется при вызове методов и выходе из них. Когда метод вызывается, создается новый кадр в стеке; когда метод завершает выполнение, его кадр удаляется из стека.

🟠Использование
Стек используется для хранения примитивных типов данных и ссылок на объекты, которые находятся в куче.
Локальные переменные методов и параметры методов хранятся в стеке.

public class Example {
    public static void main(String[] args) {
        int localVar = 10; // localVar хранится в стеке
        Example obj = new Example(); // Ссылка на obj хранится в стеке, а сам объект — в куче
        obj.method();
    }

    public void method() {
        int anotherVar = 20; // anotherVar хранится в стеке
    }
}

Ставь 👍 и забирай 📚 Базу знаний