Java 从字符串中获取多十进制数

对于我的一个项目，我想从一个有多个小数点的字符串中得到一个版本，是否可以将其转换为多个小数点的双精度，还是不可能。我想用这个来看看它是否比前一个更大，前一个也有多个小数

我现在用的是

if（！vers.equalsIgnoreCase（plugin.getDescription（）.getVersion（））{//Do stuff

但是我想这样做，这样我就可以做了

if（vers>plugin.getDescription（）.getVersion（））{//do stuff

vers

等于1.0.1，plugin.getDescription（）.getVersion（）等于1.0.2

---

谢谢！

您似乎想比较版本。或者根据某个字符串表示的版本做出决定。如果

plugin.getDescription（）.getVersion（）

是一个

字符串

，那么您应该能够使用一个简单的

字符串

比较来建立版本之间的顺序。类似这样的操作应该可以：

String[] numbers = version.split(".");
String[] numbers2 = version2.split(".");
int index = numbers.length-1;
while(numbers[index] != "."){
     index--;
}
String lastnumber = version.substring(index+1, numbers.length];
index = numbers2.length-1;
while(numbers2[index] != "."){
     index--;
}
String lastnumber2 = version.substring(index+1, numbers2.length];
if(lastnumber > lastnumber2){
    //later version
}else{
   //use the same thing to check the other numbers
}

String pluginVersion=plugin.getDescription().getVersion();
if (ensureValidVersion(pluginVersion) 
     && compareVersions(vers,pluginVersion)>0) {
  // do staff is vers is greater then plugin version
} 

---

ensureValidVersion

方法将验证您是否具有有效的版本号表示形式。而

compareVersions

将对每个版本子组件进行比较。

如果假设所有部分都是数字，则可以采用这种方法实现

public static int compareVersions(String vers1, String vers2) {
    String[] v1 = vers1.split("\\.");
    String[] v2 = vers2.split("\\.");
    for (int i = 0; i < v1.length && i < v2.length; i++) {
        int i1 = Integer.parseInt(v1[i]);
        int i2 = Integer.parseInt(v2[i]);
        int cmp = Integer.compare(i1, i2);
        if (cmp != 0)
            return cmp;
    }
    return Integer.compare(v1.length, v2.length);
}

印刷品

-1
1
-1

-1
1
1
-1

更复杂的版本支持版本内的字母

public static int compareVersions(String vers1, String vers2) {
    String[] v1 = vers1.split("\\.");
    String[] v2 = vers2.split("\\.");
    for (int i = 0; i < v1.length && i < v2.length; i++) {
        String [] w1 = v1[i].split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");
        String [] w2 = v2[i].split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");
        for(int j=0;j<w1.length&&j<w2.length;j++) {
            try {
                int i1 = Integer.parseInt(w1[j]);
                int i2 = 0;
                try {
                    i2 = Integer.parseInt(w2[j]);
                } catch (NumberFormatException e) {
                    return -1;
                }
                int cmp = Integer.compare(i1, i2);
                if (cmp != 0)
                    return cmp;
            } catch (NumberFormatException e) {
                try {
                    Integer.parseInt(w2[j]);
                    return +1;
                } catch (NumberFormatException e1) {
                    int cmp = w1[j].compareTo(w2[j]);
                    if (cmp != 0)
                        return cmp;
                }
            }
        }
        int cmp = Integer.compare(w1.length, w2.length);
        if (cmp != 0)
            return cmp;
    }
    return Integer.compare(v1.length, v2.length);
}

印刷品

-1
1
-1

-1
1
1
-1

---

假设您有以下形式的版本号：x.y.z
您可以使用Viacheslav Vedenin建议的类似方法：

String versionNumber = "1.3.45";
String[] singleParts = versionNumbers.split(".");

int[] versionParts = new int[singleParts.length];
for(int i=0; i<singleParts.length; i++) {
    versionParts[i] = Integer.parseInt(singleParts[i]);
}

String versionNumber=“1.3.45”；
字符串[]singleParts=versionNumbers.split（“.”）；
int[]versionParts=newint[singleParts.length]；
for（int i=0；i firstVersion.length）{
返回false；
}否则{
如果（firstVersion.length>secondVersion.length）{
返回true；
}否则{
for（int k=0；k

如果要使用相等/不等运算符比较版本（

=

，

，

=

），有两个选项

使用C++语言支持运算符重载

为

major.minor.build

中的每个字符串设置长度限制，并在比较之前将每个版本转换为整数。例如，如果每个版本的长度限制为3（即，您可以拥有的最长版本是

abc.def.ghi

），则您可以只使用

build+minor*10^3+major*10^6

或者，您可以只实现

compariable

，并拥有一个很好的OOP解决方案

public class Example {
    static class Version implements Comparable<Version> {
        private int major;
        private int minor;
        private int build;

        public Version(String s) {
            final String[] split = s.split("\\.");
            major = Integer.parseInt(split[0]);
            minor = Integer.parseInt(split[1]);
            build = Integer.parseInt(split[2]);
        }

        public int getMajor() {
            return major;
        }

        public int getMinor() {
            return minor;
        }

        public int getBuild() {
            return build;
        }

        @Override
        public int compareTo(Version v) {
            if (getMajor() < v.getMajor()) {
                return -1;
            } else if (getMajor() > v.getMajor()) {
                return 1;
            } else {
                if (getMinor() < v.getMinor()) {
                    return -1;
                } else if (getMinor() > v.getMinor()) {
                    return 1;
                } else {
                    if (getBuild() < v.getBuild()) {
                        return -1;
                    } else if (getBuild() > v.getBuild()) {
                        return 1;
                    } else {
                        return 0;
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        String s1 = "1.0.1";
        String s2 = "1.0.2";
        compare(s1, s2);
        compare(s1, s1);
        compare(s2, s2);
        compare(s2, s1);
    }

    private static void compare(String s1, String s2) {
        Version v1 = new Version(s1);
        Version v2 = new Version(s2);
        final int compareTo = v1.compareTo(v2);
        if (compareTo == -1) {
            System.out.println(s1 + " was released before " + s2);
        } else if (compareTo == 0) {
            System.out.println(s1 + " is the same as " + s2);
        } else {
            System.out.println(s1 + " was released after " + s2);
        }
    }
}

---

请添加您已经拥有的代码我还没有任何代码；我不知道如何转换它，这是我的问题让我们从您知道的开始，您可以编写hello world程序，您可以输入字符串。您可以使用

索引和
子字符串吗？您可以使用
整数.parseInt
？我认为您不理解这个问题；Integer.parseInt因小数而无法工作，indexof和substring因不会将其更改为数字变量而无法执行任何操作，因此您无法比较一个数字是否大于另一个数字。如果您知道Integer.parseInt是什么，听起来您理解了所有的谜题。您只是不知道如何使用t结合起来…我的读心术现在还不到110%。）字符串比较对数字不起作用。例如，“2”>“10”虽然这是目前为止最好的答案，但是如果第一个版本比第二个版本大，你怎么能在if语句中使用它呢。没关系，明白了。@Banjo226与compareTo（）相同大于：
>0
，大于或等于
=0
，类似于小于。
public class Example {
    static class Version implements Comparable<Version> {
        private int major;
        private int minor;
        private int build;

        public Version(String s) {
            final String[] split = s.split("\\.");
            major = Integer.parseInt(split[0]);
            minor = Integer.parseInt(split[1]);
            build = Integer.parseInt(split[2]);
        }

        public int getMajor() {
            return major;
        }

        public int getMinor() {
            return minor;
        }

        public int getBuild() {
            return build;
        }

        @Override
        public int compareTo(Version v) {
            if (getMajor() < v.getMajor()) {
                return -1;
            } else if (getMajor() > v.getMajor()) {
                return 1;
            } else {
                if (getMinor() < v.getMinor()) {
                    return -1;
                } else if (getMinor() > v.getMinor()) {
                    return 1;
                } else {
                    if (getBuild() < v.getBuild()) {
                        return -1;
                    } else if (getBuild() > v.getBuild()) {
                        return 1;
                    } else {
                        return 0;
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        String s1 = "1.0.1";
        String s2 = "1.0.2";
        compare(s1, s2);
        compare(s1, s1);
        compare(s2, s2);
        compare(s2, s1);
    }

    private static void compare(String s1, String s2) {
        Version v1 = new Version(s1);
        Version v2 = new Version(s2);
        final int compareTo = v1.compareTo(v2);
        if (compareTo == -1) {
            System.out.println(s1 + " was released before " + s2);
        } else if (compareTo == 0) {
            System.out.println(s1 + " is the same as " + s2);
        } else {
            System.out.println(s1 + " was released after " + s2);
        }
    }
}

1.0.1 was released before 1.0.2
1.0.1 is the same as 1.0.1
1.0.2 is the same as 1.0.2
1.0.2 was released after 1.0.1