👩‍💻 Что такое Arrays.parallelSort() и зачем он нужен?

Arrays.parallelSort() — это метод из класса java.util.Arrays, который сортирует массивы с использованием параллельных алгоритмов, задействуя несколько ядер процессора для ускорения сортировки больших объемов данных.

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

– Значительно ускоряет сортировку больших массивов
– Автоматически использует ForkJoinPool для параллельной обработки
– Минимальные изменения кода по сравнению с обычной сортировкой

Пример кода:

import java.util.*;
import java.util.concurrent.TimeUnit;

public class ParallelSortExample {
    public static void main(String[] args) {
        // Создаем большой массив случайных чисел
        int size = 10_000_000;
        int[] numbers = new int[size];
        Random random = new Random();
        
        for (int i = 0; i < size; i++) {
            numbers[i] = random.nextInt(1_000_000);
        }
        
        // Копируем массив для сравнения сортировок
        int[] numbersCopy = numbers.clone();
        
        System.out.println("Начата параллельная сортировка...");
        long startTime = System.nanoTime();
        Arrays.parallelSort(numbers);
        long parallelTime = System.nanoTime() - startTime;
        System.out.println("Параллельная сортировка заняла: " + 
                          TimeUnit.NANOSECONDS.toMillis(parallelTime) + " мс");
        
        System.out.println("Начата обычная сортировка...");
        startTime = System.nanoTime();
        Arrays.sort(numbersCopy);
        long sequentialTime = System.nanoTime() - startTime;
        System.out.println("Обычная сортировка заняла: " + 
                          TimeUnit.NANOSECONDS.toMillis(sequentialTime) + " мс");
        
        // Сортировка объектов
        String[] cities = {"Москва", "Санкт-Петербург", "Казань", 
                          "Екатеринбург", "Новосибирск", "Владивосток"};
        
        Arrays.parallelSort(cities);
        System.out.println("\nОтсортированные города: " + Arrays.toString(cities));
        
        // Сортировка с компаратором
        Arrays.parallelSort(cities, Comparator.comparingInt(String::length));
        System.out.println("Города по длине названия: " + Arrays.toString(cities));
    }
}

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

– Работает с массивами примитивов и объектами
– Автоматически выбирает алгоритм сортировки в зависимости от размера массива
– Для небольших массивов может использовать последовательную сортировку
– Поддерживает пользовательские компараторы для объектов

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

➡️ Easy Java | #Теория

👩‍💻 Викторина: что выведет код?

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            Singleton s1 = Singleton.getInstance();
            System.out.print("T1 ");
        });
        
        Thread t2 = new Thread(() -> {
            Singleton s2 = Singleton.getInstance();
            System.out.print("T2 ");
        });
        
        t1.start();
        t2.start();
        
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.print("Done");
    }
}

➡️ Easy Java | #Викторина

👩‍💻 Что такое DelayQueue в Java и зачем она нужна?

DelayQueue — это потокобезопасная очередь из java.util.concurrent, где элементы становятся доступными только после истечения заданного времени задержки. Элементы должны реализовывать интерфейс Delayed.

Она удобна для отложенной обработки задач — таймеров, кэшей с TTL, планировщиков.

• Элементы выдаются только после задержки
• Работает в многопоточном режиме
• Идеальна для задач с таймаутами

⚡️ Пример:

import java.util.concurrent.*;

class Task implements Delayed {
    long start = System.currentTimeMillis() + 1000;
    public long getDelay(TimeUnit u) { return u.convert(start - System.currentTimeMillis(), TimeUnit.MILLISECONDS); }
    public int compareTo(Delayed o) { return Long.compare(getDelay(TimeUnit.MILLISECONDS), o.getDelay(TimeUnit.MILLISECONDS)); }
    public String toString() { return "Задача выполнена"; }
}

public class Main {
    public static void main(String[] args) throws Exception {
        DelayQueue<Task> q = new DelayQueue<>();
        q.put(new Task());
        System.out.println(q.take()); // ждём 1 сек
    }
}

👀 DelayQueue особенно полезна для отложенных задач, TTL-кэшей и планировщиков.

➡️ Easy Java | #Теория

Самые хитрые и частые вопросы на собеседованиях

В статье рассказано про 10 самых «каверзных» вопросах на собеседованих, где достаточно часто допускают ошибки. Есть и те, что больше похожи на головоломки или касаются нюансов, которые прочувствовать без практики очень тяжело.

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

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

👩‍💻 Викторина: что выведет код?

public class Main {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();
    
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                try { Thread.sleep(100); } catch (Exception e) {}
                synchronized (lock2) {
                    System.out.println("Thread 1");
                }
            }
        });
        
        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                try { Thread.sleep(100); } catch (Exception e) {}
                synchronized (lock1) {
                    System.out.println("Thread 2");
                }
            }
        });
        
        t1.start();
        t2.start();
        
        try {
            t1.join(500);
            t2.join(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Main finished");
    }
}

➡️ Easy Java | #Викторина

👩‍💻 Что такое Collectors.partitioningBy() и зачем он нужен?

Collectors.partitioningBy() — это коллектор из Java Stream API, который разделяет элементы потока на две группы (true/false) на основе заданного предиката, возвращая Map<Boolean, List<T>>.

⚡️ Пример:

import java.util.*;
import java.util.stream.*;
import java.util.function.Predicate;

public class PartitioningByExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Разделение чисел на четные и нечетные
        Map<Boolean, List<Integer>> partitioned = numbers.stream()
            .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        
        System.out.println("Четные: " + partitioned.get(true));    // [2, 4, 6, 8, 10]
        System.out.println("Нечетные: " + partitioned.get(false)); // [1, 3, 5, 7, 9]
        
        // Строки по длине
        List<String> words = Arrays.asList("яблоко", "груша", "слива", "апельсин", "лимон");
        
        Map<Boolean, List<String>> byLength = words.stream()
            .collect(Collectors.partitioningBy(word -> word.length() > 5));
        
        System.out.println("\nКороткие слова (≤5 букв): " + byLength.get(false));
        System.out.println("Длинные слова (>5 букв): " + byLength.get(true));
        
        // С дополнительным коллектором - подсчет количества
        Map<Boolean, Long> countPartition = numbers.stream()
            .collect(Collectors.partitioningBy(
                n -> n > 5,
                Collectors.counting()
            ));
        
        System.out.println("\nЧисел ≤5: " + countPartition.get(false));
        System.out.println("Чисел >5: " + countPartition.get(true));
    }
}

👀 Особенно полезен для разделения данных на прошедшие/не прошедшие валидацию, категоризации на успешные/ошибочные операции, статистического анализа.

➡️ Easy Java | #Теория

Доступ к ChatGPT за 5 минут без VPN с помощью Cloudflare

Короткая, но годная статья по реализации программы, которая позволяет запускать ChatGPT без VPN. Статья вышла буквально 2 дня назад, потому еще долго будет сохранять свою актуальность, юзайте!

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

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

Хороший айтишник ≠ хороший руководитель

И это причина, почему большинство застревают в своем развитии.

📊 Управление — это отдельный навык.

В канале Апазиди АйТи показывают, как его развить в реальном IT.

▪️управленческие ошибки, которые тихо ломают карьеру

▪️почему созвоны — признак слабой системы

▪️как строить команды без постоянного контроля

Читай тут: 👉 https://t.me/+Jcx__bY56BwwN2Uy

📇 Гарантированное получение данных через REST API: подходы и библиотеки для Java

В данной статье автор разобрал основные подходы к работе с REST API в Java и поделился популярными библиотеками для реализации retry-механизмов.

Каждый из подходов имеет свои преимущества и недостатки, а выбор подходящего решения зависит от конкретных требований проекта.

🔤 Читать статью 🔤

➡️ Easy Java | #Статьи #API

➡️ Easy Java | #Мемы

👩‍💻 Что такое Math.multiplyExact() и зачем он нужен?

Math.multiplyExact() — это метод из класса java.lang.Math, который выполняет умножение двух чисел с проверкой на переполнение. При переполнении выбрасывается исключение ArithmeticException.

⚡️ Пример:

public class MultiplyExactExample {
    public static void main(String[] args) {
        // Безопасное умножение int
        int a = 1000000;
        int b = 2000;
        
        try {
            int result1 = Math.multiplyExact(a, b);
            System.out.println(a + " * " + b + " = " + result1);
        } catch (ArithmeticException e) {
            System.out.println("Переполнение int: " + e.getMessage());
        }
        
        // Переполнение на примере
        int maxInt = Integer.MAX_VALUE;
        
        try {
            int dangerous = Math.multiplyExact(maxInt, 2);
        } catch (ArithmeticException e) {
            System.out.println("Ожидаемое переполнение: " + maxInt + " * 2");
        }
        
        // Работа с long
        long big1 = 10_000_000_000L;
        long big2 = 5_000L;
        
        try {
            long result2 = Math.multiplyExact(big1, big2);
            System.out.println(big1 + " * " + big2 + " = " + result2);
        } catch (ArithmeticException e) {
            System.out.println("Переполнение long: " + e.getMessage());
        }
        
        // Практический пример: вычисление факториала с проверкой
        System.out.println("\nВычисление факториала с проверкой переполнения:");
        for (int i = 1; i <= 20; i++) {
            try {
                long factorial = computeFactorial(i);
                System.out.println(i + "! = " + factorial);
            } catch (ArithmeticException e) {
                System.out.println(i + "! - переполнение!");
                break;
            }
        }
    }
    
    private static long computeFactorial(int n) {
        long result = 1;
        for (int i = 2; i <= n; i++) {
            result = Math.multiplyExact(result, i);
        }
        return result;
    }
}

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

➡️ Easy Java | #Теория

👩‍💻 Викторина: что выведет код?

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyAnnotation {
    String value() default "";
}

class Processor {
    @MyAnnotation("first")
    public void method1() {}
    
    @MyAnnotation("second")
    private void method2() {}
    
    @MyAnnotation("third")
    protected void method3() {}
    
    public void method4() {}
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Processor.class;
        int count = 0;
        
        for (Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(MyAnnotation.class)) {
                count++;
                // Делаем приватный метод доступным
                method.setAccessible(true);
            }
        }
        
        System.out.println("Annotated methods: " + count);
    }
}

➡️ Easy Java | #Викторина

📖 Jqwik: обзор тестирования на основе свойств в UI и API

В статье объясняют, как вместо проверки конкретных данных тестировать их свойства, зачем это нужно, как помогает Jqwik для Java и где пригодится на практике.

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

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

👩‍💻 TutorialsPoint Java for Beginners — курс по Java для начинающих

TutorialsPoint — это онлайн-ресурс, который предоставляет широкий спектр учебных материалов и учебных пособий, включая учебные пособия по различным языкам программирования, включая Java.

👀 Что изучается:

— Структуры данных: Обучение включает в себя работу с массивами, списками и другими структурами данных.
— Объектно-ориентированное программирование (ООП): Вы изучите концепции ООП, такие как классы, объекты, наследование, полиморфизм и инкапсуляция.
— Потоки ввода/вывода: Вы научитесь более глубоко разбираться с потоками для ввода и вывода данных.
— Java API: Рассмотрение стандартной библиотеки классов Java.

⛓ Ссылка на ресурс

➡️ Easy Java | #Ресурсы

Разве не так?

➡️ Easy Java | #Мемы

👩‍💻 Что такое Optional.orElseThrow() и зачем он нужен?

Optional.orElseThrow() — это метод класса Optional<T>, который возвращает значение, если оно присутствует, или выбрасывает исключение, если значение отсутствует. Добавлен в Java 10 как альтернатива get() с явным указанием исключения.

⚡️ Пример:

import java.util.*;
import java.util.function.Supplier;

public class OrElseThrowExample {
    
    public static void main(String[] args) {
        // Пример с пользователями
        Optional<User> user = findUserById(123);
        
        try {
            // Получение значения с дефолтным исключением
            User foundUser = user.orElseThrow();
            System.out.println("Найден пользователь: " + foundUser.name());
        } catch (NoSuchElementException e) {
            System.out.println("Пользователь не найден (дефолтное исключение)");
        }
        
        // С кастомным исключением
        Optional<User> emptyUser = findUserById(999);
        
        try {
            User user2 = emptyUser.orElseThrow(
                () -> new UserNotFoundException("Пользователь с ID 999 не существует")
            );
        } catch (UserNotFoundException e) {
            System.out.println("Поймано кастомное исключение: " + e.getMessage());
        }
        
        // Практический пример: валидация конфигурации
        Config config = loadConfig()
            .orElseThrow(() -> new IllegalStateException("Конфигурация не загружена"));
        
        System.out.println("Конфигурация загружена: " + config);
        
        // Цепочка вызовов с обработкой ошибок
        String result = findUserById(123)
            .map(User::email)
            .orElseThrow(() -> new RuntimeException("Email не найден"));
            
        System.out.println("Email пользователя: " + result);
    }
    
    static Optional<User> findUserById(int id) {
        // Имитация поиска в базе данных
        if (id == 123) {
            return Optional.of(new User(123, "Иван Иванов", "ivan@example.com"));
        }
        return Optional.empty();
    }
    
    static Optional<Config> loadConfig() {
        // Имитация загрузки конфигурации
        return Optional.of(new Config("production"));
    }
    
    record User(int id, String name, String email) {}
    record Config(String environment) {}
    
    static class UserNotFoundException extends Exception {
        public UserNotFoundException(String message) {
            super(message);
        }
    }
}

Особенно полезен при валидации прааметров, обработки отсутствующих значений в цепочках вызовов, замене проверов if, преобразовании optional в исключения в контроллерах/сервисах.

➡️ Easy Java | #Теория