📖 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 | #Теория

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

def counter_decorator(func):
    count = 0
    def wrapper(*args, **kwargs):
        nonlocal count
        count += 1
        result = func(*args, **kwargs)
        print(f"Call {count}: {result}")
        return result
    return wrapper

@counter_decorator
def multiply(a, b):
    return a * b

multiply(2, 3)
multiply(4, 5)
multiply(6, 7)

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

📖 Сборник из 350 вопросов с ответами на собеседование Java Junior

В сборнике вопросы от самых базовых, до самых продвинутых среди «джуновских» вопросов. Сразу можно посмотреть ответ, что очень удобно.

⛓ Ссылка на сборник

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

➡️ Easy Java | #Мемы

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

BufferedReader.lines() — это метод, который возвращает Stream<String> строк, прочитанных из BufferedReader. Каждый элемент потока — это одна строка из файла или другого источника.

⚡️ Пример:

import java.io.*;
import java.nio.file.*;
import java.util.stream.*;

public class BufferedReaderLinesExample {
    public static void main(String[] args) {
        String filePath = "example.txt";
        
        // Создаем тестовый файл
        createTestFile(filePath);
        
        // Чтение файла с использованием lines()
        try (BufferedReader reader = Files.newBufferedReader(Paths.get(filePath))) {
            
            // Простое чтение всех строк
            System.out.println("Все строки файла:");
            reader.lines()
                  .forEach(System.out::println);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // Сложная обработка с Stream API
        try (BufferedReader reader = Files.newBufferedReader(Paths.get(filePath))) {
            
            System.out.println("\nАнализ файла:");
            
            long lineCount = reader.lines().count();
            System.out.println("Всего строк: " + lineCount);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // Фильтрация и преобразование
        try (BufferedReader reader = Files.newBufferedReader(Paths.get(filePath))) {
            
            System.out.println("\nСтроки содержащие 'Java':");
            reader.lines()
                  .filter(line -> line.contains("Java"))
                  .map(String::toUpperCase)
                  .forEach(System.out::println);
                  
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // Параллельная обработка большого файла
        try (BufferedReader reader = Files.newBufferedReader(Paths.get(filePath))) {
            
            long wordCount = reader.lines()
                .parallel()  // Включаем параллельную обработку
                .flatMap(line -> Arrays.stream(line.split("\\s+")))
                .filter(word -> !word.isEmpty())
                .count();
                
            System.out.println("\nВсего слов в файле: " + wordCount);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private static void createTestFile(String path) {
        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(path))) {
            writer.write("Java - популярный язык программирования\n");
            writer.write("Stream API появился в Java 8\n");
            writer.write("BufferedReader предоставляет удобные методы\n");
            writer.write("lines() возвращает Stream строк\n");
            writer.write("Это полезно для обработки больших файлов\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

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

❓ Вопрос с собеса

Зачем в Java используется ключевое слово volatile?

Пример🔽

public class Main {
    private static volatile boolean running = true;

    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            while (running) {
                // бесконечный цикл, пока running == true
            }
            System.out.println("Поток завершён");
        });

        worker.start();
        Thread.sleep(1000);
        running = false;
    }
}

Ответ🔽

volatile говорит JVM, что переменная может изменяться в других потоках, и запрещает кэшировать её значение. Без volatile поток может "застрять", не заметив изменения переменной.

📌 volatile не делает операции атомарными, но гарантирует видимость изменений между потоками. Используется для флагов, сигналов остановки и простейшей синхронизации

➡️ Easy Java | #Собес

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

import java.util.HashSet;
import java.util.Set;

record Point(int x, int y) {
    // Переопределяем equals, но не hashCode
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Point p)) return false;
        return this.x == p.x && this.y == p.y;
    }
}

public class Main {
    public static void main(String[] args) {
        Set<Point> set = new HashSet<>();
        
        Point p1 = new Point(1, 2);
        Point p2 = new Point(1, 2);
        Point p3 = new Point(3, 4);
        
        set.add(p1);
        set.add(p2);
        set.add(p3);
        
        System.out.println(set.size());
        System.out.println(p1.equals(p2));
        System.out.println(set.contains(new Point(1, 2)));
    }
}

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

Библиотека для автоматического модульного тестирования

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

Подходит для Java 17 или Kotlin 2.1.

⛓ Ознакомиться с библиотекой

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

Точно ли нейронки эволюционируют так быстро?

➡️ Easy Java | #Мем

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

Thread.sleep() — это статический метод класса java.lang.Thread, который приостанавливает выполнение текущего потока на указанное количество миллисекунд или наносекунд.

```java
public class ThreadSleepExample {
    
    public static void main(String[] args) {
        System.out.println("Демонстрация Thread.sleep()");
        
        // Простая задержка
        System.out.println("Начало работы");
        try {
            Thread.sleep(2000); // Пауза 2 секунды
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("Поток был прерван");
        }
        System.out.println("Прошло 2 секунды");
        
        // Создание анимации загрузки
        System.out.print("Загрузка");
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(500); // Полсекунды между точками
                System.out.print(".");
            } catch (InterruptedException e) {
                break;
            }
        }
        System.out.println(" Готово!");
        
        // Имитация таймера
        for (int seconds = 3; seconds > 0; seconds--) {
            System.out.println("Осталось: " + seconds + " сек");
            try {
                Thread.sleep(1000); // Пауза 1 секунда
            } catch (InterruptedException e) {
                System.out.println("Таймер прерван");
                break;
            }
        }
        System.out.println("Время вышло!");
        
        // Пример с перехватом прерывания
        Thread countingThread = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                System.out.println("Считаем: " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Поток прервали на счете " + i);
                    return; // Выходим из метода run()
                }
            }
        });
        
        countingThread.start();
        
        // Даем потоку посчитать до 3, потом прерываем
        try {
            Thread.sleep(3500);
            countingThread.interrupt(); // Прерываем поток
        } catch (InterruptedException e) {
            // Игнорируем
        }
    }
}
```

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

· Выбрасывает InterruptedException — checked exception
· Точность задержки зависит от операционной системы
· Приостанавливает только текущий поток
· После пробуждения поток переходит в состояние Runnable

Для чего особенно полезен:

· Создание задержек в UI анимациях
· Имитация длительных операций при тестировании
· Управление частотой выполнения в циклах
· Простая синхронизация потоков во времени
· Реализация тайм-аутов и ожидания
· Демонстрация многопоточности в учебных примерах

Важные замечания:
     } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("Поток был прерван");
        }
        System.out.println("Прошло 2 секунды");
        
        // Создание анимации загрузки
        System.out.print("Загрузка");
        for (int i = 0; i < 5; i++) {
            try {
            

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

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

// Предположим, что этот код находится в файле src/com/example/Main.java
package com.example;

import java.net.URL;
import java.net.URLClassLoader;

class Secret {
    static String message = "Top Secret";
}

public class Main {
    public static void main(String[] args) throws Exception {
        // Создаем загрузчик, который видит тот же класс, но в другом пакете
        URLClassLoader loader = new URLClassLoader(
            new URL[]{new URL("file:./classes/")},
            ClassLoader.getPlatformClassLoader() // Не делегирует системному загрузчику
        );
        
        Class<?> secretClass = loader.loadClass("com.example.Secret");
        String value = (String) secretClass.getField("message").get(null);
        
        System.out.println("Value: " + value);
        
        // Проверяем равенство классов
        System.out.println("Same class: " + (Secret.class == secretClass));
        
        // Проверяем instanceof
        Secret s = new Secret();
        System.out.println("Instance: " + secretClass.isInstance(s));
    }
}

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

👩‍💻 Шаблоны проектирования, реализованные в Java

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

⛓ Переход к репозиторию

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

Редко, когда сразу пишут всю правду о вакансии😁

➡️ Easy Java | #Мем

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

Collections.unmodifiableList() — это статический метод, который создает неизменяемую (read-only) обертку над существующим списком. Любая попытка изменить такой список приводит к выбросу UnsupportedOperationException.

⚡️ Пример:

import java.util.*;

public class UnmodifiableListExample {
    public static void main(String[] args) {
        // Создаем изменяемый список
        List<String> mutableList = new ArrayList<>();
        mutableList.add("Java");
        mutableList.add("Python");
        mutableList.add("C++");
        
        // Создаем неизменяемую обертку
        List<String> immutableList = Collections.unmodifiableList(mutableList);
        
        System.out.println("Исходный список: " + mutableList);
        System.out.println("Неизменяемая обертка: " + immutableList);
        
        // Попытка изменить неизменяемый список
        try {
            immutableList.add("JavaScript"); // Бросит исключение
        } catch (UnsupportedOperationException e) {
            System.out.println("Ошибка: нельзя добавить элемент в неизменяемый список");
        }
        
        try {
            immutableList.remove(0); // Бросит исключение
        } catch (UnsupportedOperationException e) {
            System.out.println("Ошибка: нельзя удалить элемент из неизменяемого списка");
        }
        
        // Важно: изменения в оригинальном списке отражаются в обертке!
        mutableList.add("JavaScript");
        System.out.println("После изменения оригинала:");
        System.out.println("Оригинал: " + mutableList);
        System.out.println("Обертка: " + immutableList); // JavaScript появился и здесь
        
        // Правильный способ - полная копия
        List<String> safeImmutable = Collections.unmodifiableList(
            new ArrayList<>(mutableList) // Создаем копию
        );
        
        // Использование в API
        DataService service = new DataService();
        List<String> data = service.getReadOnlyData();
        
        try {
            data.add("Новый элемент"); // Ошибка - список только для чтения
        } catch (UnsupportedOperationException e) {
            System.out.println("API вернуло защищенные данные");
        }
    }
    
    static class DataService {
        private List<String> internalData = Arrays.asList("A", "B", "C");
        
        public List<String> getReadOnlyData() {
            // Возвращаем неизменяемую обертку для защиты данных
            return Collections.unmodifiableList(internalData);
        }
    }
}

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

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

❓ Вопрос с собеса

Чем ReentrantLock отличается от synchronized в Java?

Пример🔽

import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final ReentrantLock lock = new ReentrantLock();
    private static int counter = 0;

    public static void main(String[] args) {
        Runnable task = () -> {
            lock.lock();
            try {
                counter++;
            } finally {
                lock.unlock();
            }
        };

        new Thread(task).start();
        new Thread(task).start();
    }
}

Ответ🔽

ReentrantLock — это класс из java.util.concurrent.locks, который предоставляет больше возможностей, чем synchronized:

— Можно пытаться захватить блокировку с таймаутом (tryLock)
— Можно использовать блокировку с несколькими условиями (Condition)
— Можно вручную управлять моментом захвата и освобождения

📌 В отличие от synchronized, ReentrantLock требует явного вызова lock() и unlock(), что даёт гибкость, но требует дисциплины.

➡️ Easy Java | #Собес