如何在Java中不使用grep或split高效提取文件中的变量与值？

需要从包含数千行的大文件中提取变量及其值，文件每行可能缺失部分字段，示例行格式如student name=james age=13 city=toronto，需映射至已定义的MyPOJO类的type、name、age、city字段。当前采用String.split实现，寻求更高效方案，且因文件内容可能变动，不使用grep。

示例文件内容 #

student name=james age=13 city=toronto
teacher name=joe age=31 city=chicago
student age=21 city=paris

MyPOJO类代码 #

public class MyPOJO {
    private String type;
    private String name;
    private int age;
    private String city;

    public MyPOJO(String type, String name, int age, String city) {
        this.type = type;
        this.name = name;
        this.age = age;
        this.city = city;
    }
    //Getters and setters below
}

当前实现代码 #

public MyPOJO extract(String line){
    String[] split = line.split(" ");
    String type, name, city;
    int age;
    type = split[0];
    for(String s : split){
        if(s.contains("name")){
            name = s.split("=")[1];
        }
        if(s.contains("city")){
            city = s.split("=")[1];
        }
        if(s.contains("age")){
            age = Integer.parseInt(s.split("=")[1]);
        }
    }
}

1. 预编译正则表达式（高效且灵活） #

正则可一次性匹配行内所有键值对，预编译后复用能大幅提升大文件处理效率，同时天然适配字段缺失的场景。

先定义全局预编译的Pattern：

private static final Pattern FIELD_PATTERN = Pattern.compile("(\\w+)(?:=(\\S+))?");

提取逻辑实现：

public MyPOJO extract(String line) {
    String type = null;
    String name = "";
    int age = -1;
    String city = "";

    Matcher matcher = FIELD_PATTERN.matcher(line);
    if (matcher.find()) {
        // 第一个匹配项是type（无=的字段）
        type = matcher.group(1);
    }

    // 遍历匹配剩余键值对
    while (matcher.find()) {
        String key = matcher.group(1);
        String value = matcher.group(2);
        switch (key) {
            case "name":
                name = value;
                break;
            case "age":
                if (value != null) {
                    age = Integer.parseInt(value);
                }
                break;
            case "city":
                city = value;
                break;
        }
    }

    return new MyPOJO(type, name, age, city);
}

2. 使用StringTokenizer替代split（降低内存开销） #

String.split每次调用都会创建字符串数组，处理大量行时内存开销较高；StringTokenizer是轻量的字符串分割工具，逐段解析时内存占用更低。

实现代码：

public MyPOJO extract(String line) {
    StringTokenizer tokenizer = new StringTokenizer(line);
    String type = tokenizer.nextToken(); // 第一个token固定为type
    String name = "";
    int age = -1;
    String city = "";

    while (tokenizer.hasMoreTokens()) {
        String token = tokenizer.nextToken();
        int eqPos = token.indexOf('=');
        if (eqPos == -1) {
            continue; // 容错处理非键值对格式的token
        }
        String key = token.substring(0, eqPos);
        String value = token.substring(eqPos + 1);
        switch (key) {
            case "name":
                name = value;
                break;
            case "age":
                age = Integer.parseInt(value);
                break;
            case "city":
                city = value;
                break;
        }
    }

    return new MyPOJO(type, name, age, city);
}

关键优化点说明 #

• 修复原始代码问题：原始代码未处理字段缺失的情况，会导致变量未初始化报错，优化后的代码都添加了默认值兜底，避免空指针或编译错误。
• 性能提升：正则预编译方案减少了多次split操作的字符串开销；StringTokenizer则避免了数组创建，内存占用更低，适合大文件批量处理。
• 扩展性：后续新增字段时，只需修改switch分支（正则方案无需修改匹配规则），能适配文件内容变动的需求。

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