Java技术实现：从字符串列表中查找命名最相似的字符串

需求明确 #

给定文件名列表：

AppName-ver-1.1.0-data.exe
AppName-ver-1.1.1-secondData.exe
AppName-ver-1.2.0-data.exe
AppName-ver-1.2.1-data.exe
AppName-ver-1.2.3-data.exe
AnotherAppName-ver-1.0.0-data.exe
AnotherAppName-ver-1.0.0-secondData.exe

要找到与目标字符串AppName-ver-1.2.4-data.exe按命名规则最相似的文件，预期结果为AppName-ver-1.2.3-data.exe。这里的"相似"定义为：

• 应用名、数据类型、后缀完全匹配（即同属AppName的data类型exe文件）
• 在匹配规则的前提下，版本号与目标版本最接近

高效实现思路 #

核心逻辑是先过滤符合规则的候选集，再比较版本号找最接近的目标，避免无意义的全局比较，步骤如下：

1. 定义命名规则正则
   用正则表达式解析文件名结构：^([^-]+)-ver-(\d+\.\d+\.\d+)-([^.]+)\.exe$，拆分出三个关键部分：

   • 分组1：应用名（如AppName）
   • 分组2：版本号（如1.2.3）
   • 分组3：数据类型（如data）

2. 过滤候选文件
   遍历文件名列表，只保留与目标文件的应用名、数据类型、后缀完全一致的文件，缩小处理范围。

3. 版本号解析与比较
   将版本号拆分为整数数组（如1.2.3转成[1,2,3]），通过权重计算版本差值（大版本差异权重高于小版本），找到差值最小的版本。若存在多个同差值的情况，优先选择更接近目标的版本（如目标是1.2.4时，优先选1.2.3而非1.2.1）。

具体Java代码示例 #

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ClosestFileNameMatcher {
    public static void main(String[] args) {
        List<String> fileNames = List.of(
                "AppName-ver-1.1.0-data.exe",
                "AppName-ver-1.1.1-secondData.exe",
                "AppName-ver-1.2.0-data.exe",
                "AppName-ver-1.2.1-data.exe",
                "AppName-ver-1.2.3-data.exe",
                "AnotherAppName-ver-1.0.0-data.exe",
                "AnotherAppName-ver-1.0.0-secondData.exe"
        );
        String target = "AppName-ver-1.2.4-data.exe";

        System.out.println(findClosestMatch(fileNames, target));
    }

    private static String findClosestMatch(List<String> fileNames, String target) {
        Pattern pattern = Pattern.compile("^([^-]+)-ver-(\\d+\\.\\d+\\.\\d+)-([^.]+)\\.exe$");
        Matcher targetMatcher = pattern.matcher(target);
        if (!targetMatcher.find()) {
            return null;
        }

        String targetApp = targetMatcher.group(1);
        int[] targetVersion = parseVersion(targetMatcher.group(2));
        String targetDataType = targetMatcher.group(3);

        String closestMatch = null;
        int[] closestVersion = null;
        int minDiff = Integer.MAX_VALUE;

        for (String fileName : fileNames) {
            Matcher fileMatcher = pattern.matcher(fileName);
            if (!fileMatcher.find()) {
                continue;
            }

            String app = fileMatcher.group(1);
            String dataType = fileMatcher.group(3);
            if (!app.equals(targetApp) || !dataType.equals(targetDataType)) {
                continue;
            }

            int[] version = parseVersion(fileMatcher.group(2));
            int diff = calculateVersionDiff(targetVersion, version);

            if (diff < minDiff || (diff == minDiff && isVersionHigher(version, closestVersion))) {
                minDiff = diff;
                closestMatch = fileName;
                closestVersion = version;
            }
        }
        return closestMatch;
    }

    private static int[] parseVersion(String versionStr) {
        String[] parts = versionStr.split("\\.");
        int[] version = new int[3];
        for (int i = 0; i < 3; i++) {
            version[i] = Integer.parseInt(parts[i]);
        }
        return version;
    }

    private static int calculateVersionDiff(int[] target, int[] candidate) {
        int majorDiff = Math.abs(target[0] - candidate[0]) * 10000;
        int minorDiff = Math.abs(target[1] - candidate[1]) * 100;
        int patchDiff = Math.abs(target[2] - candidate[2]);
        return majorDiff + minorDiff + patchDiff;
    }

    private static boolean isVersionHigher(int[] candidate, int[] current) {
        if (current == null) return true;
        if (candidate[0] != current[0]) return candidate[0] > current[0];
        if (candidate[1] != current[1]) return candidate[1] > current[1];
        return candidate[2] > current[2];
    }
}

方法优势 #

• 高效性：通过正则过滤快速缩小候选集，避免对所有文件做全量版本比较，整体时间复杂度为O(n)（n为文件总数），适合处理大量文件的场景。
• 准确性：通过版本号权重计算差值，确保大版本差异优先于小版本，符合软件版本的命名逻辑。

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