import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Загружаем данные...");
            sleep(2000);
            return "Данные загружены";
        }).thenApply(data -> {
            System.out.println("Обрабатываем: " + data);
            return data.toUpperCase();
        }).thenAccept(System.out::println)
          .exceptionally(ex -> {
              System.out.println("Ошибка: " + ex.getMessage());
              return null;
          });

        sleep(3000); // Даем время асинхронной операции завершиться
    }

    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Optional<String> optional = Optional.ofNullable(getValue());
if (optional.isPresent()) {
    System.out.println(optional.get());
}

Optional.ofNullable(getValue()).ifPresent(System.out::println);

String value = Optional.ofNullable(getValue()).orElse("Default Value");

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyService {
    private static final Logger log = LoggerFactory.getLogger(MyService.class);
}

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MyService {
}

log.info("Приложение запущено");
log.error("Произошла ошибка: {}", exception.getMessage());

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.11</version>
</dependency>

Optional<String> name = Optional.ofNullable(user.getName());
name.ifPresent(System.out::println);

Optional<String> city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity);

User user = optionalUser.orElse(new User());

User user = optionalUser.orElseGet(User::new);

User user = optionalUser.orElseThrow(() -> new RuntimeException("User not found"));

@EnableAsync
@SpringBootApplication
public class MyApplication {

@Service
public class EmailService {

    @Async
    public void sendEmail(String email) {
        System.out.println("Отправка email: " + email + " в потоке " + Thread.currentThread().getName());
    }
}

@Component
public class NotificationSender {

    private final EmailService emailService;

    public NotificationSender(EmailService emailService) {
        this.emailService = emailService;
    }

    public void notifyUser(String email) {
        emailService.sendEmail(email);
        System.out.println("Метод notifyUser выполняется в потоке " + Thread.currentThread().getName());
    }
}

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.initialize();
        return executor;
    }
}

class User {
    String name;
    int age;

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

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

List<User> users = List.of(
    new User("Алекс", 25),
    new User("Мария", 17),
    new User("Иван", 30),
    new User("Ольга", 20)
);

List<String> adultNames = users.stream()
    .filter(user -> user.age >= 18)  // Фильтрация
    .sorted(Comparator.comparingInt(user -> user.age)) // Сортировка
    .map(user -> user.name) // Преобразование
    .toList();

System.out.println(adultNames); // [Ольга, Алекс, Иван]

Query query = entityManager.createQuery("SELECT u FROM User u WHERE u.age > :age")
        .setParameter("age", 25)
        .setHint("org.hibernate.cacheable", true);
List<User> users = query.getResultList();

@QueryHints({@QueryHint(name = "org.hibernate.readOnly", value = "true")})
@Query("SELECT u FROM User u WHERE u.status = 'ACTIVE'")
List<User> findActiveUsers();

int d = 365;

int daysInYear = 365;

if (user != null) {
    if (user.isActive()) {
        process(user);
    }
}

if (user == null) return;
if (!user.isActive()) return;
process(user);

private static final int SECONDS_IN_A_DAY = 86400;

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    MyClass myClass = (MyClass) obj;
    return Objects.equals(field1, myClass.field1) &&
           Objects.equals(field2, myClass.field2);
}

@Override
public int hashCode() {
    return Objects.hash(field1, field2);
}