public class CacheService {
    private final Map<String, List<Object>> cache = new ConcurrentHashMap<>();

    public List<Object> getCachedValues(String key) {
        return cache.getOrDefault(key, Collections.emptyList());
    }

    public void addToCache(String key, Object value) {
        cache.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
    }
}

System.out.println(Objects.hashCode(null)); // 0

List<String> list = new ArrayList<String>(); // Приходилось дублировать <String>

List<String> list = new ArrayList<>(); // Компилятор сам выводит <String>

List<String > planets = new ArrayList<>() {{
    add ("Mercury");
    add ("Venus");
    add ("Earth");
    add ("Mars");
    add ("Jupiter");
    add ("Saturn");
    add ("Uranus") ;
    add ("Neptune");
}};

List<String> planets = Stream.of("Mercury", "Venus", "Earth")
                             .collect(Collectors.toList());

List<String> planets = List.of("Mercury", "Venus", "Earth");

List<Integer> list = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(2, 3, 5)));

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());
}