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)) {
    // Логика для активных статусов
}

   implementation 'com.google.code.gson:gson:2.12.1'
   

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

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

Gson gson = new Gson();
User user = new User("John", 25);
String json = gson.toJson(user);
System.out.println(json);

{"name":"John","age":25}

String json = "{\"name\":\"Jane\",\"age\":30}";
User user = gson.fromJson(json, User.class);
System.out.println("Имя: " + user.getName() + ", Возраст: " + user.getAge());

String jsonArray = "[{\"name\":\"John\",\"age\":25},{\"name\":\"Jane\",\"age\":30}]";
Type userListType = new TypeToken<List<User>>() {}.getType();
List<User> users = gson.fromJson(jsonArray, userListType);

for (User user : users) {
    System.out.println("Имя: " + user.getName() + ", Возраст: " + user.getAge());
}

Gson gson = new GsonBuilder()
    .setPrettyPrinting()
    .excludeFieldsWithoutExposeAnnotation()
    .create();
String json = gson.toJson(user);
System.out.println(json);

{
  "name": "John",
  "age": 25
}

try {
    User user = gson.fromJson("{invalid_json}", User.class);
} catch (JsonSyntaxException e) {
    e.printStackTrace();
}

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

public interface ApiService {
    @GET("users")
    Call<List<User>> getUsers();
}

ApiService apiService = retrofit.create(ApiService.class);
apiService.getUsers().enqueue(new Callback>() {
    @Override
    public void onResponse(Call<List<User>> call, Response<List<User>> response) {
        if (response.isSuccessful()) {
            List<User> users = response.body();
            // Обработка данных
        } else {
            // Обработка ошибки
        }
    }

    @Override
    public void onFailure(Call<List<User>> call, Throwable t) {
        // Обработка ошибки сети
    }
});

public class User {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

public interface ApiService {
    @GET("users/{id}")
    Call<User> getUser(@Path("id") int userId);
}

apiService.getUser(1).enqueue(new Callback() {
    @Override
    public void onResponse(Call<User> call, Response response) {
        if (response.isSuccessful()) {
            User user = response.body();
            // Обработка данных пользователя
        }
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
        // Обработка ошибки сети
    }
});

public interface ApiService {
    @GET("users")
    Call<List<User>> getUsers(@Header("Authorization") String token);
}

public interface ApiService {
    @POST("users")
    Call<User> createUser(@Body User user);

    @GET("users")
    Call<List<User>> getUsers(@Query("page") int page);
}

Parent parent = new Child();
if (parent instanceof Child) {
    Child child = (Child) parent;
}

// Опасно - можно добавить что угодно, ошибка будет при извлечении
List unsafeList = new ArrayList();
unsafeList.add("Привет");
unsafeList.add(123); // Компилятор не ругается!

// String s = (String) unsafeList.get(1); // ClassCastException во время выполнения!

// Безопасно - только строки!
List<String> safeList = new ArrayList<>();
safeList.add("Привет");
// safeList.add(123); // Ошибка компиляции! Нельзя добавить int в List<String>

String s = safeList.get(0); // Никакого приведения типов не нужно!

import java.time.LocalDate;
import java.time.Month;
import java.time.temporal.ChronoUnit;

LocalDate today = LocalDate.now();
LocalDate birthday = LocalDate.of(2024, Month.DECEMBER, 31);
LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS); // Неизменяемый! Возвращает новый объект

System.out.println("Сегодня: " + today);
System.out.println("День рождения: " + birthday);
System.out.println("Через неделю: " + nextWeek);
// Вывод:
// Сегодня: 2023-10-27 (пример)
// День рождения: 2024-12-31
// Через неделю: 2023-11-03 (пример)