import java.util.*;

public class Task211124_1 {
    public static void main(String[] args) {
        List<String> items = Arrays.asList("A", "B", "C", "D", "E", "F", "G", "H", "I", "J");
        int pageSize = 3;
        int page = 3;

        List<String> pageItems = paginate(items, page, pageSize);
        System.out.println(pageItems);
    }

    public static List<String> paginate(List<String> items, int page, int pageSize) {
        int start = (page - 1) * pageSize;
        int end = Math.min(start + pageSize, items.size());
        return items.subList(start, end);
    }
}

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private String email;

    // getters and setters
}

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByName(String name);
    User findByEmail(String email);
    List<User> findByNameAndEmail(String name, String email);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> getUsersByName(String name) {
        return userRepository.findByName(name);
    }

    public User getUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }

    public List<User> getUsersByNameAndEmail(String name, String email) {
        return userRepository.findByNameAndEmail(name, email);
    }
}

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface UserRepository extends JpaRepository<User, Long> {

    @Query("SELECT u FROM User u WHERE u.name = :name")
    List<User> findUsersByName(@Param("name") String name);

    @Query("SELECT u FROM User u WHERE u.email LIKE %:emailDomain")
    List<User> findUsersByEmailDomain(@Param("emailDomain") String emailDomain);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> findUsersByEmailDomain(String domain) {
        return userRepository.findUsersByEmailDomain(domain);
    }
}

import org.springframework.data.domain.Sort;

List<User> findAll(Sort sort);

List<User> usersSortedByName = userRepository.findAll(Sort.by("name"));

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;

Page<User> findAll(PageRequest pageable);

Page<User> usersPage = userRepository.findAll(PageRequest.of(0, 10));

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

import java.util.List;

@SpringBootApplication
public class Main211124_2 {
    public static void main(String[] args) {
        SpringApplication.run(Main211124_2.class, args);
    }

    @Bean
    public CommandLineRunner demo(UserRepository2111 repository) {
        return args -> {
            repository.save(new User2111("Alice", 30));
            repository.save(new User2111("Bob", 25));
            List<User2111> users = repository.findByAgeGreaterThan(20);
            users.forEach(user -> System.out.println(user.getName()));
        };
    }
}

@Entity
@Table(name = "users2111")
class User2111 {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;
    private int age;

    // Конструкторы, геттеры и сеттеры
    public User2111() {}

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

    public String getName() {
        return name;
    }
}

@Repository
interface UserRepository2111 extends JpaRepository<User2111, Long> {
    List<User2111> findByAgeGreaterThan(int age);
}

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

INSERT INTO transactions (from_account, to_account, amount) VALUES (1, 2, 100);

COMMIT;
Если любая из этих операций не выполняется, все изменения откатываются.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class TransactionalService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void performTransactionalOperation() {
        TransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            // Ваши операции с базой данных
            performDatabaseOperation1();
            performDatabaseOperation2();

            // Подтверждение транзакции
            transactionManager.commit(status);
        } catch (Exception e) {
            // Откат транзакции в случае ошибки
            transactionManager.rollback(status);
            throw e;
        }
    }

    private void performDatabaseOperation1() {
        // Код операции 1
    }

    private void performDatabaseOperation2() {
        // Код операции 2
    }
}
Этот метод предоставляет полный контроль над транзакциями, но делает код более сложным.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        // Семафор с 2 разрешениями
        Semaphore semaphore = new Semaphore(2);

        // Пул из 5 потоков
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            executor.submit(() -> {
                try {
                    System.out.println("Thread " + threadId + " is waiting for permit...");
                    semaphore.acquire(); // Получаем разрешение
                    System.out.println("Thread " + threadId + " acquired permit.");
                    Thread.sleep(2000); // Имитируем использование ресурса
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    System.out.println("Thread " + threadId + " released permit.");
                    semaphore.release(); // Освобождаем разрешение
                }
            });
        }

        executor.shutdown();
    }
}

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        // Создаем CountDownLatch с начальным значением 3
        CountDownLatch latch = new CountDownLatch(3);

        // Потоки, выполняющие задачи
        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " is working...");
            try {
                Thread.sleep(1000); // Имитация работы
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println(Thread.currentThread().getName() + " finished.");
            latch.countDown(); // Уменьшаем значение счетчика
        };

        // Запускаем 3 потока
        for (int i = 0; i < 3; i++) {
            new Thread(task).start();
        }

        System.out.println("Main thread is waiting for tasks to finish...");
        latch.await(); // Ждем, пока счетчик не станет равен 0
        System.out.println("All tasks are finished. Main thread resumes.");
    }
}

Semaphore semaphore = new Semaphore(10); // Максимум 10 соединений

// Каждый поток пытается установить соединение
Runnable connectTask = () -> {
    try {
        semaphore.acquire();
        System.out.println("Connection established by " + Thread.currentThread().getName());
        Thread.sleep(2000); // Используем соединение
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        System.out.println("Connection released by " + Thread.currentThread().getName());
        semaphore.release();
    }
};

CountDownLatch latch = new CountDownLatch(3);

Runnable loadData = () -> {
    try {
        System.out.println(Thread.currentThread().getName() + " loading data...");
        Thread.sleep(1000);
        latch.countDown();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

new Thread(loadData).start();
new Thread(loadData).start();
new Thread(loadData).start();

latch.await();
System.out.println("All data loaded. Proceeding to next step.");

public class Task221124_1 {
    public static void main(String[] args) {
        int[] arr = {3, 5, 7, 9, 11};
        int result = modifyArray(arr);
        System.out.println(result);
        System.out.println(arr[1]);
    }

    public static int modifyArray(int[] array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] % 2 == 0 ? array[i] / 2 : array[i] * 2;
            sum += array[i];
        }
        return sum;
    }
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PaymentService {

    @Transactional
    public void transferMoney(Long fromAccountId, Long toAccountId, double amount) {
        // Операции с базой данных
        debitAccount(fromAccountId, amount);
        creditAccount(toAccountId, amount);
    }

    private void debitAccount(Long accountId, double amount) {
        // Логика снятия средств
    }

    private void creditAccount(Long accountId, double amount) {
        // Логика зачисления средств
    }
}
В этом примере все операции внутри метода transferMoney выполняются в одной транзакции. Если любая операция завершится сбоем, все изменения будут откатаны.

@Transactional(
    propagation = Propagation.REQUIRES_NEW,
    isolation = Isolation.SERIALIZABLE,
    timeout = 30,
    rollbackFor = {RuntimeException.class},
    readOnly = false
)
public void processTransaction() {
    // Логика транзакции
}

@Transactional(rollbackFor = Exception.class)
public void updateDatabase() throws Exception {
    // Если возникает Exception, транзакция будет откатана
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class OrderService {

    public void createOrder() {
        // Операции в транзакции
    }

    public void cancelOrder() {
        // Операции в транзакции
    }
}

@Service
public class ExampleService {

    @Transactional
    public void method1() {
        method2(); // method2 вызван напрямую, @Transactional не применяется
    }

    @Transactional
    public void method2() {
        // Логика method2
    }
}
Только публичные методы: Аннотация работает только на публичных методах. Внутренние вызовы приватных или protected методов не активируют транзакцию.