是否有比较版本号的标准习语?我不能直接使用String compareTo,因为我还不知道点释放的最大数量是多少。我需要比较版本,并有以下保持正确:

1.0 < 1.1
1.0.1 < 1.1
1.9 < 1.10

当前回答

如果你的项目中已经有Jackson,你可以使用com.fasterxml.jackson.core.Version:

import com.fasterxml.jackson.core.Version;
import org.junit.Test;

import static org.junit.Assert.assertTrue;

public class VersionTest {

    @Test
    public void shouldCompareVersion() {
        Version version1 = new Version(1, 11, 1, null, null, null);
        Version version2 = new Version(1, 12, 1, null, null, null);
        assertTrue(version1.compareTo(version2) < 0);
    }
}

其他回答

我喜欢@Peter Lawrey的想法,我把它扩展到更远的范围:

    /**
    * Normalize string array, 
    * Appends zeros if string from the array
    * has length smaller than the maxLen.
    **/
    private String normalize(String[] split, int maxLen){
        StringBuilder sb = new StringBuilder("");
        for(String s : split) {
            for(int i = 0; i<maxLen-s.length(); i++) sb.append('0');
            sb.append(s);
        }
        return sb.toString();
    }

    /**
    * Removes trailing zeros of the form '.00.0...00'
    * (and does not remove zeros from, say, '4.1.100')
    **/
    public String removeTrailingZeros(String s){
        int i = s.length()-1;
        int k = s.length()-1;
        while(i >= 0 && (s.charAt(i) == '.' || s.charAt(i) == '0')){
          if(s.charAt(i) == '.') k = i-1;
          i--;  
        } 
        return s.substring(0,k+1);
    }

    /**
    * Compares two versions(works for alphabets too),
    * Returns 1 if v1 > v2, returns 0 if v1 == v2,
    * and returns -1 if v1 < v2.
    **/
    public int compareVersion(String v1, String v2) {

        // Uncomment below two lines if for you, say, 4.1.0 is equal to 4.1
        // v1 = removeTrailingZeros(v1);
        // v2 = removeTrailingZeros(v2);

        String[] splitv1 = v1.split("\\.");
        String[] splitv2 = v2.split("\\.");
        int maxLen = 0;
        for(String str : splitv1) maxLen = Math.max(maxLen, str.length());
        for(String str : splitv2) maxLen = Math.max(maxLen, str.length());
        int cmp = normalize(splitv1, maxLen).compareTo(normalize(splitv2, maxLen));
        return cmp > 0 ? 1 : (cmp < 0 ? -1 : 0);
    }

希望它能帮助到别人。它通过了interviewbit和leetcode中的所有测试用例(需要取消compareVersion函数中的两行注释)。

很容易测试!

想知道为什么每个人都假设版本只由整数组成-在我的情况下,它不是。

为什么要重新发明轮子(假设版本遵循Semver标准)

首先通过Maven安装https://github.com/vdurmont/semver4j

然后使用这个库

Semver sem = new Semver("1.2.3");
sem.isGreaterThan("1.2.2"); // true

我写了一个名为MgntUtils的开源库,它有一个用于字符串版本的实用程序。它正确地比较它们,适用于版本范围等等。下面是这个库javadoc参见方法TextUtils.comapreVersions(…)它已经被大量使用并经过了良好的测试。下面这篇文章描述了这个库以及如何获取它。它可以作为Maven工件和在github上获得(包括源代码和JavaDoc)

public static int compareVersions(String version1, String version2){

    String[] levels1 = version1.split("\\.");
    String[] levels2 = version2.split("\\.");

    int length = Math.max(levels1.length, levels2.length);
    for (int i = 0; i < length; i++){
        Integer v1 = i < levels1.length ? Integer.parseInt(levels1[i]) : 0;
        Integer v2 = i < levels2.length ? Integer.parseInt(levels2[i]) : 0;
        int compare = v1.compareTo(v2);
        if (compare != 0){
            return compare;
        }
    }

    return 0;
}

我现在就做了,然后问自己,这对吗?因为我从来没有找到过比我的更干净的解决方案

你只需要像下面这样拆分字符串版本("1.0.0"):

userVersion.split("\\.")

那么你将得到:{"1","0","0"}

现在,用我做过的方法

isUpdateAvailable(userVersion.split("\\."), latestVersionSplit.split("\\."));

方法:

/**
 * Compare two versions
 *
 * @param userVersionSplit   - User string array with major, minor and patch version from user (exemple: {"5", "2", "70"})
 * @param latestVersionSplit - Latest string array with major, minor and patch version from api (example: {"5", "2", "71"})
 * @return true if user version is smaller than latest version
 */
public static boolean isUpdateAvailable(String[] userVersionSplit, String[] latestVersionSplit) {

    try {
        int majorUserVersion = Integer.parseInt(userVersionSplit[0]);
        int minorUserVersion = Integer.parseInt(userVersionSplit[1]);
        int patchUserVersion = Integer.parseInt(userVersionSplit[2]);

        int majorLatestVersion = Integer.parseInt(latestVersionSplit[0]);
        int minorLatestVersion = Integer.parseInt(latestVersionSplit[1]);
        int patchLatestVersion = Integer.parseInt(latestVersionSplit[2]);

        if (majorUserVersion <= majorLatestVersion) {
            if (majorUserVersion < majorLatestVersion) {
                return true;
            } else {
                if (minorUserVersion <= minorLatestVersion) {
                    if (minorUserVersion < minorLatestVersion) {
                        return true;
                    } else {
                        return patchUserVersion < patchLatestVersion;
                    }
                }
            }
        }
    } catch (Exception ignored) {
        // Will be throw only if the versions pattern is different from "x.x.x" format
        // Will return false at the end
    }

    return false;
}

等待任何反馈:)