如何使用Java 8读取文件中两个区段间的特定行？

嘿，这个需求我之前也碰到过，Java 8里其实有不少更优雅的方式来处理这种按区段读取文件的场景，我给你梳理几个实用的方案：

方案一：Stream + 状态标记（大文件友好） #

如果你的文件比较大，优先考虑这种懒加载的方式，Files.lines()会逐行读取而不是一次性加载全部内容，内存占用很低。我们用一个布尔变量标记是否处于目标区段，逐行判断筛选：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class CurveSectionReader {
    public static void main(String[] args) {
        String filePath = "your-file-path.txt";
        List<String> curveLines = new ArrayList<>();
        boolean isInTargetSection = false;

        try {
            Files.lines(Paths.get(filePath))
                 .forEach(line -> {
                     // 进入目标区段的标记
                     if (line.startsWith("~CURVE INFORMATION")) {
                         isInTargetSection = true;
                         return; // 跳过标记行本身
                     }
                     // 退出目标区段的标记
                     if (line.startsWith("~PARAMETER INFORMATION")) {
                         isInTargetSection = false;
                         return; // 跳过结束标记行
                     }
                     // 处于目标区段时收集行
                     if (isInTargetSection) {
                         curveLines.add(line);
                     }
                 });
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 输出结果
        curveLines.forEach(System.out::println);
    }
}

这个方案逻辑直观，而且针对大文件性能表现更好，不会因为加载整个文件导致内存溢出。

方案二：函数式风格的Stream过滤（Java 8特性适配） #

如果你想更贴合Java 8的函数式编程风格，可以用AtomicBoolean来维护区段状态（避免lambda里使用可变变量的不规范写法），直接通过filter和collect完成整个流程：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;

public class FunctionalCurveReader {
    public static void main(String[] args) {
        String filePath = "your-file-path.txt";
        AtomicBoolean inCurveSection = new AtomicBoolean(false);

        try {
            List<String> curveLines = Files.lines(Paths.get(filePath))
                                           .filter(line -> {
                                               if (line.startsWith("~CURVE INFORMATION")) {
                                                   inCurveSection.set(true);
                                                   return false; // 不收集标记行
                                               }
                                               if (line.startsWith("~PARAMETER INFORMATION")) {
                                                   inCurveSection.set(false);
                                                   return false;
                                               }
                                               return inCurveSection.get();
                                           })
                                           .collect(Collectors.toList());

            curveLines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这种写法代码更简洁，完全用Stream API串联操作，符合Java 8的设计理念，而且AtomicBoolean保证了状态在并行流场景下的安全性（虽然大多数时候你可能用串行流，但这样写更规范）。

方案三：索引截取法（小文件首选） #

如果你的文件不大，一次性加载到内存完全没问题，那可以先读取所有行，然后找到两个标记行的索引，直接截取中间的内容，逻辑非常清晰：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class IndexBasedCurveReader {
    public static void main(String[] args) {
        String filePath = "your-file-path.txt";

        try {
            List<String> allLines = Files.readAllLines(Paths.get(filePath));
            int startIndex = -1;
            int endIndex = -1;

            // 遍历找到两个标记行的位置
            for (int i = 0; i < allLines.size(); i++) {
                String line = allLines.get(i);
                if (line.startsWith("~CURVE INFORMATION")) {
                    startIndex = i + 1; // 从标记行的下一行开始收集
                } else if (line.startsWith("~PARAMETER INFORMATION")) {
                    endIndex = i; // 到标记行的前一行结束
                    break; // 找到结束标记就停止遍历，提升效率
                }
            }

            // 验证索引有效性并输出结果
            if (startIndex != -1 && endIndex != -1 && startIndex < endIndex) {
                List<String> curveLines = allLines.subList(startIndex, endIndex);
                curveLines.forEach(System.out::println);
            } else {
                System.out.println("未找到目标区段，请检查标记行格式");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个方案的优势是代码逻辑一目了然，调试起来也方便，适合小文件场景，而且subList返回的是原列表的视图，不会额外占用内存。

额外小提示 #

• 如果标记行可能存在空格、大小写差异，可以先对行做trim()或者用equalsIgnoreCase()处理，比如line.trim().equalsIgnoreCase("~curve information")；
• 如果你不需要把结果存到集合，而是想直接处理每一行，可以在Stream里直接做后续操作，不需要收集到List里，进一步节省内存。

内容的提问来源于stack exchange，提问作者Shankar