// Упрощенная структура из 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] + " ");
        }
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.List;
import java.util.stream.Collectors;

public class AllOfResults {
    
    public static void main(String[] args) {
        List<CompletableFuture<String>> futures = List.of(
            CompletableFuture.supplyAsync(() -> "Result 1"),
            CompletableFuture.supplyAsync(() -> "Result 2"),
            CompletableFuture.supplyAsync(() -> "Result 3")
        );
        
        //allOf возвращает Void — результаты не доступны
        CompletableFuture<Void> all = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
        all.join(); // ждем завершения, но результатов нет
        
        //Собираем результаты вручную через thenApply
        CompletableFuture<List<String>> combined = CompletableFuture
            .allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList()));
        
        List<String> results = combined.join();
        System.out.println(results); // [Result 1, Result 2, Result 3]
        
        // ✅ Альтернатива: использование thenAccept для побочного эффекта
        CompletableFuture<Void> log = CompletableFuture
            .allOf(futures.toArray(new CompletableFuture[0]))
            .thenAccept(v -> futures.forEach(f -> System.out.println(f.join())));
        log.join();
        
        //Сборка с преобразованием типов
        CompletableFuture<Integer> totalLength = CompletableFuture
            .allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream()
                .map(CompletableFuture::join)
                .mapToInt(String::length)
                .sum());
        System.out.println("Total length: " + totalLength.join());
    }
}

import java.util.concurrent.CompletableFuture;

public class Task020726 {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> f1 = CompletableFuture.completedFuture(42);
        CompletableFuture<String> f2 = CompletableFuture.completedFuture("hello");
        CompletableFuture<Void> all = CompletableFuture.allOf(f1, f2);
        System.out.println(all.get());
    }
}