Какие знаешь способы чтения из файла?

Способы чтения из файла в Java

Зависит от типа файла (текст, бинарный), размера и требований производительности. Рассмотрим все основные способы.

1. FileReader и BufferedReader (строка за строкой)

Одна из самых распространённых техник для текстовых файлов:

// ✅ Правильно: try-with-resources (автоматическое закрытие)
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.err.println("Ошибка чтения файла: " + e.getMessage());
}

// ❌ Неправильно: забыли закрыть файл (утечка ресурсов)
BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
String line = reader.readLine();
system.out.println(line);
// reader не закрыт!

BufferedReader кэширует данные, поэтому быстрее, чем просто FileReader.

2. Files.readAllLines (весь файл в список)

Для небольших файлов когда нужны все строки сразу:

import java.nio.file.Files;
import java.nio.file.Paths;

try {
    // Читаем все строки в список
    List<String> lines = Files.readAllLines(Paths.get("file.txt"));
    
    // Обрабатываем
    for (String line : lines) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.err.println("Ошибка: " + e.getMessage());
}

// С кодировкой
List<String> lines = Files.readAllLines(
    Paths.get("file.txt"), 
    StandardCharsets.UTF_8
);

⚠️ Осторожно: если файл очень большой (100+ MB), весь файл загружается в память.

3. Files.readString (весь файл как одна строка)

Для небольших текстовых файлов:

import java.nio.file.Files;
import java.nio.file.Paths;

try {
    // Java 11+
    String content = Files.readString(Paths.get("file.txt"), StandardCharsets.UTF_8);
    System.out.println(content);
} catch (IOException e) {
    e.printStackTrace();
}

4. Files.lines (Stream для больших файлов)

Для больших файлов, обработка строка за строкой, ленивая загрузка:

import java.nio.file.Files;
import java.nio.file.Paths;

try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
    lines
        .filter(line -> !line.isEmpty())  // Пропускаем пустые
        .map(String::trim)                // Убираем пробелы
        .forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

// С фильтром
try (Stream<String> lines = Files.lines(Paths.get("data.csv"))) {
    int count = (int) lines
        .filter(line -> line.startsWith("error"))
        .count();
    System.out.println("Ошибок: " + count);
} catch (IOException e) {
    e.printStackTrace();
}

Преимущества Stream:

• Ленивая обработка (не загружаем весь файл)
• Функциональный стиль
• Возможность parallelStream() для параллельной обработки

5. InputStreamReader (с контролем кодировки)

Для точного управления кодировкой:

try (InputStreamReader reader = new InputStreamReader(
        new FileInputStream("file.txt"), 
        StandardCharsets.UTF_8)) {
    
    try (BufferedReader buffered = new BufferedReader(reader)) {
        String line;
        while ((line = buffered.readLine()) != null) {
            System.out.println(line);
        }
    }
} catch (IOException e) {
    e.printStackTrace();
}

6. Scanner (для парсинга структурированного контента)

Удобно для чтения числовых данных или полей разделённых символами:

try (Scanner scanner = new Scanner(new File("data.txt"))) {
    // Построчно
    while (scanner.hasNextLine()) {
        String line = scanner.nextLine();
        System.out.println(line);
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

// Для чисел
try (Scanner scanner = new Scanner(new File("numbers.txt"))) {
    while (scanner.hasNextInt()) {
        int number = scanner.nextInt();
        System.out.println("Число: " + number);
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

// Для парсинга CSV
try (Scanner scanner = new Scanner(new File("data.csv"))) {
    scanner.useDelimiter(",");  // CSV разделитель
    while (scanner.hasNext()) {
        String field = scanner.next();
        System.out.println(field);
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

7. RandomAccessFile (доступ по позиции)

Для файлов где нужен доступ к любой позиции:

try (RandomAccessFile file = new RandomAccessFile("data.bin", "r")) {
    // Перемещаемся на позицию 100
    file.seek(100);
    
    // Читаем данные
    byte[] buffer = new byte[1024];
    int bytesRead = file.read(buffer);
    
    System.out.println("Прочитано байт: " + bytesRead);
} catch (IOException e) {
    e.printStackTrace();
}

// Чтение определённых типов
try (RandomAccessFile file = new RandomAccessFile("data.bin", "r")) {
    int intValue = file.readInt();
    long longValue = file.readLong();
    String stringValue = file.readUTF();
    
    System.out.println("Int: " + intValue);
    System.out.println("Long: " + longValue);
    System.out.println("String: " + stringValue);
} catch (IOException e) {
    e.printStackTrace();
}

8. FileInputStream (для бинарных файлов)

Для непосредственного чтения байтов:

try (FileInputStream fis = new FileInputStream("image.png")) {
    byte[] buffer = new byte[1024];
    int bytesRead;
    
    while ((bytesRead = fis.read(buffer)) != -1) {
        System.out.println("Прочитано " + bytesRead + " байт");
        // Обработать buffer
    }
} catch (IOException e) {
    e.printStackTrace();
}

// Чтение всех байтов
try {
    byte[] allBytes = Files.readAllBytes(Paths.get("image.png"));
    System.out.println("Размер: " + allBytes.length);
} catch (IOException e) {
    e.printStackTrace();
}

9. Java NIO (Channel и Buffer)

Для высокопроизводительного чтения больших файлов:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.channels.FileChannel;
import java.nio.ByteBuffer;

try (FileChannel channel = FileChannel.open(Path.of("largefile.bin"))) {
    ByteBuffer buffer = ByteBuffer.allocate(8192);  // 8KB буфер
    
    while (channel.read(buffer) > 0) {
        buffer.flip();  // Переключаем режим чтения
        
        while (buffer.hasRemaining()) {
            byte b = buffer.get();
            // Обработать байт
        }
        
        buffer.clear();  // Очищаем для следующих данных
    }
} catch (IOException e) {
    e.printStackTrace();
}

// Более удобно с Files.readAllBytes
try {
    byte[] data = Files.readAllBytes(Path.of("file.bin"));
} catch (IOException e) {
    e.printStackTrace();
}

10. Чтение JSON файлов

С использованием Jackson:

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;

public class JsonReader {
    public static void main(String[] args) {
        ObjectMapper mapper = new ObjectMapper();
        
        try {
            // Чтение в объект
            User user = mapper.readValue(
                new File("user.json"),
                User.class
            );
            System.out.println(user);
            
            // Чтение в Map
            Map<String, Object> map = mapper.readValue(
                new File("config.json"),
                new TypeReference<Map<String, Object>>() {}
            );
            
            // Чтение в List
            List<User> users = mapper.readValue(
                new File("users.json"),
                new TypeReference<List<User>>() {}
            );
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Либо с Gson:

import com.google.gson.Gson;
import java.nio.file.Files;
import java.nio.file.Paths;

Gson gson = new Gson();
String json = Files.readString(Paths.get("user.json"));
User user = gson.fromJson(json, User.class);

11. Чтение CSV файлов

С OpenCSV:

import com.opencsv.CSVReader;
import java.io.FileReader;

try (CSVReader reader = new CSVReader(new FileReader("data.csv"))) {
    List<String[]> records = reader.readAll();
    
    for (String[] record : records) {
        System.out.println("Поля: " + Arrays.toString(record));
    }
} catch (Exception e) {
    e.printStackTrace();
}

// Построчное чтение
try (CSVReader reader = new CSVReader(new FileReader("data.csv"))) {
    String[] record;
    while ((record = reader.readNext()) != null) {
        String name = record[0];
        String email = record[1];
        System.out.println(name + " - " + email);
    }
} catch (Exception e) {
    e.printStackTrace();
}

12. Параллельное чтение (parallelStream)

Для обработки больших файлов:

try (Stream<String> lines = Files.lines(Paths.get("largefile.txt"))) {
    int wordCount = (int) lines
        .parallel()  // Параллельная обработка
        .map(line -> line.split("\\s+"))
        .mapToInt(words -> words.length)
        .sum();
    
    System.out.println("Слов: " + wordCount);
} catch (IOException e) {
    e.printStackTrace();
}

Выбор метода чтения

Best Practices

// ✅ Всегда используй try-with-resources
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    // Файл автоматически закроется
} catch (IOException e) {
    // Обработка ошибок
}

// ✅ Для текста до 100 MB
List<String> lines = Files.readAllLines(Paths.get("file.txt"));

// ✅ Для больших файлов
try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
    lines.forEach(System.out::println);
}

// ❌ Не забывай про кодировку
Files.readString(Paths.get("file.txt"), StandardCharsets.UTF_8);

// ❌ Избегай утечек ресурсов
BufferedReader reader = new BufferedReader(...);  // Плохо
BufferedReader reader = new BufferedReader(...);  // Хорошо (try-with-resources)