如何在Java中拆分解析文本文件生成Message对象的ArrayList

嘿，这个文本提取的需求我帮你捋清楚，两种实用的实现思路给你参考，都能搞定从文件生成Message列表的问题～

思路一：一次性读取文件，按消息分隔符#拆分 #

这种方式代码简洁，适合文件不大的场景，一次性把文件内容读入内存后拆分处理：

完整代码示例 #

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

public class MessageParser {

    public static List<Message> parseMessagesFromFile(String filePath) throws IOException {
        List<Message> messages = new ArrayList<>();
        // 读取整个文件内容（小文件推荐）
        String fileContent = Files.readString(Paths.get(filePath));
        
        // 按#分割成单个消息块，过滤掉空块（比如文件末尾的#会产生空字符串）
        String[] messageBlocks = fileContent.split("#");
        for (String block : messageBlocks) {
            String trimmedBlock = block.trim();
            if (trimmedBlock.isEmpty()) {
                continue;
            }
            // 解析单个消息块
            Message msg = parseSingleMessageBlock(trimmedBlock);
            if (msg != null) {
                messages.add(msg);
            }
        }
        return messages;
    }

    private static Message parseSingleMessageBlock(String block) {
        // 用正则精准匹配From和To行，支持行首的空格和冒号后的任意空格
        Pattern fromPattern = Pattern.compile("^From:\\s*(.+)$", Pattern.MULTILINE);
        Pattern toPattern = Pattern.compile("^To:\\s*(.+)$", Pattern.MULTILINE);
        
        Matcher fromMatcher = fromPattern.matcher(block);
        Matcher toMatcher = toPattern.matcher(block);
        
        String from = fromMatcher.find() ? fromMatcher.group(1).trim() : null;
        String to = toMatcher.find() ? toMatcher.group(1).trim() : null;
        
        // 如果缺少From或To，跳过这条无效消息
        if (from == null || to == null) {
            return null;
        }
        
        // 提取消息体：移除From和To行，整理格式（这里把多行body合并成一行，要保留换行就去掉replaceAll）
        String body = block.replaceFirst("^From:\\s*.+$", "")
                           .replaceFirst("^To:\\s*.+$", "")
                           .trim()
                           .replaceAll("\\n+", " ");
        
        return new Message(from, to, body);
    }

    public static void main(String[] args) {
        try {
            List<Message> messages = parseMessagesFromFile("your_messages.txt");
            System.out.println("成功解析 " + messages.size() + " 条消息");
            // 如果你给Message加了getter，可以打印详情
            // messages.forEach(msg -> System.out.println("From: " + msg.getFrom() + ", To: " + msg.getTo() + ", Body: " + msg.getBody()));
        } catch (IOException e) {
            System.err.println("读取文件出错：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

关键步骤说明 #

1. 读取文件：用Files.readString一次性读取整个文件，代码简洁。
2. 拆分消息块：用#分割内容，过滤空块避免无效处理。
3. 解析单个消息：用正则匹配From:和To:行，准确提取发送者和接收者；剩下的内容就是消息体，按需整理格式（合并多行或保留换行）。

思路二：逐行读取文件，按状态处理 #

如果你的文件很大，一次性加载到内存会占用太多资源，推荐用这种逐行处理的方式，内存占用更低：

完整代码示例 #

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class MessageLineParser {

    public static List<Message> parseMessagesFromFile(String filePath) throws IOException {
        List<Message> messages = new ArrayList<>();
        BufferedReader reader = new BufferedReader(new FileReader(filePath));
        
        String line;
        String currentFrom = null;
        String currentTo = null;
        StringBuilder currentBody = new StringBuilder();
        
        while ((line = reader.readLine()) != null) {
            String trimmedLine = line.trim();
            if (trimmedLine.isEmpty()) {
                continue; // 跳过空行
            }
            
            if (trimmedLine.equals("#")) {
                // 遇到消息结束符，构造Message并重置状态
                if (currentFrom != null && currentTo != null && currentBody.length() > 0) {
                    messages.add(new Message(currentFrom, currentTo, currentBody.toString().trim()));
                }
                currentFrom = null;
                currentTo = null;
                currentBody.setLength(0);
            } else if (trimmedLine.startsWith("From:")) {
                // 提取发送者
                currentFrom = trimmedLine.substring("From:".length()).trim();
            } else if (trimmedLine.startsWith("To:")) {
                // 提取接收者
                currentTo = trimmedLine.substring("To:".length()).trim();
            } else {
                // 追加消息体内容（要保留换行就加"\n"，这里用空格连接）
                if (currentBody.length() > 0) {
                    currentBody.append(" ");
                }
                currentBody.append(trimmedLine);
            }
        }
        reader.close();
        return messages;
    }

    public static void main(String[] args) {
        try {
            List<Message> messages = parseMessagesFromFile("large_messages.txt");
            System.out.println("成功解析 " + messages.size() + " 条消息");
        } catch (IOException e) {
            System.err.println("读取文件出错：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

关键步骤说明 #

1. 逐行读取：用BufferedReader逐行读取，避免一次性加载大文件。
2. 状态跟踪：通过变量记录当前是否在读取发送者、接收者或消息体，遇到#就完成当前消息的构造并重置状态。
3. 容错处理：跳过空行，确保只有完整的消息（包含From、To和Body）才会被加入列表。

额外建议 #

1. 给你的Message类添加getter方法，方便后续访问属性，比如：

public String getFrom() { return from; }
public String getTo() { return to; }
public String getBody() { return body; }

2. 如果文件有特殊编码（比如UTF-8），读取时指定编码，比如Files.readString(Paths.get(filePath), StandardCharsets.UTF_8)或new FileReader(filePath, StandardCharsets.UTF_8)。
3. 可以添加日志或错误提示，比如记录格式无效的消息块，方便调试。

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