Recursion vs Iteration: Что выбрать?🗳

Рекурсия и итерация — два способа решения задач. Какой выбрать?

📌 Факториал: Рекурсия vs Итерация

✔️ Рекурсия:

public static int factorialRecursive(int n) {
    return (n == 1) ? 1 : n * factorialRecursive(n - 1);
}

✔️ Итерация:

public static int factorialIterative(int n) {
    int result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

👍 Разбор:

✔️ Рекурсия удобна для разделяй и властвуй, но может вызвать StackOverflowError.
✔️ Итерация эффективнее по памяти, но иногда менее читаема.
✔️ В Java лучше избегать глубоких рекурсий из-за ограниченного стека.

💡 Запомни:

✔️ Рекурсия = удобство, но риск StackOverflowError.
✔️ Итерация = производительность и безопасность.

📍 Теги: #java #recursion #iteration #performance #bestpractices

➡️ Easy Java | #Мемы

👩‍💻 Java - Полный Курс по Java

В этом видеокурсе автор пошагово и простым языком ознакомит вас с важными концепциями языка Java.

Преподаватель на практике показывает — как, что и зачем делать, прямо в редакторе кода.

🔤 Ссылка на источник 🔤

➡ Easy Java |#Видео #Курсы

🟢 1. Ошибка: == vs equals() при сравнении строк

В Java строки (String) сравниваются не через ==, а с equals(), иначе возможны ошибки.

📌 Ошибка:

public class StringComparison {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = new String("hello");

        System.out.println(s1 == s2);      // ❌ false (сравнение ссылок)
        System.out.println(s1.equals(s2)); // ✅ true (сравнение значений)
    }
}

👍 Разбор:

✔️ == сравнивает ссылки на объекты в памяти, а не значения.
✔️ equals() сравнивает сами строки.


✔️ Правильный вариант:

if (s1.equals(s2)) {
    System.out.println("Строки равны ");
}

💡 Запомни:

✔️ Используй equals() для строк.
✔️ == работает только для пулла строк (String s1 = "hello"; String s2 = "hello";).

❓ А вы знали об этом?

📍 Теги: #java #string #equals #mistakes #bestpractices

Ошибка: ConcurrentModificationException при итерации по списку.

При изменении ArrayList во время итерации можно получить ConcurrentModificationException.

❌ Ошибка:

import java.util.*;

public class ConcurrentModExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(List.of(1, 2, 3, 4, 5));

        for (Integer num : numbers) {
            if (num % 2 == 0) {
                numbers.remove(num); // ❌ ConcurrentModificationException
            }
        }
    }
}

👍 Разбор:

✔️ ArrayList использует модификационный счётчик, который ломается при изменении коллекции во время итерации.
✔️ for-each использует Iterator, который не поддерживает удаление элементов во время итерации.

✔️ Правильный вариант 1: Использовать Iterator.remove()

Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
    if (iterator.next() % 2 == 0) {
        iterator.remove(); //  Работает корректно
    }
}

✔️ Правильный вариант 2: Использовать removeIf()

numbers.removeIf(n -> n % 2 == 0); //  Удаляет без исключений

💡 Запомни:

✔️ for-each нельзя использовать для удаления элементов.
✔️ Используй Iterator.remove() или removeIf().

❓ А вы знали об этом?

📍 Теги: #java #concurrentmodification #collections #mistakes #bestpractices

Ошибка: Автоупаковка (Autoboxing) и производительность.

В Java Integer, Double и другие обёртки примитивов (wrapper classes) используют автоупаковку (autoboxing), которая может снижать производительность.

❌ Ошибка:

public class AutoboxingExample {
    public static void main(String[] args) {
        Integer sum = 0;  // ❌ Используем обёртку вместо int

        for (int i = 0; i < 1_000_000; i++) {
            sum += i; // ❌ Автоупаковка на каждой итерации (int → Integer)
        }

        System.out.println(sum);
    }
}

Проблема:

🚨 На каждой итерации создаётся новый объект Integer, что замедляет программу!

✔️ Правильный вариант:

int sum = 0; //  Используем int
for (int i = 0; i < 1_000_000; i++) {
    sum += i; 
}
System.out.println(sum);

👍 Разбор:

✔️ Автоупаковка создаёт новые объекты, что увеличивает потребление памяти и замедляет код.
✔️ Используй примитивные типы (int, double) там, где не нужна обёртка.

💡 Запомни:

✔️ int быстрее, чем Integer.
✔️ Избегай ненужной автоупаковки в циклах.

❓ А вы знали об этом?

📍 Теги: #java #autoboxing #performance #mistakes #bestpractices

➡️ Easy Java | #Мемы

👨‍💻 Задача: Найти два числа в массиве, сумма которых равна целевому значению

📌 Условие:

Дан массив целых чисел и целевое число target. Нужно найти два числа, сумма которых равна target, и вернуть их индексы.
Гарантируется, что решение всегда существует.

✔️ Примеры:

Input: nums = [2, 7, 11, 15], target = 9  
Output: [0, 1] // (2 + 7 = 9)

Input: nums = [3, 2, 4], target = 6  
Output: [1, 2] // (2 + 4 = 6)

📌 Решение:

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

public class TwoSum {
    public static int[] findTwoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];

            if (map.containsKey(complement)) {
                return new int[]{map.get(complement), i};
            }

            map.put(nums[i], i);
        }

        throw new IllegalArgumentException("Решение не найдено");
    }

    public static void main(String[] args) {
        int[] nums = {2, 7, 11, 15};
        int target = 9;

        int[] result = findTwoSum(nums, target);
        System.out.println("[" + result[0] + ", " + result[1] + "]");
    }
}

👍 Разбор:

✔️ Используем HashMap для хранения чисел и их индексов.
✔️ Одним проходом по массиву за O(n) проверяем, есть ли нужное число.
✔️ Если target - nums[i] уже есть в map, возвращаем пару индексов.

💡 Запомни:

✔️ HashMap даёт поиск за O(1), что делает алгоритм эффективным.
✔️ Использование map.containsKey() позволяет избежать вложенных циклов.

❓ А вы знали об этом?

📍 Теги: #java #tasks #algorithms #hashmap

❌ Ошибка: Сравнение строк через == вместо .equals()

🚨 Одна из самых частых ошибок в Java — сравнение строк через ==.

Ошибка ⚠️ :

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = new String("Hello");

        System.out.println(str1 == str2); // ✅ true (оба строки из пула строк)
        System.out.println(str1 == str3); // ❌ false (разные объекты в памяти)
    }
}

Что произошло❓

🚨 == сравнивает ссылки в памяти, а не содержимое строк!

✔️ Правильный вариант:

System.out.println(str1.equals(str2)); //  true
System.out.println(str1.equals(str3)); //  true

👍 Разбор:

✔️ == проверяет ссылки, а не содержимое строк.
✔️ Используй .equals() для сравнения значений строк.
✔️ intern() можно использовать для приведения строк в пул строк.

💡 Запомни:

✔️ == сравнивает ссылки.
✔️ .equals() сравнивает содержимое.
✔️ intern() делает строки из new String() частью пула строк.

❓ А вы знали об этом?

📍 Теги: #java #mistakes #bestpractices #string

➡️ Easy Java | #Мемы

🟢 Как правильно использовать Optional в Java

В Java Optional помогает избежать NullPointerException. Давай разберём, как его использовать!

📌 Пример:

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optionalValue = getValue();

        // ✅ Правильное использование Optional
        String result = optionalValue.orElse("Значение по умолчанию");
        System.out.println(result);
    }

    public static Optional<String> getValue() {
        return Optional.ofNullable(null); // Имитация возможного null
    }
}

👍 Разбор:

✔️ Optional.ofNullable(value) – создаёт Optional, который может быть пустым.
✔️ .orElse("Значение по умолчанию") – возвращает значение или подставляет дефолтное.
✔️ Избегаем NullPointerException!

💡 Запомни:

✔️ Используй Optional для работы с возможными null.
✔️ .orElse(), .orElseGet(), .ifPresent() – удобные методы для обработки значений.

❓ А вы знали об этом?

🟢 Почему нельзя изменять список внутри for-each?

В Java изменение списка (List) внутри for-each приведёт к ConcurrentModificationException. Давай разберёмся, как правильно удалять элементы!

📌 Ошибка при удалении в for-each:

import java.util.*;

public class ForEachModification {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

        for (Integer num : numbers) {
            if (num % 2 == 0) {
                numbers.remove(num); // ❌ ConcurrentModificationException
            }
        }

        System.out.println(numbers);
    }
}

👍 Как правильно удалять элементы?

✔️ Используем Iterator.remove():

Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
    if (iterator.next() % 2 == 0) {
        iterator.remove(); //  Правильный способ удаления
    }
}

✔️ Используем removeIf() (Java 8+):

numbers.removeIf(n -> n % 2 == 0); //  Удаление без исключений

👍 Разбор:

✔️ for-each использует Iterator под капотом, но не позволяет безопасно изменять коллекцию.
✔️ remove() внутри for-each изменяет список, вызывая ConcurrentModificationException.
✔️ Итератор обнаруживает изменения структуры и выбрасывает исключение.

💡 Запомни:

✔️ Нельзя изменять List внутри for-each.
✔️ Используй Iterator.remove() или removeIf().
✔️ ConcurrentModificationException возникает при изменении коллекции во время итерации.

❓ А вы знали об этом?

➡️ Easy Java | #Мемы

☕️ Почему нет достойных форматтеров кода для Java?

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

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

⛓ Читать статью

➡️ Easy Java | #статья

Почему нельзя изменять список внутри Java foreach? 🤔

Привет, программисты! Сегодня поговорим о популярной конструкции в Java — foreach. Это удобный способ перебора элементов коллекции или массива. Однако есть одна важная особенность, о которой нужно знать: нельзя изменять список (коллекцию) внутри цикла foreach. Разберёмся, почему так происходит и как это может повлиять на ваш код.

---

### Что такое foreach?

В Java foreach — это упрощённый синтаксис для перебора элементов коллекции или массива. Выглядит он так:

List<String> list = Arrays.asList("Java", "Kotlin", "Python");

for (String item : list) {
    System.out.println(item);
}

Здесь item — это текущий элемент списка, который обрабатывается на каждой итерации. Просто и элегантно!

---

### Почему нельзя изменять список внутри foreach?

Если вы попробуете добавить, удалить или изменить структуру списка внутри цикла foreach, вы получите ошибку ConcurrentModificationException. Например:

List<String> list = new ArrayList<>(Arrays.asList("Java", "Kotlin", "Python"));

for (String item : list) {
    if (item.equals("Kotlin")) {
        list.remove(item); // БАБАХ! ConcurrentModificationException
    }
}

#### Почему так происходит?

1. Итератор под капотом
На самом деле, foreach — это просто "синтаксический сахар" над итератором. Когда вы используете foreach, Java создаёт объект Iterator для перебора элементов. Этот итератор отслеживает состояние коллекции.

2. Проверка на модификацию
Итератор проверяет, была ли коллекция изменена во время итерации. Если вы пытаетесь изменить список напрямую (например, вызывая add или remove), итератор обнаруживает это и выбрасывает исключение ConcurrentModificationException.

3. Целостность данных
Такое поведение защищает вас от неопределённого состояния коллекции. Представьте, что вы удаляете элемент из списка, а итератор продолжает работать со старой версией коллекции. Это может привести к ошибкам и непредсказуемому поведению.

---

### Как правильно изменять список?

Если вам нужно изменить список во время перебора, используйте явный итератор и его методы:

List<String> list = new ArrayList<>(Arrays.asList("Java", "Kotlin", "Python"));

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    if (item.equals("Kotlin")) {
        iterator.remove(); // Безопасное удаление через итератор
    }
}

Здесь метод iterator.remove() безопасно удаляет элемент из списка без нарушения целостности итерации.

---

### Альтернативные подходы

1. Создание нового списка
Если вам нужно фильтровать элементы, создайте новый список и добавьте в него только нужные элементы:

   List<String> filteredList = new ArrayList<>();
   for (String item : list) {
       if (!item.equals("Kotlin")) {
           filteredList.add(item);
       }
   }
   

2. Использование Stream API
В Java 8+ можно использовать Stream API для фильтрации:

   List<String> filteredList = list.stream()
                                   .filter(item -> !item.equals("Kotlin"))
                                   .collect(Collectors.toList());
   

---

### Итог

- foreach — это удобный инструмент для перебора элементов, но он не позволяет изменять коллекцию напрямую.
- Причина — использование итератора под капотом, который следит за целостностью коллекции.
- Для безопасного изменения списка используйте явный итератор или альтернативные подходы (например, Stream API).

Теперь вы знаете, почему нельзя изменять список внутри foreach, и сможете избежать ошибок в своём коде! ✨

---

🔥 А вы сталкивались с ConcurrentModificationException? Как решали эту проблему? Делитесь в комментариях!