import io.r2dbc.spi.ConnectionFactories;
import io.r2dbc.spi.ConnectionFactory;
import reactor.core.publisher.Flux;

public void createConnectionFactory () {

  ConnectionFactory factory = ConnectionFactories.get("r2dbc:postgresql://localhost:5432/db?username=user&password=pass");

  Flux<String> namesFlux = Flux.usingWhen(

     factory.create(), // Асинхронно создать соединение

     conn -> conn.createStatement("SELECT name FROM users").execute().flatMap(result -> result.map((row, metadata) -> row.get("name", String.class))),
     conn -> conn.close() // Асинхронно закрыть
  );

  namesFlux.subscribe(System.out::println); // Строки приходят асинхронно
}

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-r2dbc</artifactId>
</dependency>
<dependency>
  <groupId>io.r2dbc</groupId>
  <artifactId>r2dbc-postgresql</artifactId> <!-- Для PostgreSQL -->
</dependency>

spring.r2dbc.url=r2dbc:postgresql://localhost:5432/db
spring.r2dbc.username=user
spring.r2dbc.password=pass

ReactiveRepository extends ReactiveCrudRepository<Entity, ID>.

@Entity
public class User {
  @Id
  private Long id;
  private String name;
  // Getters/setters
}

public interface UserRepository extends ReactiveCrudRepository<User, Long> {
  @Query("SELECT * FROM users WHERE name LIKE :name")
  Flux<User> findByNameLike(String name);
}

@Service
public class UserService {
  private final UserRepository repo;

  public UserService(UserRepository repo) {
     this.repo = repo;
  }

  public Flux<User> findAll() {
    return repo.findAll(); // Flux асинхронно
  }

  public Mono<User> save(User user) {
     return repo.save(user);
  }
}

@GetMapping("/users")
public Flux<User> getAllUsers() {
     return userService.findAll();
}

public interface UserRepository extends ReactiveSortingRepository<User, Long> {}
Flux<User> paged = repo.findAll(Sort.by("name").ascending()).skip(10).take(20); // Простая пагинация
Для complex: используйте @Query с параметрами, или Criteria API.

import java.util.LinkedList;

public class Task221025 {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        
        list.remove(1);
        list.remove(new Integer(2));
        
        System.out.println(list.size());
        System.out.println(list.get(0));
    }
}

import java.util.ArrayDeque;
import java.util.Deque;

public class Main {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();
        // FIFO: Очередь
        deque.offerLast("Элемент 1");  // Добавление в конец
        deque.offerLast("Элемент 2");
        System.out.println(deque.pollFirst());  // Элемент 1 (извлечение из начала)
        System.out.println(deque.peekFirst());  // Элемент 2 (просмотр)

        // LIFO: Стек
        deque.offerFirst("Элемент 3");  // Добавление в начало
        deque.offerFirst("Элемент 4");
        System.out.println(deque.pollFirst());  // Элемент 4 (LIFO)

        // Обратный итератор
        for (String elem : deque.descendingIterator()) {
            System.out.println(elem);  // С конца к началу
        }
    }
}

Вывод: Показывает FIFO и LIFO, операции O(1).

import java.util.LinkedList;
import java.util.Deque;

public class Main {
    public static void main(String[] args) {
        Deque<String> deque = new LinkedList<>();
        deque.addLast("Элемент 1");
        deque.addLast("Элемент 2");
        System.out.println(deque.removeFirst());  // Элемент 1

        deque.addFirst("Элемент 3");
        System.out.println(deque.removeFirst());  // Элемент 3 (LIFO)
    }
}

Вывод: То же, что и ArrayDeque, но с List-возможностями.

import java.util.ArrayDeque;
import java.util.Deque;

public class Task231025 {
    public static void main(String[] args) {
        Deque<Integer> deque = new ArrayDeque<>();
        deque.offer(1);
        deque.push(2);
        deque.offer(3);
        deque.push(4);
        
        System.out.print(deque.poll() + " ");
        System.out.print(deque.pop() + " ");
        System.out.print(deque.remove() + " ");
        System.out.print(deque.element());
    }
}

Mono<String> coldMono = Mono.fromCallable(() -> {
     System.out.println("Генерация данных...");
     return "Данные";
});

coldMono.subscribe(System.out::println); // Вывод: "Генерация данных..." и "Данные"
coldMono.subscribe(System.out::println); // Снова: "Генерация данных..." и "Данные"
Каждый subscribe() вызывает fromCallable заново — данные свежие, но если это запрос в API, будет два вызова.

   Flux<Integer> coldFlux = Flux.range(1, 3).doOnSubscribe(sub -> System.out.println("Новая подписка!"));
   coldFlux.subscribe(val -> System.out.println("Подписчик 1: " + val));
   coldFlux.subscribe(val -> System.out.println("Подписчик 2: " + val));
   // Вывод: "Новая подписка!" + 1,2,3 для первого; "Новая подписка!" + 1,2,3 для второго

Каждый подписчик получает полный поток независимо. Полезно для idempotent операций (без side-effects), как чтение статичных данных.
Асинхронный пример: coldFlux = Flux.interval(Duration.ofSeconds(1)).take(3); // Каждый subscribe() запускает свой таймер.

ConnectableFlux<Integer> hotFlux = Flux.push(sink -> {
// Симулируем внешний источник
new Thread(() -> {
   for (int i = 1; i <= 3; i++) {
   try { Thread.sleep(1000); } catch (InterruptedException e) {}
   sink.next(i);
}
   sink.complete();
   }).start();
});

hotFlux.subscribe(val -> System.out.println("Подписчик 1: " + val));
Thread.sleep(1500); // Ждём, чтобы пропустить начало
hotFlux.subscribe(val -> System.out.println("Подписчик 2: " + val));
hotFlux.connect(); // Запуск горячего

// Вывод примерно: Подписчик 1: 1 (1с), 2 (2с), 3 (3с); Подписчик 2: 2 (присоединился после 1), 3

Второй пропустил 1 — поток общий. Connect() — триггер для ConnectableFlux (обёртка для горячих).

Flux.interval(Duration.ofSeconds(1)) — бесконечный таймер, вещает независимо.
Оператор share(): Делает холодный горячим.
Flux<Integer> shared = coldFlux.share();
shared.subscribe(...); // Запускает
shared.subscribe(...); // Присоединяется к существующему