Удастся ли сделать проход по строчкам документа при Lazy инициализации

Lazy инициализация и итерация по документам

Да, удастся, но есть важные нюансы и ограничения, которые нужно понимать. Это касается как потока данных, так и состояния инициализации. Разберемся подробно.

Принцип Lazy инициализации

Lazy инициализация — это отложенное создание объекта или загрузка данных до момента, когда они реально нужны. Это сохраняет память и время запуска.

public class Document {
    private List<String> lines;
    
    // Ленивая инициализация
    public List<String> getLines() {
        if (lines == null) {
            lines = loadLines(); // загружаем только при первом обращении
        }
        return lines;
    }
    
    private List<String> loadLines() {
        // Загружаем данные из файла/БД
        return new ArrayList<>();
    }
}

Проход по строкам через Iterator

Да, это работает отлично. Самый безопасный подход — использовать Iterator для итерации:

Document document = new Document();

Iterator<String> iterator = document.getLines().iterator();
while (iterator.hasNext()) {
    String line = iterator.next();
    System.out.println(line);
}

Ор еще лучше — enhanced for loop (работает с Iterable):

for (String line : document.getLines()) {
    System.out.println(line);
}

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

Если файл огромный, полная загрузка в память — плохая идея. Используй Stream API с ленивым чтением:

public class Document {
    private String filePath;
    
    // Возвращаем Stream для ленивой обработки
    public Stream<String> lines() throws IOException {
        return Files.lines(Paths.get(filePath));
    }
}

// Использование
Document document = new Document();
try (Stream<String> lines = document.lines()) {
    lines
        .filter(line -> !line.isEmpty())
        .map(String::trim)
        .forEach(System.out::println);
} catch (IOException e) {
    // обработка ошибки
}

Важно: Stream нужно закрывать в try-with-resources, потому что он держит открытый файл.

BufferedReader для больших файлов

Традиционный но проверенный способ:

public class Document {
    private String filePath;
    
    public void processLines(Consumer<String> processor) throws IOException {
        try (BufferedReader reader = new BufferedReader(
                new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                processor.accept(line); // обрабатываем каждую строку
            }
        }
    }
}

// Использование
Document document = new Document();
document.processLines(line -> {
    System.out.println(line.toUpperCase());
});

Этот способ:

• Не загружает весь файл в памяти
• Читает строку за строкой
• Контролирует ресурсы

Потенциальные проблемы

1. Race conditions при многопоточности

Если несколько потоков обращаются к документу одновременно:

public class Document {
    private volatile List<String> lines; // volatile важен!
    
    public synchronized List<String> getLines() {
        if (lines == null) {
            lines = loadLines();
        }
        return lines;
    }
}

Ор используй double-checked locking:

public List<String> getLines() {
    if (lines == null) {
        synchronized (this) {
            if (lines == null) {
                lines = loadLines();
            }
        }
    }
    return lines;
}

2. Modifying during iteration

Нельзя менять коллекцию во время итерации:

// ПЛОХО: ConcurrentModificationException
for (String line : document.getLines()) {
    if (line.isEmpty()) {
        document.getLines().remove(line); // падет!
    }
}

// ХОРОШО: используй Iterator явно
Iterator<String> it = document.getLines().iterator();
while (it.hasNext()) {
    String line = it.next();
    if (line.isEmpty()) {
        it.remove(); // безопасно
    }
}

Паттерн: Lazy Singleton для инициализации

Если инициализация дорогостоящая:

public class Document {
    private static class LazySingleton {
        static final List<String> LINES = loadLines();
    }
    
    public static List<String> getLines() {
        return LazySingleton.LINES;
    }
    
    private static List<String> loadLines() {
        // инициализируется только при первом обращении
        return new ArrayList<>();
    }
}

Сравнение подходов

Вывод

Да, проход по строкам при ленивой инициализации — это нормальный паттерн в Java. Главное:

1. Выбери подходящий способ загрузки (Stream, BufferedReader, Iterator)
2. Обработай потокобезопасность (volatile, synchronized)
3. Правильно управляй ресурсами (try-with-resources)
4. Не меняй коллекцию во время итерации

Это основа работы с большими объемами данных в Java.