class MathUtils {
    int sum(int a, int b) {
        return a + b;
    }
    
    double sum(double a, double b) { // Перегруженный метод
        return a + b;
    }
}

class Animal {
    void sound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() { // Переопределение метода
        System.out.println("Bark");
    }
}

import java.util.ArrayList;

public class arrayVsArrayList {

  public static void main(String[] args) {

    // объявление Array
    int[] myArray = new int[6];

    // обращение к несуществующему индексу
    myArray[7]= 10; // ArrayIndexOutOfBoundsException

    // объявление ArrayList
    ArrayList<Integer> myArrayList = new ArrayList<>();

    // простое добавление и удаление элементов
    myArrayList.add(1);
    myArrayList.add(2);
    myArrayList.add(3);
    myArrayList.add(4);
    myArrayList.add(5);
    myArrayList.remove(0);

    // получение элементов ArrayList    
    for(int i = 0; i < myArrayList.size(); i++) {
      System.out.println("Element: " + myArrayList.get(i));
    }
  
    // многомерный Array
    int[][][] multiArray = new int [3][3][3]; 
    }
}

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.font.PDType1Font;
import org.apache.pdfbox.pdmodel.graphics.image.PDImageXObject;

import java.io.IOException;

public class PDFCreationExample {
    public static void main(String[] args) throws IOException {
        try (PDDocument document = new PDDocument()) {
            PDPage page = new PDPage();
            document.addPage(page);

            try (PDPageContentStream contentStream = new PDPageContentStream(document, page)) {
                // Добавляем заголовок
                contentStream.beginText();
                contentStream.setFont(PDType1Font.HELVETICA_BOLD, 16);
                contentStream.newLineAtOffset(50, 750);
                contentStream.showText("Отчет о продажах");
                contentStream.endText();

                // Добавляем таблицу
                drawTable(contentStream, 50, 700, new String[][] {
                    {"Продукт", "Количество", "Цена"},
                    {"Яблоки", "100", "50"},
                    {"Бананы", "150", "40"},
                    {"Апельсины", "75", "60"}
                });

                // Добавляем изображение
                PDImageXObject image = PDImageXObject.createFromFile("path/to/image.jpg", document);
                contentStream.drawImage(image, 50, 500, 200, 150);
            }

            document.save("Отчет_о_продажах.pdf");
        }
    }

    private static void drawTable(PDPageContentStream contentStream, float x, float y, String[][] content) throws IOException {
        // Метод для рисования таблицы (код опущен для краткости)
    }
}

Map<String, Integer> map = new HashMap<>(1000);
map.computeIfAbsent("key", k -> 42);

import javassist.*;

public class LoggingExample {
    public static void main(String[] args) throws Exception {
        // Получаем пул классов
        ClassPool pool = ClassPool.getDefault();

        // Получаем класс, который хотим модифицировать
        CtClass ctClass = pool.get("com.example.MyClass");

        // Получаем все методы класса
        CtMethod[] methods = ctClass.getDeclaredMethods();

        for (CtMethod method : methods) {
            // Добавляем логирование в начало каждого метода
            method.insertBefore("System.out.println(\"Вызван метод: " + method.getName() + "\");");

            // Добавляем логирование в конец каждого метода
            method.insertAfter("System.out.println(\"Метод " + method.getName() + " завершен\");");
        }

        // Заменяем оригинальный класс модифицированным
        ctClass.toClass();

        // Теперь при использовании MyClass все его методы будут логироваться
        // Например:
        // MyClass obj = new MyClass();
        // obj.someMethod();
    }
}

public class OverflowTest {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE; // 2147483647
        int result = max * 2; // Переполнение!
        
        System.out.println("Max: " + max); // Max: 2147483647
        System.out.println("Result: " + result); // Result: -2
    }
}

public class SafeMultiply {
    public static void main(String[] args) {
        try {
            int safeResult = Math.multiplyExact(Integer.MAX_VALUE, 2);
            System.out.println(safeResult);
        } catch (ArithmeticException e) {
            System.out.println("Переполнение!");
        }
    }
}

// Без Lambda
File directory = new File("./src/main/java");
String[] list = directory.list(new FilenameFilter() {
    @Override
    public boolean accept(File dir, String name) {
        return name.endsWith(".java");
    }
});

// С Lambda
File directory = new File("./src/main/java");
String[] list = directory.list((dir, name) -> name.endsWith(".java"));

💻AssertJ — это библиотека для написания fluent-assertions в тестах, которая предоставляет удобный и читаемый синтаксис для проверок. Основные возможности:

// Проверки строк
assertThat("Hello Java")
    .startsWith("Hello")
    .endsWith("Java")
    .hasSize(10)
    .contains(" ");

// Проверки коллекций
assertThat(userList)
    .hasSize(3)
    .extracting(User::getName)
    .containsExactly("Alice", "Bob", "Charlie");

// Проверки исключений
assertThatThrownBy(() -> service.process(null))
    .isInstanceOf(IllegalArgumentException.class)
    .hasMessage("Parameter cannot be null");

assertThat(localDate)
    .isAfter("2023-01-01")
    .isBeforeOrEqualTo("2023-12-31");

assertThat(optionalValue)
    .isPresent()
    .contains("expected");

assertThat(book)
    .matches(b -> b.getPages() > 100, "толстая книга")
    .matches(b -> b.getAuthor() != null, "имеет автора");

1. 💬Более информативные сообщения об ошибках
2. 💬Поддержка цепочек проверок
3. 💬Встроенные проверки для коллекций
4. 💬Удобная работа с исключениями
5. 💬Поддержка Java 8+ features

import org.jgrapht.Graph;
import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
import org.jgrapht.graph.DefaultWeightedEdge;
import org.jgrapht.graph.SimpleWeightedGraph;

public class RoadNetworkExample {
    public static void main(String[] args) {
        // Создаем взвешенный граф
        Graph roadNetwork = 
            new SimpleWeightedGraph<>(DefaultWeightedEdge.class);

        // Добавляем города (вершины)
        roadNetwork.addVertex("Москва");
        roadNetwork.addVertex("Санкт-Петербург");
        roadNetwork.addVertex("Нижний Новгород");
        roadNetwork.addVertex("Казань");

        // Добавляем дороги (ребра) с расстояниями
        roadNetwork.setEdgeWeight(roadNetwork.addEdge("Москва", "Санкт-Петербург"), 700);
        roadNetwork.setEdgeWeight(roadNetwork.addEdge("Москва", "Нижний Новгород"), 400);
        roadNetwork.setEdgeWeight(roadNetwork.addEdge("Нижний Новгород", "Казань"), 400);
        roadNetwork.setEdgeWeight(roadNetwork.addEdge("Санкт-Петербург", "Казань"), 1500);

        // Находим кратчайший путь
        DijkstraShortestPath dijkstraAlg = 
            new DijkstraShortestPath<>(roadNetwork);
        var path = dijkstraAlg.getPath("Москва", "Казань");

        System.out.println("Кратчайший путь: " + path.getVertexList());
        System.out.println("Общее расстояние: " + path.getWeight() + " км");
    }
}

☕️Фишка Java: Optional для Null-Safety

⚙️Работа с null-значениями традиционно была источником ошибок в Java. Класс Optional предоставляет более элегантный способ обработки потенциально отсутствующих значений.

💬Традиционный подход:

User user = getUserById(id);
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        String city = address.getCity();
        if (city != null) {
            System.out.println(city.toUpperCase());
        }
    }
}

💻С использованием Optional:

Optional.ofNullable(getUserById(id))
    .map(User::getAddress)
    .map(Address::getCity)
    .ifPresent(city -> System.out.println(city.toUpperCase()));

💻Основные методы Optional:

1.⏺ ofNullable() - создает Optional из значения, которое может быть null
2.⏺ map() - преобразует значение, если оно присутствует
3.⏺ orElse() - предоставляет значение по умолчанию
4.⏺ ifPresent() - выполняет действие, если значение есть
5.⏺ orElseThrow() - бросает исключение, если значения нет

🗂Примеры:

1.🔐 Безопасное получение вложенных свойств:

String cityName = Optional.ofNullable(order)
    .map(Order::getCustomer)
    .map(Customer::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

2. 🗂Комбинация нескольких Optional:

Optional<Double> totalPrice = Optional.ofNullable(order1)
    .flatMap(o1 -> Optional.ofNullable(order2)
        .map(o2 -> o1.getPrice() + o2.getPrice()));

3. 🗂Работа с коллекциями:

List<String> names = Optional.ofNullable(userList)
    .orElse(Collections.emptyList())
    .stream()
    .map(User::getName)
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

🗂Преимущества использования Optional:

1.⏺ Явное указание на возможность отсутствия значения
2.⏺ Устранение проверок на null в коде
3.⏺ Четкая цепочка преобразований
4.⏺ Более читаемый и выразительный код

☕️Лямбда-выражения и Stream API

💻Лямбда-выражения и Stream API кардинально изменили подход к обработке данных в Java, позволив писать более декларативный и выразительный код.

🗂Пример без лямбд:

List<String> names = Arrays.asList("John", "Alice", "Bob");
Collections.sort(names, new Comparator() {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

🗂С лямбда-выражением:

List<String> names = Arrays.asList("John", "Alice", "Bob");
names.sort((a, b) -> a.compareTo(b));

🔵Stream API позволяет выполнять сложные операции над коллекциями:

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

🗂Ключевые преимущества:

1.⏺ Упрощение работы с коллекциями
2.⏺ Возможность цепочечных вызовов методов
3.⏺ Параллельная обработка через parallelStream()
4.⏺ Ленивое выполнение операций

🗂Примеры:

1.🔅 Фильтрация и преобразование:

List<Product> expensiveProducts = products.stream()
    .filter(p -> p.getPrice() > 1000)
    .map(p -> p.withDiscount(0.1))
    .collect(Collectors.toList());

2.🟡 Группировка данных:

Map<String, List<Employ>> employeesByDepartment = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));

3.💬 Статистические операции:

IntSummaryStatistics stats = salaries.stream()
    .mapToInt(Integer::intValue)
    .summaryStatistics();

🗂Особенности работы:

- 💬Stream не изменяет исходную коллекцию
- 💬Многие операции возвращают новый Stream
- 💬Терминальные операции завершают цепочку
- 💬Оптимизированная работа с памятью

🗂MapStruct — это генератор кода для маппинга между Java-бинами, который создает реализации mapper-ов на этапе компиляции.

1. 🗣Автоматический маппинг полей с одинаковыми именами
2. 🗣Высокая производительность (нет рефлексии в runtime)
3. 🗣Поддержка сложных преобразований
4. 🗣Интеграция с Spring и CDI

@Mapper(componentModel = "spring")
public interface UserMapper {
    
    @Mapping(target = "fullName", expression = "java(user.getFirstName() + \" \" + user.getLastName())")
    @Mapping(target = "status", constant = "ACTIVE")
    UserDto toDto(User user);
    
    @Mapping(target = "firstName", source = "fullName.split(\" \")[0]")
    @Mapping(target = "lastName", source = "fullName.split(\" \")[1]")
    User toEntity(UserDto dto);
}

-💬 Генерация чистого Java-кода без зависимостей
-💬 Поддержка коллекций и потоков
-💬 Преобразование типов
-💬 Работа с вложенными объектами
-💬 Кастомные методы маппинга

@Service
@RequiredArgsConstructor
public class UserService {
    private final UserMapper userMapper;
    
    public UserDto createUser(UserRequest request) {
        User user = userMapper.toEntity(request);
        // бизнес-логика
        return userMapper.toDto(user);
    }
}

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.time.LocalDateTime;

public class BackupSchedulerExample {
    public static void main(String[] args) throws SchedulerException {
        // Создаем планировщик
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // Определяем задачу
        JobDetail job = JobBuilder.newJob(DatabaseBackupJob.class)
                .withIdentity("databaseBackupJob", "backupGroup")
                .build();

        // Создаем триггер для запуска задачи каждый день в 2:00
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("dailyBackupTrigger", "backupGroup")
                .withSchedule(CronScheduleBuilder.dailyAtHourAndMinute(2, 0))
                .build();

        // Планируем задачу с триггером
        scheduler.scheduleJob(job, trigger);

        // Запускаем планировщик
        scheduler.start();

        System.out.println("Планировщик резервного копирования запущен.");
        System.out.println("Следующее резервное копирование запланировано на: " 
                + trigger.getNextFireTime());

        // Оставляем планировщик работать
        try {
            Thread.sleep(60000); // Ждем 1 минуту для демонстрации
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Останавливаем планировщик
        scheduler.shutdown();
    }

    // Класс, представляющий задачу резервного копирования
    public static class DatabaseBackupJob implements Job {
        @Override
        public void execute(JobExecutionContext context) {
            System.out.println("Выполняется резервное копирование базы данных: " 
                    + LocalDateTime.now());
            // Здесь был бы реальный код для резервного копирования
        }
    }
}

if (obj instanceof String) {
    String str = (String) obj;
    System.out.println(str.length());
}

if (obj instanceof String str) {
    System.out.println(str.length());
}

import org.mindrot.jbcrypt.BCrypt;

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

public class AuthenticationSystem {
    private static Map users = new HashMap<>();

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("1. Регистрация");
            System.out.println("2. Вход");
            System.out.println("3. Выход");
            System.out.print("Выберите действие: ");

            int choice = scanner.nextInt();
            scanner.nextLine(); // Очистка буфера

            switch (choice) {
                case 1:
                    register(scanner);
                    break;
                case 2:
                    login(scanner);
                    break;
                case 3:
                    System.out.println("До свидания!");
                    return;
                default:
                    System.out.println("Неверный выбор. Попробуйте снова.");
            }
        }
    }

    private static void register(Scanner scanner) {
        System.out.print("Введите имя пользователя: ");
        String username = scanner.nextLine();
        System.out.print("Введите пароль: ");
        String password = scanner.nextLine();

        String hashedPassword = BCrypt.hashpw(password, BCrypt.gensalt());
        users.put(username, hashedPassword);

        System.out.println("Регистрация успешна!");
    }

    private static void login(Scanner scanner) {
        System.out.print("Введите имя пользователя: ");
        String username = scanner.nextLine();
        System.out.print("Введите пароль: ");
        String password = scanner.nextLine();

        if (users.containsKey(username) && BCrypt.checkpw(password, users.get(username))) {
            System.out.println("Вход выполнен успешно!");
        } else {
            System.out.println("Неверное имя пользователя или пароль.");
        }
    }
}

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

public class LambdaExample {
    public static void main(String[] args) {
        // Реализация интерфейса с помощью лямбда-выражения
        MathOperation addition = (a, b) -> a + b;
        MathOperation subtraction = (a, b) -> a - b;
        MathOperation multiplication = (a, b) -> a * b;
        MathOperation division = (a, b) -> a / b;

        int x = 10;
        int y = 5;

        System.out.println("Addition: " + operate(x, y, addition)); // 15
        System.out.println("Subtraction: " + operate(x, y, subtraction)); // 5
        System.out.println("Multiplication: " + operate(x, y, multiplication)); // 50
        System.out.println("Division: " + operate(x, y, division)); // 2
    }

    // Метод, принимающий MathOperation и применяющий его к данным
    private static int operate(int a, int b, MathOperation operation) {
        return operation.operate(a, b);
    }
}

module com.example.app {
    requires java.sql;
    exports com.example.app.api;
}

public class Logger {
    private String prefix;
    
    { // Блок инициализации экземпляра (выполняется перед конструктором)
        prefix = "[LOG] " + LocalDateTime.now();  // Инициализация префикса с текущей датой/временем
        System.out.println("Логгер готов!");      // Сообщение о готовности логгера
    }
    
    public Logger() {
        System.out.println(prefix + " | Новый объект");  // Вывод информации о создании объекта
    }
}

public class ConfigLoader {
    static {
        System.out.println("Загружаем конфиги...");
        // Здесь можно читать файлы, подключать БД и т.д.
    }
}

public enum FileFormat {
    CSV {
        public String parse(String data) {
            return data.replace(",", ";");
        }
    },
    JSON {
        public String parse(String data) {
            return "{" + data + "}";
        }
    };
    
    public abstract String parse(String data);
}

public interface Formatter {
    String format(String text);
}

public enum TextFormat implements Formatter {
    UPPERCASE {
        public String format(String text) {
            return text.toUpperCase();
        }
    },
    LOWERCASE {
        public String format(String text) {
            return text.toLowerCase();
        }
    };
}

// Пример вызова
String result = TextFormat.UPPERCASE.format("Hello"); // "HELLO"

public enum OrderStatus {
    NEW(1) {
        public OrderStatus next() {
            return PROCESSING;
        }
    },
    PROCESSING(2) {
        public OrderStatus next() {
            return SHIPPED;
        }
    },
    SHIPPED(3) {
        public OrderStatus next() {
            return COMPLETED;
        }
    };

    private final int code;

    OrderStatus(int code) {
        this.code = code;
    }

    public abstract OrderStatus next();
}

@Entity
public class Order {
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
}

// Сохраняется как строка "NEW", "PROCESSING" в БД

public static OrderStatus findByCode(int code) {
    return Arrays.stream(OrderStatus.values())
        .filter(status -> status.code == code)
        .findFirst()
        .orElseThrow();
}

public enum MathOperation {
    PLUS("+", (a, b) -> a + b),
    MINUS("-", (a, b) -> a - b);

    private final String symbol;
    private final IntBinaryOperator operation;

    MathOperation(String symbol, IntBinaryOperator operation) {
        this.symbol = symbol;
        this.operation = operation;
    }

    public int apply(int a, int b) {
        return operation.applyAsInt(a, b);
    }
}

// Использование
int result = MathOperation.PLUS.apply(5, 3); // 8

String description = switch (status) {
    case NEW -> "Новый заказ";
    case PROCESSING -> "В обработке";
    case SHIPPED -> "Отправлен";
};

EnumSet activeStatuses = EnumSet.of(NEW, PROCESSING);
if (activeStatuses.contains(currentStatus)) {
    // Логика для активных статусов
}