В чем разница между байтовыми и файловыми потоками?

# Разница между байтовыми и файловыми потоками

Определение

Байтовые потоки (byte streams) работают с одиночными байтами или массивами байт.

Файловые потоки (file streams) это специализированные байтовые потоки для работы с файлами.

На самом деле, файловые потоки это тоже байтовые потоки, но для конкретного источника (файл). Правильнее говорить о разнице между потоками для разных источников данных.

Байтовые потоки (Byte Streams)

Байтовые потоки работают с данными на уровне отдельных байт.

import java.io.*;

public class ByteStreamExample {
    public static void main(String[] args) throws IOException {
        // InputStream - чтение
        InputStream input = new ByteArrayInputStream(
            "Hello".getBytes()
        );
        
        int data = input.read();  // Читает один байт
        while (data != -1) {
            System.out.print((char) data);
            data = input.read();
        }
        input.close();
        
        // OutputStream - запись
        OutputStream output = new ByteArrayOutputStream();
        output.write(72);  // H
        output.write(101); // e
        output.write(108); // l
        output.close();
    }
}

Иерархия:

• InputStream (абстрактный класс)
  • ByteArrayInputStream (из памяти)
  • FileInputStream (из файла)
  • PipedInputStream (из другого потока)
  • SequenceInputStream (несколько потоков)

Файловые потоки (File Streams)

Файловые потоки читают/пишут данные в файлы на диске.

import java.io.*;

public class FileStreamExample {
    public static void main(String[] args) throws IOException {
        // Чтение из файла
        FileInputStream input = new FileInputStream("data.txt");
        
        byte[] buffer = new byte[1024];
        int bytesRead = input.read(buffer);
        
        System.out.println(new String(buffer, 0, bytesRead));
        input.close();
        
        // Запись в файл
        FileOutputStream output = new FileOutputStream("output.txt");
        output.write("Hello World".getBytes());
        output.close();
    }
}

Типы файловых потоков:

• FileInputStream (чтение из файла)
• FileOutputStream (запись в файл)

Сравнение

Практический пример — байтовые потоки

import java.io.*;
import java.util.*;

public class ByteStreamUsage {
    public static void main(String[] args) throws IOException {
        // 1. ByteArrayInputStream (из памяти)
        byte[] data = {72, 101, 108, 108, 111};  // Hello
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        
        int byte1 = bais.read();
        System.out.println((char) byte1);  // H
        
        // 2. PipedInputStream/PipedOutputStream (между потоками)
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream(pos);
        
        new Thread(() -> {
            try {
                pos.write("Hello".getBytes());
                pos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
        
        // Читаем из другого потока
        byte[] buffer = new byte[5];
        pis.read(buffer);
        System.out.println(new String(buffer));
    }
}

Практический пример — файловые потоки

import java.io.*;

public class FileStreamUsage {
    public static void main(String[] args) throws IOException {
        // Запись в файл
        try (FileOutputStream fos = 
                new FileOutputStream("data.txt")) {
            String text = "Java is awesome";
            fos.write(text.getBytes());
        }
        
        // Чтение из файла
        try (FileInputStream fis = 
                new FileInputStream("data.txt")) {
            byte[] buffer = new byte[1024];
            int bytesRead = fis.read(buffer);
            
            System.out.println(new String(buffer, 0, bytesRead));
        }
    }
}

Буферизация для оптимизации

import java.io.*;

public class BufferingExample {
    public static void main(String[] args) throws IOException {
        // Медленно: без буфера, читает байт за байтом
        FileInputStream fis1 = new FileInputStream("bigfile.bin");
        int data = fis1.read();  // Одна операция диска
        fis1.close();
        
        // Быстро: с буфером, читает 8KB за раз
        FileInputStream fis2 = new FileInputStream("bigfile.bin");
        BufferedInputStream bis = new BufferedInputStream(fis2);
        byte[] buffer = new byte[8192];
        int bytesRead = bis.read(buffer);  // Одна операция диска для 8KB
        bis.close();
    }
}

Копирование файла — оптимальный способ

import java.io.*;
import java.nio.file.*;

public class FileCopy {
    public static void main(String[] args) throws IOException {
        // Вариант 1: Низкоуровневый (не рекомендуется)
        FileInputStream fis = new FileInputStream("source.txt");
        FileOutputStream fos = new FileOutputStream("dest.txt");
        int data = fis.read();
        while (data != -1) {
            fos.write(data);
            data = fis.read();  // Медленно!
        }
        fis.close();
        fos.close();
        
        // Вариант 2: С буферизацией (хорошо)
        try (BufferedInputStream bis = 
                new BufferedInputStream(new FileInputStream("source.txt"));
             BufferedOutputStream bos = 
                new BufferedOutputStream(new FileOutputStream("dest.txt"))) {
            byte[] buffer = new byte[8192];
            int bytesRead;
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }
        }
        
        // Вариант 3: Современный способ (лучше всего)
        Files.copy(Paths.get("source.txt"), 
                   Paths.get("dest.txt"),
                   StandardCopyOption.REPLACE_EXISTING);
    }
}

Иерархия потоков Java

InputStream (абстрактный)
├── ByteArrayInputStream (из памяти)
├── FileInputStream (из файла)
├── PipedInputStream (из другого потока)
├── SequenceInputStream (несколько потоков)
└── FilterInputStream
    └── BufferedInputStream (с буфером)

OutputStream (абстрактный)
├── ByteArrayOutputStream (в память)
├── FileOutputStream (в файл)
├── PipedOutputStream (в другой поток)
└── FilterOutputStream
    └── BufferedOutputStream (с буфером)

Лучшие практики

import java.io.*;

public class BestPractices {
    // 1. Всегда используй try-with-resources
    public static void readFile(String path) throws IOException {
        try (FileInputStream fis = new FileInputStream(path)) {
            byte[] buffer = new byte[1024];
            int bytesRead = fis.read(buffer);
        }
    }
    
    // 2. Используй буферизацию для больших файлов
    public static void processBigFile(String path) throws IOException {
        try (BufferedInputStream bis = 
                new BufferedInputStream(
                    new FileInputStream(path), 8192)) {
            byte[] buffer = new byte[8192];
            int bytesRead;
            while ((bytesRead = bis.read(buffer)) != -1) {
                processData(buffer, bytesRead);
            }
        }
    }
    
    // 3. Для текстовых файлов используй Reader/Writer
    public static void readTextFile(String path) throws IOException {
        try (FileReader reader = new FileReader(path);
             BufferedReader bufferedReader = 
                new BufferedReader(reader)) {
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
    
    private static void processData(byte[] data, int len) {}
}

Когда использовать

Байтовые потоки (InputStream/OutputStream)

• Бинарные данные
• Неизвестный источник
• Универсальная обработка

Файловые потоки (FileInputStream/FileOutputStream)

• Работа с файлами на диске
• Обязательно используй BufferedInputStream/OutputStream
• Для текста лучше использовать FileReader/FileWriter

Итог

• Байтовые потоки это универсальные потоки для работы с байтами
• Файловые потоки это специализированные байтовые потоки для файлов
• Файловые потоки наследуют от байтовых потоков
• Для работы с файлами всегда используй буферизацию и try-with-resources