public class CompletableFutureHandle {
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // Создаем будущее, которое завершится исключительно
        CompletableFuture<String> failedFuture = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Ошибка в задаче");
        });
        
        //thenApply не выполнится, исключение игнорируется
        CompletableFuture<String> badChain = failedFuture.thenApply(s -> s + " обработано");
        // badChain.get() выбросит ExecutionException с исходной ошибкой
        
        //handle: всегда вызывается, получает результат или исключение
        CompletableFuture<String> handled = failedFuture.handle((result, ex) -> {
            if (ex != null) {
                System.err.println("Ошибка: " + ex.getMessage());
                return "Значение по умолчанию";
            }
            return result + " (успех)";
        });
        System.out.println("handle result: " + handled.join()); // Значение по умолчанию
        
        //whenComplete: для логирования, не меняет результат
        CompletableFuture<String> logged = failedFuture.whenComplete((result, ex) -> {
            if (ex != null) {
                System.err.println("Логируем ошибку: " + ex);
            } else {
                System.out.println("Успешно: " + result);
            }
        });
        // logged по-прежнему будет завершено исключительно
        // logged.join() выбросит CompletionException
        
        // Обработка через exceptionally (только при ошибке)
        CompletableFuture<String> recovered = failedFuture.exceptionally(ex -> {
            System.err.println("Восстановление: " + ex);
            return "Восстановленное значение";
        });
        System.out.println("exceptionally: " + recovered.join());
        
        // Комбинирование: handle может изменить тип
        CompletableFuture<Integer> typed = failedFuture.handle((s, ex) -> {
            return ex != null ? -1 : s.length();
        });
        System.out.println("handle with type: " + typed.join()); // -1
    }
}

import java.util.concurrent.CompletableFuture;

public class Task300626 {
    public static void main(String[] args) throws Exception {
        CompletableFuture<String> future = new CompletableFuture<>();

        CompletableFuture<String> result = future
                .thenApply(s -> s + "!")
                .exceptionally(ex -> "fallback");

        future.completeExceptionally(new RuntimeException("Oops"));
        System.out.println(result.get());
    }
}

// Упрощенная структура из OpenJDK
public class SequenceInputStream extends InputStream {
    // Текущий активный поток
    private InputStream in;
    
    // Перечисление оставшихся потоков
    private Enumeration<InputStream> e;
    
    // Конструктор для двух потоков
    public SequenceInputStream(InputStream s1, InputStream s2) {
        Vector<InputStream> v = new Vector<>(2);
        v.addElement(s1);
        v.addElement(s2);
        e = v.elements();
        nextStream(); // Установка первого потока
    }
    
    // Конструктор для произвольного количества потоков
    public SequenceInputStream(Enumeration<InputStream> e) {
        this.e = e;
        nextStream(); // Установка первого потока
    }
    
    // Переключение на следующий поток
    private void nextStream() {
        if (in != null) {
            in.close(); // Закрытие исчерпанного потока
        }
        in = e.hasMoreElements() ? e.nextElement() : null;
    }
}

public int read() throws IOException {
    if (in == null) {
        return -1; // Все потоки исчерпаны
    }
    int c = in.read(); // Делегирование текущему потоку
    if (c == -1) {
        nextStream(); // Переключение на следующий
        return read(); // Рекурсивный вызов для нового потока
    }
    return c;
}

[Java: sis.read()]
  -> [SequenceInputStream: in != null?]
    -> [in.read()] // Делегирование текущему потоку
      -> [Например, FileInputStream.read()]
        -> [Системный вызов read()]
          -> [Page Cache -> нативный буфер -> byte в heap]
    -> [c == -1?] // Конец текущего потока?
      -> [Нет: возврат c]
      -> [Да: nextStream()]
        -> [in.close()] // Закрытие исчерпанного потока
        -> [in = e.nextElement()] // Следующий поток
        -> [Рекурсивный read()] // Чтение из нового потока

public int read(byte[] b, int off, int len) throws IOException {
    if (in == null) {
        return -1;
    }
    if (b == null) {
        throw new NullPointerException();
    }
    
    int n = in.read(b, off, len); // Попытка чтения из текущего потока
    if (n > 0) {
        return n; // Данные прочитаны
    }
    if (n == -1) {
        nextStream(); // Конец потока — переключение
        return read(b, off, len); // Рекурсивный вызов
    }
    // n == 0: поток вернул 0 байт, но не EOF
    return 0;
}

public void concatenateFiles(String outputPath, String... inputPaths) 
        throws IOException {
    
    // Создание Enumeration из списка путей
    Vector<InputStream> streams = new Vector<>();
    for (String path : inputPaths) {
        streams.add(new FileInputStream(path)); // Каждый поток — объект в heap
    }
    
    // SequenceInputStream создается в heap
    // Внутренний Vector — объект в heap
    try (SequenceInputStream sis = new SequenceInputStream(streams.elements());
         FileOutputStream fos = new FileOutputStream(outputPath)) {
        
        byte[] buffer = new byte[8192]; // Буфер в heap
        int bytesRead;
        
        // Цикл без аллокаций — GC не вовлечен
        while ((bytesRead = sis.read(buffer)) != -1) {
            fos.write(buffer, 0, bytesRead);
        }
        
    } // sis.close() закрывает текущий поток и все оставшиеся в Enumeration
    
    // Vector, FileInputStream'ы, buffer — недостижимы, GC собирает
}

// Антипаттерн: утечка при исключении в конструкторе
Vector<InputStream> streams = new Vector<>();
for (String path : paths) {
    streams.add(new FileInputStream(path)); // Если здесь исключение — предыдущие потоки не закрыты
}
SequenceInputStream sis = new SequenceInputStream(streams.elements());

// Правильно: гарантированное закрытие при исключении
List<InputStream> streams = new ArrayList<>();
try {
    for (String path : paths) {
        streams.add(new FileInputStream(path));
    }
    Enumeration<InputStream> en = Collections.enumeration(streams);
    try (SequenceInputStream sis = new SequenceInputStream(en)) {
        // Использование
    }
} catch (IOException e) {
    // Закрытие всех созданных потоков при ошибке
    for (InputStream is : streams) {
        try { is.close(); } catch (IOException ignored) {}
    }
    throw e;
}

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class FileConcatenator {
    
    // Объединение файлов с автоматическим закрытием
    public void concatenate(String outputPath, String... inputPaths) 
            throws IOException {
        
        // Создание списка потоков с гарантированным закрытием при ошибках
        List<InputStream> streams = new ArrayList<>();
        boolean success = false;
        
        try {
            for (String path : inputPaths) {
                streams.add(new FileInputStream(path));
            }
            
            // SequenceInputStream объединяет все потоки
            Enumeration<InputStream> en = Collections.enumeration(streams);
            try (SequenceInputStream sis = new SequenceInputStream(en);
                 // Декодирование байтов в символы через UTF-8
                 InputStreamReader isr = new InputStreamReader(sis, StandardCharsets.UTF_8);
                 // Буферизация символьного ввода
                 BufferedReader reader = new BufferedReader(isr);
                 // Запись в выходной файл
                 FileOutputStream fos = new FileOutputStream(outputPath);
                 OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
                 BufferedWriter writer = new BufferedWriter(osw)) {
                
                String line;
                while ((line = reader.readLine()) != null) {
                    writer.write(line);
                    writer.newLine();
                }
                
                success = true;
            }
            
        } finally {
            // Закрытие всех потоков, если try-with-resources не сработал
            if (!success) {
                for (InputStream is : streams) {
                    try { is.close(); } catch (IOException ignored) {}
                }
            }
        }
    }
    
    // Альтернатива: объединение только двух файлов
    public void concatenateTwo(String outputPath, String path1, String path2) 
            throws IOException {
        
        try (SequenceInputStream sis = new SequenceInputStream(
                new FileInputStream(path1),
                new FileInputStream(path2));
             FileOutputStream fos = new FileOutputStream(outputPath)) {
            
            // Прямое блочное копирование без промежуточных преобразований
            byte[] buffer = new byte[8192];
            int bytesRead;
            while ((bytesRead = sis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        }
        // Оба FileInputStream закрыты автоматически:
        // - первый при исчерпании (внутри nextStream)
        // - второй при закрытии SequenceInputStream
    }
}

[Файл 1 на диске: байты UTF-8]
  -> [FileInputStream 1: системный вызов read()]
    -> [SequenceInputStream: делегирование FileInputStream 1]
      -> [InputStreamReader: декодирование байт -> char]
        -> [BufferedReader: накопление в cb[8192], поиск \n]
          -> [readLine(): создание String]
            -> [BufferedWriter.write(String)]
              -> [OutputStreamWriter: кодирование char -> байты UTF-8]
                -> [FileOutputStream: системный вызов write()]
                  -> [Page Cache -> диск]

[Конец файла 1: FileInputStream 1.read() возвращает -1]
  -> [SequenceInputStream.nextStream()]
    -> [FileInputStream 1.close()] // Автоматическое закрытие
    -> [FileInputStream 2 становится активным]

[Файл 2 на диске: байты UTF-8]
  -> [FileInputStream 2: системный вызов read()]
    -> [SequenceInputStream: делегирование FileInputStream 2]
      -> [Тот же путь через Reader/Writer]

// Правильно: буферизация каждого потока
Vector<InputStream> streams = new Vector<>();
for (String path : paths) {
    streams.add(new BufferedInputStream(new FileInputStream(path)));
}
SequenceInputStream sis = new SequenceInputStream(streams.elements());

// Объединение через Stream API — более гибко, но с другой семантикой
public void concatenateModern(String outputPath, String... inputPaths) 
        throws IOException {
    
    try (OutputStream out = new FileOutputStream(outputPath)) {
        for (String path : inputPaths) {
            Files.copy(Path.of(path), out); // Копирование файла в общий поток
        }
    }
}

import java.io.*;

public class Task010726 {
    public static void main(String[] args) throws IOException {
        ByteArrayInputStream bais1 = new ByteArrayInputStream(new byte[]{1, 2, 3});
        ByteArrayInputStream bais2 = new ByteArrayInputStream(new byte[]{4, 5, 6});
        SequenceInputStream sis = new SequenceInputStream(bais1, bais2);
        byte[] buffer = new byte[5];
        int len = sis.read(buffer, 0, 5);
        System.out.println(len);
        for (int i = 0; i < len; i++) {
            System.out.print(buffer[i] + " ");
        }
    }
}