blocks|key|1502977|text|使用点作为分隔符对字符串进行标记化，然后从左开始并排比较整数转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1502978|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Tokenize the strings with the dot as delimiter and then compare the integer translation side by side, beginning from the left.

blocks|key|1503030|text|使用Maven真的很容易：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503031|import+org.apache.maven.artifact.versioning.DefaultArtifactVersion;

DefaultArtifactVersion+minVersion+=+new+DefaultArtifactVersion("1.0.1");
DefaultArtifactVersion+maxVersion+=+new+DefaultArtifactVersion("1.10");

DefaultArtifactVersion+version+=+new+DefaultArtifactVersion("1.11");

if+(version.compareTo(minVersion)+<+0+%7C%7C+version.compareTo(maxVersion)+>+0)+{
++++System.out.println("Sorry,+your+version+is+unsupported");
}|code-block|syntax|javascript|1503032|您可以从this+page获取正确的Maven工件的依赖项字符串|offset|length|1503033|<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-artifact</artifactId>
<version>3.0.3</version>
</dependency>|1503034|entityMap|0|LINK|mutability|MUTABLE|url|http://mvnrepository.com/artifact/org.apache.maven/maven-artifact/3.0.3^0|0|0|4|9|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

It's really easy using Maven:

<pre><code>import org.apache.maven.artifact.versioning.DefaultArtifactVersion;

DefaultArtifactVersion minVersion = new DefaultArtifactVersion("1.0.1");
DefaultArtifactVersion maxVersion = new DefaultArtifactVersion("1.10");

DefaultArtifactVersion version = new DefaultArtifactVersion("1.11");

if (version.compareTo(minVersion) &lt; 0 || version.compareTo(maxVersion) &gt; 0) {
 System.out.println("Sorry, your version is unsupported");
}
</code></pre>

You can get the right dependency string for Maven Artifact from <a href="http://mvnrepository.com/artifact/org.apache.maven/maven-artifact/3.0.3" rel="noreferrer">this page</a>:

<pre><code>&lt;dependency&gt;
&lt;groupId&gt;org.apache.maven&lt;/groupId&gt;
&lt;artifactId&gt;maven-artifact&lt;/artifactId&gt;
&lt;version&gt;3.0.3&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>

blocks|key|1503278|text|想知道为什么每个人都认为版本只由整数组成--在我的例子中并非如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503279|为什么要重新发明轮子(假设版本遵循Semver标准)|1503280|首先通过Maven安装https://github.com/vdurmont/semver4j|offset|length|1503281|然后使用这个库|1503282|Semver+sem+=+new+Semver("1.2.3");
sem.isGreaterThan("1.2.2");+//+true|code-block|syntax|javascript|1503283|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/vdurmont/semver4j^0|0|0|B|10|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Wondering why everybody assumes that the versions is only made up of integers - in my case it was not.

Why reinventing the wheel (assuming the version follows the Semver standard)

First install <a href="https://github.com/vdurmont/semver4j" rel="noreferrer">https://github.com/vdurmont/semver4j</a> via Maven

Then use this library

<pre><code>Semver sem = new Semver("1.2.3");
sem.isGreaterThan("1.2.2"); // true
</code></pre>

blocks|key|1504048|text|使用Java9的own+builtin+Version+class|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1504049|import+java.util.*;
import+java.lang.module.ModuleDescriptor.Version;
class+Main+{
++public+static+void+main(String[]+args)+{
++++var+versions+=+Arrays.asList(
++++++"1.0.2",
++++++"1.0.0-beta.2",
++++++"1.0.0",
++++++"1.0.0-beta",
++++++"1.0.0-alpha.12",
++++++"1.0.0-beta.11",
++++++"1.0.1",
++++++"1.0.11",
++++++"1.0.0-rc.1",
++++++"1.0.0-alpha.1",
++++++"1.1.0",
++++++"1.0.0-alpha.beta",
++++++"1.11.0",
++++++"1.0.0-alpha.12.ab-c",
++++++"0.0.1",
++++++"1.2.1",
++++++"1.0.0-alpha",
++++++"1.0.0.1",++//+Also+works+with+a+number+of+sections+different+than+3
++++++"1.0.0.2",
++++++"2",
++++++"10",
++++++"1.0.0.10"
++++);
++++versions.stream()
++++++.map(Version::parse)
++++++.sorted()
++++++.forEach(System.out::println);
++}
}|code-block|syntax|javascript|1504050|Try+it+online!|1504051|输出：|1504052|0.0.1
1.0.0-alpha
1.0.0-alpha.1
1.0.0-alpha.12
1.0.0-alpha.12.ab-c
1.0.0-alpha.beta
1.0.0-beta
1.0.0-beta.2
1.0.0-beta.11
1.0.0-rc.1
1.0.0
1.0.0.1
1.0.0.2
1.0.0.10
1.0.1
1.0.2
1.0.11
1.1.0
1.2.1
1.11.0
2
10|1504053|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/9/docs/api/java/lang/module/ModuleDescriptor.Version.html|1|https://tio.run/##dZI9b8JADIb3/AqLKVTlyNEN1AGp3cqE1KXq4CQXcnC5i@xLEKr47WkaUAkBJsuvH3/I9hZrnGzTXdPoonTkYdsKovLaiKdF0NcM2o0oXFoZJVadeVOckC69I/GpiLWziyAxyAwr1BZ@AoCyio1OgD361tROp1C0sXDtSdvN1zcgbXjcoQA1EtSnQgyvsCTCAwvkD80@7AiAkRSRmI2e@240iZXHG/UeNNTQlDkKeb@glNfy0JXDLEqEfNChL8vb2U7UcEL5kJQzgfEkuQSj4XyzB6MMxD8KYDqFpWEHe0c7hr32OSDYqogVgcuAVeK7o6Q6yxQp68HnaOHlulRvi/2FRjcto1EnjBens59PLtiTwiIcn2lRYBmeH2s@L5FY/Ye4fUuVXtDM0Tsmebg@sFeFcJVvM9oX88Z2XY7BsWl@AQ^0|K|7|8|P|0|0|0|0|E|1|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

<h1>Use Java 9's <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/module/ModuleDescriptor.Version.html" rel="noreferrer">own builtin <code>Version</code> class</a></h1>
<pre><code>import java.util.*;
import java.lang.module.ModuleDescriptor.Version;
class Main {
 public static void main(String[] args) {
 var versions = Arrays.asList(
 &quot;1.0.2&quot;,
 &quot;1.0.0-beta.2&quot;,
 &quot;1.0.0&quot;,
 &quot;1.0.0-beta&quot;,
 &quot;1.0.0-alpha.12&quot;,
 &quot;1.0.0-beta.11&quot;,
 &quot;1.0.1&quot;,
 &quot;1.0.11&quot;,
 &quot;1.0.0-rc.1&quot;,
 &quot;1.0.0-alpha.1&quot;,
 &quot;1.1.0&quot;,
 &quot;1.0.0-alpha.beta&quot;,
 &quot;1.11.0&quot;,
 &quot;1.0.0-alpha.12.ab-c&quot;,
 &quot;0.0.1&quot;,
 &quot;1.2.1&quot;,
 &quot;1.0.0-alpha&quot;,
 &quot;1.0.0.1&quot;, // Also works with a number of sections different than 3
 &quot;1.0.0.2&quot;,
 &quot;2&quot;,
 &quot;10&quot;,
 &quot;1.0.0.10&quot;
 );
 versions.stream()
 .map(Version::parse)
 .sorted()
 .forEach(System.out::println);
 }
}
</code></pre>
<a href="https://tio.run/##dZI9b8JADIb3/AqLKVTlyNEN1AGp3cqE1KXq4CQXcnC5i@xLEKr47WkaUAkBJsuvH3/I9hZrnGzTXdPoonTkYdsKovLaiKdF0NcM2o0oXFoZJVadeVOckC69I/GpiLWziyAxyAwr1BZ@AoCyio1OgD361tROp1C0sXDtSdvN1zcgbXjcoQA1EtSnQgyvsCTCAwvkD80@7AiAkRSRmI2e@240iZXHG/UeNNTQlDkKeb@glNfy0JXDLEqEfNChL8vb2U7UcEL5kJQzgfEkuQSj4XyzB6MMxD8KYDqFpWEHe0c7hr32OSDYqogVgcuAVeK7o6Q6yxQp68HnaOHlulRvi/2FRjcto1EnjBens59PLtiTwiIcn2lRYBmeH2s@L5FY/Ye4fUuVXtDM0Tsmebg@sFeFcJVvM9oX88Z2XY7BsWl@AQ" rel="noreferrer" title="Java (JDK) – Try It Online">Try it online!</a>
Output:
<pre class="lang-text prettyprint-override"><code>0.0.1
1.0.0-alpha
1.0.0-alpha.1
1.0.0-alpha.12
1.0.0-alpha.12.ab-c
1.0.0-alpha.beta
1.0.0-beta
1.0.0-beta.2
1.0.0-beta.11
1.0.0-rc.1
1.0.0
1.0.0.1
1.0.0.2
1.0.0.10
1.0.1
1.0.2
1.0.11
1.1.0
1.2.1
1.11.0
2
10
</code></pre>

blocks|key|1718221|text|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%2B%2B){
++++++++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;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1718222|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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 &lt; length; i++){
 Integer v1 = i &lt; levels1.length ? Integer.parseInt(levels1[i]) : 0;
 Integer v2 = i &lt; levels2.length ? Integer.parseInt(levels2[i]) : 0;
 int compare = v1.compareTo(v2);
 if (compare != 0){
 return compare;
 }
 }

 return 0;
}
</code></pre>

blocks|key|1718638|text|如果你的项目中已经有了杰克逊，你可以使用com.fasterxml.jackson.core.Version|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1718639|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);
++++}
}|code-block|syntax|javascript|1718640|entityMap^0|K|Y|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If you already have Jackson in your project, you can use <code>com.fasterxml.jackson.core.Version</code>:

<pre><code>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) &lt; 0);
 }
}
</code></pre>

blocks|key|1503936|text|@alex's+post+on+Kotlin|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1503937|class+Version(inputVersion:+String)+:+Comparable<Version>+{

++++++++var+version:+String
++++++++++++private+set

++++++++override+fun+compareTo(other:+Version)+=
++++++++++++(split()+to+other.split()).let+{(thisParts,+thatParts)->
++++++++++++++++val+length+=+max(thisParts.size,+thatParts.size)
++++++++++++++++for+(i+in+0+until+length)+{
++++++++++++++++++++val+thisPart+=+if+(i+<+thisParts.size)+thisParts[i].toInt()+else+0
++++++++++++++++++++val+thatPart+=+if+(i+<+thatParts.size)+thatParts[i].toInt()+else+0
++++++++++++++++++++if+(thisPart+<+thatPart)+return+-1
++++++++++++++++++++if+(thisPart+>+thatPart)+return+1
++++++++++++++++}
+++++++++++++++++0
++++++++++++}

++++++++init+{
++++++++++++require(inputVersion.matches("[0-9]%2B(\\.[0-9]%2B)*".toRegex()))+{+"Invalid+version+format"+}
++++++++++++version+=+inputVersion
++++++++}
++++}

++++fun+Version.split()+=+version.split(".").toTypedArray()|code-block|syntax|javascript|1503938|用法：|1503939|Version("1.2.4").compareTo(Version("0.0.5"))+//return+1|1503940|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/11024200/6352712^0|8|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

@alex's <a href="https://stackoverflow.com/a/11024200/6352712">post</a> on Kotlin

<pre><code>class Version(inputVersion: String) : Comparable&lt;Version&gt; {

 var version: String
 private set

 override fun compareTo(other: Version) =
 (split() to other.split()).let {(thisParts, thatParts)-&gt;
 val length = max(thisParts.size, thatParts.size)
 for (i in 0 until length) {
 val thisPart = if (i &lt; thisParts.size) thisParts[i].toInt() else 0
 val thatPart = if (i &lt; thatParts.size) thatParts[i].toInt() else 0
 if (thisPart &lt; thatPart) return -1
 if (thisPart &gt; thatPart) return 1
 }
 0
 }

 init {
 require(inputVersion.matches("[0-9]+(\\.[0-9]+)*".toRegex())) { "Invalid version format" }
 version = inputVersion
 }
 }

 fun Version.split() = version.split(".").toTypedArray()
</code></pre>

usage:

<pre><code>Version("1.2.4").compareTo(Version("0.0.5")) //return 1
</code></pre>

blocks|key|1718123|text|public+int+compare(String+v1,+String+v2)+{
++++++++v1+=+v1.replaceAll("\\s",+"");
++++++++v2+=+v2.replaceAll("\\s",+"");
++++++++String[]+a1+=+v1.split("\\.");
++++++++String[]+a2+=+v2.split("\\.");
++++++++List<String>+l1+=+Arrays.asList(a1);
++++++++List<String>+l2+=+Arrays.asList(a2);


++++++++int+i=0;
++++++++while(true){
++++++++++++Double+d1+=+null;
++++++++++++Double+d2+=+null;

++++++++++++try{
++++++++++++++++d1+=+Double.parseDouble(l1.get(i));
++++++++++++}catch(IndexOutOfBoundsException+e){
++++++++++++}

++++++++++++try{
++++++++++++++++d2+=+Double.parseDouble(l2.get(i));
++++++++++++}catch(IndexOutOfBoundsException+e){
++++++++++++}

++++++++++++if+(d1+!=+null+&&+d2+!=+null)+{
++++++++++++++++if+(d1.doubleValue()+>+d2.doubleValue())+{
++++++++++++++++++++return+1;
++++++++++++++++}+else+if+(d1.doubleValue()+<+d2.doubleValue())+{
++++++++++++++++++++return+-1;
++++++++++++++++}
++++++++++++}+else+if+(d2+==+null+&&+d1+!=+null)+{
++++++++++++++++if+(d1.doubleValue()+>+0)+{
++++++++++++++++++++return+1;
++++++++++++++++}
++++++++++++}+else+if+(d1+==+null+&&+d2+!=+null)+{
++++++++++++++++if+(d2.doubleValue()+>+0)+{
++++++++++++++++++++return+-1;
++++++++++++++++}
++++++++++++}+else+{
++++++++++++++++break;
++++++++++++}
++++++++++++i%2B%2B;
++++++++}
++++++++return+0;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1718124|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public int compare(String v1, String v2) {
 v1 = v1.replaceAll("\\s", "");
 v2 = v2.replaceAll("\\s", "");
 String[] a1 = v1.split("\\.");
 String[] a2 = v2.split("\\.");
 List&lt;String&gt; l1 = Arrays.asList(a1);
 List&lt;String&gt; l2 = Arrays.asList(a2);


 int i=0;
 while(true){
 Double d1 = null;
 Double d2 = null;

 try{
 d1 = Double.parseDouble(l1.get(i));
 }catch(IndexOutOfBoundsException e){
 }

 try{
 d2 = Double.parseDouble(l2.get(i));
 }catch(IndexOutOfBoundsException e){
 }

 if (d1 != null &amp;&amp; d2 != null) {
 if (d1.doubleValue() &gt; d2.doubleValue()) {
 return 1;
 } else if (d1.doubleValue() &lt; d2.doubleValue()) {
 return -1;
 }
 } else if (d2 == null &amp;&amp; d1 != null) {
 if (d1.doubleValue() &gt; 0) {
 return 1;
 }
 } else if (d1 == null &amp;&amp; d2 != null) {
 if (d2.doubleValue() &gt; 0) {
 return -1;
 }
 } else {
 break;
 }
 i++;
 }
 return 0;
 }
</code></pre>

blocks|key|1718544|text|/**++
+*++written+by:+Stan+Towianski+-+May+2018+
+*+notes:+I+make+assumption+each+of+3+version+sections+a.b.c+is+not+longer+then+4+digits:+aaaa.bbbb.cccc-MODWORD1(-)modnum2
+*+5.10.13-release-1+becomes+0000500100013.501+++++6.0-snapshot+becomes+0000600000000.100
+*+MODWORD1+=+-xyz/NotMatching,+-SNAPSHOT,+-ALPHA,+-BETA,+-RC,+-RELEASE/nothing++return:++.0,+.1,+.2,+.3,+.4,+.5
+*+modnum2+=+up+to+2+digit/chars+second+version
+*+*/
public+class+VersionCk+{

++++private+static+boolean+isVersionHigher(+String+baseVersion,+String+testVersion+)
++++++++{
++++++++System.out.println(+"versionToComparable(+baseVersion+)+="+%2B+versionToComparable(+baseVersion+)+);
++++++++System.out.println(+"versionToComparable(+testVersion+)+="+%2B+versionToComparable(+testVersion+)+%2B+"+is+this+higher+?"+);
++++++++return+versionToComparable(+testVersion+).compareTo(+versionToComparable(+baseVersion+)+)+>+0;
++++++++}

++++//----++not+worrying+about+%2B=+for+something+so+small
++++private+static+String+versionToComparable(+String+version+)
++++++++{
//++++++++System.out.println("version+-+"+%2B+version);
++++++++String+versionNum+=+version;
++++++++int+at+=+version.indexOf(+'-'+);
++++++++if+(+at+>=+0+)
++++++++++++versionNum+=+version.substring(+0,+at+);

++++++++String[]+numAr+=+versionNum.split(+"\\."+);
++++++++String+versionFormatted+=+"0";
++++++++for+(+String+tmp+:+numAr+)
++++++++++++{
++++++++++++versionFormatted+%2B=+String.format(+"%254s",+tmp+).replace('+',+'0');
++++++++++++}
++++++++while+(+versionFormatted.length()+<+12+)++//+pad+out+to+aaaa.bbbb.cccc
++++++++++++{
++++++++++++versionFormatted+%2B=+"0000";
++++++++++++}
//++++++++System.out.println(+"converted+min+version+="+%2B+versionFormatted+%2B+"=+++:+"+%2B+versionNum+);
++++++++return+versionFormatted+%2B+getVersionModifier(+version,+at+);
++++++++}

++++//----++use+order+low+to+high:+-xyz,+-SNAPSHOT,+-ALPHA,+-BETA,+-RC,+-RELEASE/nothing++returns:+0,+1,+2,+3,+4,+5
++++private+static+String+getVersionModifier(+String+version,+int+at+)
++++++++{
//++++++++System.out.println("version+-+"+%2B+version+);
++++++++String[]+wordModsAr+=+{+"-SNAPSHOT",+"-ALPHA",+"-BETA",+"-RC",+"-RELEASE"+};++++++++

++++++++if+(+at+<+0+)
++++++++++++return+"."+%2B+wordModsAr.length+%2B+"00";+++//+make+nothing+=+RELEASE+level

++++++++int+i+=+1;
++++++++for+(+String+word+:+wordModsAr+)
++++++++++++{
++++++++++++if+(+(+at+=+version.toUpperCase().indexOf(+word+)+)+>+0+)
++++++++++++++++return+"."+%2B+i+%2B+getSecondVersionModifier(+version.substring(+at+%2B+word.length()+)+);
++++++++++++i%2B%2B;
++++++++++++}

++++++++return+".000";
++++++++}

++++//----++add+2+chars+for+any+number+after+first+modifier.++-rc2+or+-rc-2+++returns+02
++++private+static+String+getSecondVersionModifier(+String+version+)
++++++++{
++++++++System.out.println(+"second+modifier+="+%2B+version+%2B+"="+);
++++++++Matcher+m+=+Pattern.compile("(.*?)(\\d%2B).*").matcher(+version+);
//++++++++if+(+m.matches()+)
//++++++++++++System.out.println(+"match+?+="+%2B+m.matches()+%2B+"=+++m.group(1)+="+%2B+m.group(1)+%2B+"=+++m.group(2)+="+%2B+m.group(2)+%2B+"=+++m.group(3)+="+%2B+(m.groupCount()+>=+3+?+m.group(3)+:+"x")+);
//++++++++else
//++++++++++++System.out.println(+"No+match"+);
++++++++return+m.matches()+?+String.format(+"%252s",+m.group(2)+).replace('+',+'0')+:+"00";
++++++++}

++++public+static+void+main(String[]+args)+
++++++++{
++++++++checkVersion(+"3.10.0",+"3.4.0");
++++++++checkVersion(+"5.4.2",+"5.4.1");
++++++++checkVersion(+"5.4.4",+"5.4.5");
++++++++checkVersion(+"5.4.9",+"5.4.12");
++++++++checkVersion(+"5.9.222",+"5.10.12");
++++++++checkVersion(+"5.10.12",+"5.10.12");
++++++++checkVersion(+"5.10.13",+"5.10.14");
++++++++checkVersion(+"6.7.0",+"6.8");
++++++++checkVersion(+"6.7",+"2.7.0");
++++++++checkVersion(+"6",+"6.3.1");
++++++++checkVersion(+"4",+"4.0.0");
++++++++checkVersion(+"6.3.0",+"6");
++++++++checkVersion(+"5.10.12-Alpha",+"5.10.12-beTA");
++++++++checkVersion(+"5.10.13-release",+"5.10.14-beta");
++++++++checkVersion(+"6.7.0",+"6.8-snapshot");
++++++++checkVersion(+"6.7.1",+"6.7.0-release");
++++++++checkVersion(+"6-snapshot",+"6.0.0-beta");
++++++++checkVersion(+"6.0-snapshot",+"6.0.0-whatthe");
++++++++checkVersion(+"5.10.12-Alpha-1",+"5.10.12-alpha-2");
++++++++checkVersion(+"5.10.13-release-1",+"5.10.13-release2");
++++++++checkVersion(+"10-rc42",+"10.0.0-rc53");
++++++++}

++++private+static+void+checkVersion(String+baseVersion,+String+testVersion)+
++++++++{
++++++++System.out.println(+"baseVersion+-+"+%2B+baseVersion+);
++++++++System.out.println(+"testVersion+-+"+%2B+testVersion+);
++++++++System.out.println(+"isVersionHigher+=+"+%2B+isVersionHigher(+baseVersion,+testVersion+)+);
++++++++System.out.println(+"---------------");
++++++++}

++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1718545|一些输出：|unstyled|1718546|---------------
baseVersion+-+6.7
testVersion+-+2.7.0
versionToComparable(+baseVersion+)+=0000600070000.500
versionToComparable(+testVersion+)+=0000200070000.500+is+this+higher+?
isVersionHigher+=+false
---------------
baseVersion+-+6
testVersion+-+6.3.1
versionToComparable(+baseVersion+)+=0000600000000.500
versionToComparable(+testVersion+)+=0000600030001.500+is+this+higher+?
isVersionHigher+=+true
---------------
baseVersion+-+4
testVersion+-+4.0.0
versionToComparable(+baseVersion+)+=0000400000000.500
versionToComparable(+testVersion+)+=0000400000000.500+is+this+higher+?
isVersionHigher+=+false
---------------
baseVersion+-+6.3.0
testVersion+-+6
versionToComparable(+baseVersion+)+=0000600030000.500
versionToComparable(+testVersion+)+=0000600000000.500+is+this+higher+?
isVersionHigher+=+false
---------------
baseVersion+-+5.10.12-Alpha
testVersion+-+5.10.12-beTA
second+modifier+==
versionToComparable(+baseVersion+)+=0000500100012.200
second+modifier+==
versionToComparable(+testVersion+)+=0000500100012.300+is+this+higher+?
second+modifier+==
second+modifier+==
isVersionHigher+=+true
---------------
baseVersion+-+5.10.13-release
testVersion+-+5.10.14-beta
second+modifier+==
versionToComparable(+baseVersion+)+=0000500100013.500
second+modifier+==
versionToComparable(+testVersion+)+=0000500100014.300+is+this+higher+?
second+modifier+==
second+modifier+==
isVersionHigher+=+true
---------------
baseVersion+-+6.7.0
testVersion+-+6.8-snapshot
versionToComparable(+baseVersion+)+=0000600070000.500
second+modifier+==
versionToComparable(+testVersion+)+=0000600080000.100+is+this+higher+?
second+modifier+==
isVersionHigher+=+true
---------------
baseVersion+-+6.7.1
testVersion+-+6.7.0-release
versionToComparable(+baseVersion+)+=0000600070001.500
second+modifier+==
versionToComparable(+testVersion+)+=0000600070000.500+is+this+higher+?
second+modifier+==
isVersionHigher+=+false
---------------
baseVersion+-+6-snapshot
testVersion+-+6.0.0-beta
second+modifier+==
versionToComparable(+baseVersion+)+=0000600000000.100
second+modifier+==
versionToComparable(+testVersion+)+=0000600000000.300+is+this+higher+?
second+modifier+==
second+modifier+==
isVersionHigher+=+true
---------------
baseVersion+-+6.0-snapshot
testVersion+-+6.0.0-whatthe
second+modifier+==
versionToComparable(+baseVersion+)+=0000600000000.100
versionToComparable(+testVersion+)+=0000600000000.000+is+this+higher+?
second+modifier+==
isVersionHigher+=+false
---------------
baseVersion+-+5.10.12-Alpha-1
testVersion+-+5.10.12-alpha-2
second+modifier+=-1=
versionToComparable(+baseVersion+)+=0000500100012.201
second+modifier+=-2=
versionToComparable(+testVersion+)+=0000500100012.202+is+this+higher+?
second+modifier+=-2=
second+modifier+=-1=
isVersionHigher+=+true
---------------
baseVersion+-+5.10.13-release-1
testVersion+-+5.10.13-release2
second+modifier+=-1=
versionToComparable(+baseVersion+)+=0000500100013.501
second+modifier+=2=
versionToComparable(+testVersion+)+=0000500100013.502+is+this+higher+?
second+modifier+=2=
second+modifier+=-1=
isVersionHigher+=+true
---------------
baseVersion+-+10-rc42
testVersion+-+10.0.0-rc53
second+modifier+=42=
versionToComparable(+baseVersion+)+=0001000000000.442
second+modifier+=53=
versionToComparable(+testVersion+)+=0001000000000.453+is+this+higher+?
second+modifier+=53=
second+modifier+=42=
isVersionHigher+=+true
---------------|1718547|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>/** 
 * written by: Stan Towianski - May 2018 
 * notes: I make assumption each of 3 version sections a.b.c is not longer then 4 digits: aaaa.bbbb.cccc-MODWORD1(-)modnum2
 * 5.10.13-release-1 becomes 0000500100013.501 6.0-snapshot becomes 0000600000000.100
 * MODWORD1 = -xyz/NotMatching, -SNAPSHOT, -ALPHA, -BETA, -RC, -RELEASE/nothing return: .0, .1, .2, .3, .4, .5
 * modnum2 = up to 2 digit/chars second version
 * */
public class VersionCk {

 private static boolean isVersionHigher( String baseVersion, String testVersion )
 {
 System.out.println( "versionToComparable( baseVersion ) =" + versionToComparable( baseVersion ) );
 System.out.println( "versionToComparable( testVersion ) =" + versionToComparable( testVersion ) + " is this higher ?" );
 return versionToComparable( testVersion ).compareTo( versionToComparable( baseVersion ) ) &gt; 0;
 }

 //---- not worrying about += for something so small
 private static String versionToComparable( String version )
 {
// System.out.println("version - " + version);
 String versionNum = version;
 int at = version.indexOf( '-' );
 if ( at &gt;= 0 )
 versionNum = version.substring( 0, at );

 String[] numAr = versionNum.split( "\\." );
 String versionFormatted = "0";
 for ( String tmp : numAr )
 {
 versionFormatted += String.format( "%4s", tmp ).replace(' ', '0');
 }
 while ( versionFormatted.length() &lt; 12 ) // pad out to aaaa.bbbb.cccc
 {
 versionFormatted += "0000";
 }
// System.out.println( "converted min version =" + versionFormatted + "= : " + versionNum );
 return versionFormatted + getVersionModifier( version, at );
 }

 //---- use order low to high: -xyz, -SNAPSHOT, -ALPHA, -BETA, -RC, -RELEASE/nothing returns: 0, 1, 2, 3, 4, 5
 private static String getVersionModifier( String version, int at )
 {
// System.out.println("version - " + version );
 String[] wordModsAr = { "-SNAPSHOT", "-ALPHA", "-BETA", "-RC", "-RELEASE" }; 

 if ( at &lt; 0 )
 return "." + wordModsAr.length + "00"; // make nothing = RELEASE level

 int i = 1;
 for ( String word : wordModsAr )
 {
 if ( ( at = version.toUpperCase().indexOf( word ) ) &gt; 0 )
 return "." + i + getSecondVersionModifier( version.substring( at + word.length() ) );
 i++;
 }

 return ".000";
 }

 //---- add 2 chars for any number after first modifier. -rc2 or -rc-2 returns 02
 private static String getSecondVersionModifier( String version )
 {
 System.out.println( "second modifier =" + version + "=" );
 Matcher m = Pattern.compile("(.*?)(\\d+).*").matcher( version );
// if ( m.matches() )
// System.out.println( "match ? =" + m.matches() + "= m.group(1) =" + m.group(1) + "= m.group(2) =" + m.group(2) + "= m.group(3) =" + (m.groupCount() &gt;= 3 ? m.group(3) : "x") );
// else
// System.out.println( "No match" );
 return m.matches() ? String.format( "%2s", m.group(2) ).replace(' ', '0') : "00";
 }

 public static void main(String[] args) 
 {
 checkVersion( "3.10.0", "3.4.0");
 checkVersion( "5.4.2", "5.4.1");
 checkVersion( "5.4.4", "5.4.5");
 checkVersion( "5.4.9", "5.4.12");
 checkVersion( "5.9.222", "5.10.12");
 checkVersion( "5.10.12", "5.10.12");
 checkVersion( "5.10.13", "5.10.14");
 checkVersion( "6.7.0", "6.8");
 checkVersion( "6.7", "2.7.0");
 checkVersion( "6", "6.3.1");
 checkVersion( "4", "4.0.0");
 checkVersion( "6.3.0", "6");
 checkVersion( "5.10.12-Alpha", "5.10.12-beTA");
 checkVersion( "5.10.13-release", "5.10.14-beta");
 checkVersion( "6.7.0", "6.8-snapshot");
 checkVersion( "6.7.1", "6.7.0-release");
 checkVersion( "6-snapshot", "6.0.0-beta");
 checkVersion( "6.0-snapshot", "6.0.0-whatthe");
 checkVersion( "5.10.12-Alpha-1", "5.10.12-alpha-2");
 checkVersion( "5.10.13-release-1", "5.10.13-release2");
 checkVersion( "10-rc42", "10.0.0-rc53");
 }

 private static void checkVersion(String baseVersion, String testVersion) 
 {
 System.out.println( "baseVersion - " + baseVersion );
 System.out.println( "testVersion - " + testVersion );
 System.out.println( "isVersionHigher = " + isVersionHigher( baseVersion, testVersion ) );
 System.out.println( "---------------");
 }

 }
</code></pre>

some output:

<pre><code>---------------
baseVersion - 6.7
testVersion - 2.7.0
versionToComparable( baseVersion ) =0000600070000.500
versionToComparable( testVersion ) =0000200070000.500 is this higher ?
isVersionHigher = false
---------------
baseVersion - 6
testVersion - 6.3.1
versionToComparable( baseVersion ) =0000600000000.500
versionToComparable( testVersion ) =0000600030001.500 is this higher ?
isVersionHigher = true
---------------
baseVersion - 4
testVersion - 4.0.0
versionToComparable( baseVersion ) =0000400000000.500
versionToComparable( testVersion ) =0000400000000.500 is this higher ?
isVersionHigher = false
---------------
baseVersion - 6.3.0
testVersion - 6
versionToComparable( baseVersion ) =0000600030000.500
versionToComparable( testVersion ) =0000600000000.500 is this higher ?
isVersionHigher = false
---------------
baseVersion - 5.10.12-Alpha
testVersion - 5.10.12-beTA
second modifier ==
versionToComparable( baseVersion ) =0000500100012.200
second modifier ==
versionToComparable( testVersion ) =0000500100012.300 is this higher ?
second modifier ==
second modifier ==
isVersionHigher = true
---------------
baseVersion - 5.10.13-release
testVersion - 5.10.14-beta
second modifier ==
versionToComparable( baseVersion ) =0000500100013.500
second modifier ==
versionToComparable( testVersion ) =0000500100014.300 is this higher ?
second modifier ==
second modifier ==
isVersionHigher = true
---------------
baseVersion - 6.7.0
testVersion - 6.8-snapshot
versionToComparable( baseVersion ) =0000600070000.500
second modifier ==
versionToComparable( testVersion ) =0000600080000.100 is this higher ?
second modifier ==
isVersionHigher = true
---------------
baseVersion - 6.7.1
testVersion - 6.7.0-release
versionToComparable( baseVersion ) =0000600070001.500
second modifier ==
versionToComparable( testVersion ) =0000600070000.500 is this higher ?
second modifier ==
isVersionHigher = false
---------------
baseVersion - 6-snapshot
testVersion - 6.0.0-beta
second modifier ==
versionToComparable( baseVersion ) =0000600000000.100
second modifier ==
versionToComparable( testVersion ) =0000600000000.300 is this higher ?
second modifier ==
second modifier ==
isVersionHigher = true
---------------
baseVersion - 6.0-snapshot
testVersion - 6.0.0-whatthe
second modifier ==
versionToComparable( baseVersion ) =0000600000000.100
versionToComparable( testVersion ) =0000600000000.000 is this higher ?
second modifier ==
isVersionHigher = false
---------------
baseVersion - 5.10.12-Alpha-1
testVersion - 5.10.12-alpha-2
second modifier =-1=
versionToComparable( baseVersion ) =0000500100012.201
second modifier =-2=
versionToComparable( testVersion ) =0000500100012.202 is this higher ?
second modifier =-2=
second modifier =-1=
isVersionHigher = true
---------------
baseVersion - 5.10.13-release-1
testVersion - 5.10.13-release2
second modifier =-1=
versionToComparable( baseVersion ) =0000500100013.501
second modifier =2=
versionToComparable( testVersion ) =0000500100013.502 is this higher ?
second modifier =2=
second modifier =-1=
isVersionHigher = true
---------------
baseVersion - 10-rc42
testVersion - 10.0.0-rc53
second modifier =42=
versionToComparable( baseVersion ) =0001000000000.442
second modifier =53=
versionToComparable( testVersion ) =0001000000000.453 is this higher ?
second modifier =53=
second modifier =42=
isVersionHigher = true
---------------
</code></pre>

blocks|key|1718700|text|我编写了一个名为MgntUtils的开源库，它有一个可以处理字符串版本的实用程序。它可以正确地比较它们，使用版本范围等等。这里是这个库，请参阅methods+TextUtils.comapreVersions(...)。它已经得到了广泛的使用和良好的测试。下面是描述该库的article，以及在哪里可以获得它。它以Maven+artifact的形式提供，也可以在github上使用(带有源代码和JavaDoc)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1718701|entityMap|0|LINK|mutability|MUTABLE|url|https://community.oracle.com/blogs/michaelgantman/2016/01/26/open-source-java-library-with-stacktrace-filtering-silent-string-parsing-and-version-comparison|1|https://search.maven.org/search?q=MgntUtils|2|https://github.com/michaelgantman/Mgnt^0|27|U|3S|7|0|4D|E|1|51|6|2|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]|$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]|P|$5|I|J|K|E|$L|Q]]]]

I wrote an Open Source Library called MgntUtils that has a utility that works with String versions. It correctly compares them, works with version ranges and so forth. Here is this library <a href="http://michaelgantman.github.io/Mgnt/docs/" rel="nofollow noreferrer">javadoc</a> See methods <code>TextUtils.comapreVersions(...)</code>. It has been heavily used and well tested. Here is the <a href="https://community.oracle.com/blogs/michaelgantman/2016/01/26/open-source-java-library-with-stacktrace-filtering-silent-string-parsing-and-version-comparison" rel="nofollow noreferrer">article</a> that describes the library and where to get it. It is available as <a href="https://search.maven.org/search?q=MgntUtils" rel="nofollow noreferrer">Maven artifact</a> and on the <a href="https://github.com/michaelgantman/Mgnt" rel="nofollow noreferrer">github</a> (with sources and JavaDoc)

blocks|key|1503898|text|我现在就这么做了，并问自己，这是正确的吗？因为我从来没有找到过比我的更干净的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503899|您只需要拆分字符串版本("1.0.0")，如下例所示：|1503900|userVersion.split("\\.")|code-block|syntax|javascript|1503901|那么你会得到：{"1"，"0"，"0"}|1503902|现在，使用我所做的方法：|1503903|isUpdateAvailable(userVersion.split("\\."),+latestVersionSplit.split("\\."));|1503904|方法：|1503905|/**
+*+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;
}|1503906|等待任何反馈:)|1503907|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

I done it right now and asked myself, is it correct? Because I've never found a cleanest solution before than mine:
You just need to split the string versions (&quot;1.0.0&quot;) like this example:
<pre><code>userVersion.split(&quot;\\.&quot;)
</code></pre>
Then you will have: {&quot;1&quot;, &quot;0&quot;, &quot;0&quot;}
Now, using the method that I done:
<pre><code>isUpdateAvailable(userVersion.split(&quot;\\.&quot;), latestVersionSplit.split(&quot;\\.&quot;));
</code></pre>
Method:
<pre><code>/**
 * Compare two versions
 *
 * @param userVersionSplit - User string array with major, minor and patch version from user (exemple: {&quot;5&quot;, &quot;2&quot;, &quot;70&quot;})
 * @param latestVersionSplit - Latest string array with major, minor and patch version from api (example: {&quot;5&quot;, &quot;2&quot;, &quot;71&quot;})
 * @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 &lt;= majorLatestVersion) {
 if (majorUserVersion &lt; majorLatestVersion) {
 return true;
 } else {
 if (minorUserVersion &lt;= minorLatestVersion) {
 if (minorUserVersion &lt; minorLatestVersion) {
 return true;
 } else {
 return patchUserVersion &lt; patchLatestVersion;
 }
 }
 }
 }
 } catch (Exception ignored) {
 // Will be throw only if the versions pattern is different from &quot;x.x.x&quot; format
 // Will return false at the end
 }

 return false;
}
</code></pre>
Waiting for any feedback :)

blocks|key|1503207|text|对于我的项目，我使用我的通用版本库https://github.com/raydac/commons-version，它包含两个辅助类-解析版本(解析的版本可以与另一个版本对象进行比较，因为它是可比较的)和VersionValidator，它允许检查某个表达式的版本，如!=ide-1.1.1,>idea-1.3.4-SNAPSHOT;<1.2.3|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1503208|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/raydac/commons-version^0|3R|13|H|15|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

for my projects I use my commons-version library <a href="https://github.com/raydac/commons-version" rel="nofollow">https://github.com/raydac/commons-version</a>
it contains two auxiliary classes - to parse version (parsed version can be compared with another version object because it is comparable one) and VersionValidator which allows to check version for some expression like <code>!=ide-1.1.1,&gt;idea-1.3.4-SNAPSHOT;&lt;1.2.3</code>

blocks|key|1503588|text|public+int+CompareVersions(String+version1,+String+version2)
{
++++String[]+string1Vals+=+version1.split("\\.");
++++String[]+string2Vals+=+version2.split("\\.");

++++int+length+=+Math.max(string1Vals.length,+string2Vals.length);

++++for+(int+i+=+0;+i+<+length;+i%2B%2B)
++++{
++++++++Integer+v1+=+(i+<+string1Vals.length)?Integer.parseInt(string1Vals[i]):0;
++++++++Integer+v2+=+(i+<+string2Vals.length)?Integer.parseInt(string2Vals[i]):0;

++++++++//Making+sure+Version1+bigger+than+version2
++++++++if+(v1+>+v2)
++++++++{
++++++++++++return+1;
++++++++}
++++++++//Making+sure+Version1+smaller+than+version2
++++++++else+if(v1+<+v2)
++++++++{
++++++++++++return+-1;
++++++++}
++++}

++++//Both+are+equal
++++return+0;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503589|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public int CompareVersions(String version1, String version2)
{
 String[] string1Vals = version1.split("\\.");
 String[] string2Vals = version2.split("\\.");

 int length = Math.max(string1Vals.length, string2Vals.length);

 for (int i = 0; i &lt; length; i++)
 {
 Integer v1 = (i &lt; string1Vals.length)?Integer.parseInt(string1Vals[i]):0;
 Integer v2 = (i &lt; string2Vals.length)?Integer.parseInt(string2Vals[i]):0;

 //Making sure Version1 bigger than version2
 if (v1 &gt; v2)
 {
 return 1;
 }
 //Making sure Version1 smaller than version2
 else if(v1 &lt; v2)
 {
 return -1;
 }
 }

 //Both are equal
 return 0;
}
</code></pre>

blocks|key|1718874|text|由于这个页面上没有能很好地处理混合文本的答案，我制作了自己的版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718875|import+java.util.regex.Matcher;
import+java.util.regex.Pattern;

class+Main+{
++++static+double+parseVersion(String+v)+{
++++++++if+(v.isEmpty())+{
++++++++++++return+0;
++++++++}
++++++++Pattern+p+=+Pattern.compile("%5E(\\D*)(\\d*)(\\D*)$");
++++++++Matcher+m+=+p.matcher(v);
++++++++m.find();
++++++++if+(m.group(2).isEmpty())+{
++++++++++++//+v1.0.0.[preview]
++++++++++++return+-1;
++++++++}
++++++++double+i+=+Integer.parseInt(m.group(2));
++++++++if+(!m.group(3).isEmpty())+{
++++++++++++//+v1.0.[0b]
++++++++++++i+-=+0.1;
++++++++}
++++++++return+i;
++++}

++++public+static+int+versionCompare(String+str1,+String+str2)+{
++++++++String[]+v1+=+str1.split("\\.");
++++++++String[]+v2+=+str2.split("\\.");
++++++++int+i+=+0;
++++++++for+(;+i+<+v1.length+&&+i+<+v2.length;+i%2B%2B)+{
++++++++++++double+iv1+=+parseVersion(v1[i]);
++++++++++++double+iv2+=+parseVersion(v2[i]);

++++++++++++if+(iv1+!=+iv2)+{
++++++++++++++++return+iv1+-+iv2+<+0+?+-1+:+1;
++++++++++++}
++++++++}
++++++++if+(i+<+v1.length)+{
++++++++++++//+"1.0.1",+"1.0"
++++++++++++double+iv1+=+parseVersion(v1[i]);
++++++++++++return+iv1+<+0+?+-1+:+(int)+Math.ceil(iv1);
++++++++}
++++++++if+(i+<+v2.length)+{
++++++++++++double+iv2+=+parseVersion(v2[i]);
++++++++++++return+-iv2+<+0+?+-1+:+(int)+Math.ceil(iv2);
++++++++}
++++++++return+0;
++++}


++++public+static+void+main(String[]+args)+{
++++++++System.out.println("versionCompare(v1.0.0,+1.0.0)");
++++++++System.out.println(versionCompare("v1.0.0",+"1.0.0"));+//+0

++++++++System.out.println("versionCompare(v1.0.0b,+1.0.0)");
++++++++System.out.println(versionCompare("v1.0.0b",+"1.0.0"));+//+-1

++++++++System.out.println("versionCompare(v1.0.0.preview,+1.0.0)");
++++++++System.out.println(versionCompare("v1.0.0.preview",+"1.0.0"));+//+-1

++++++++System.out.println("versionCompare(v1.0,+1.0.0)");
++++++++System.out.println(versionCompare("v1.0",+"1.0.0"));+//+0

++++++++System.out.println("versionCompare(ver1.0,+1.0.1)");
++++++++System.out.println(versionCompare("ver1.0",+"1.0.1"));+//+-1
++++}
}|code-block|syntax|javascript|1718876|然而，在需要比较"alpha“和"beta”的情况下，它仍然是不够的。|1718877|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Since no answer on this page handles mixed text well, I made my own version:
<pre class="lang-java prettyprint-override"><code>import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Main {
 static double parseVersion(String v) {
 if (v.isEmpty()) {
 return 0;
 }
 Pattern p = Pattern.compile(&quot;^(\\D*)(\\d*)(\\D*)$&quot;);
 Matcher m = p.matcher(v);
 m.find();
 if (m.group(2).isEmpty()) {
 // v1.0.0.[preview]
 return -1;
 }
 double i = Integer.parseInt(m.group(2));
 if (!m.group(3).isEmpty()) {
 // v1.0.[0b]
 i -= 0.1;
 }
 return i;
 }

 public static int versionCompare(String str1, String str2) {
 String[] v1 = str1.split(&quot;\\.&quot;);
 String[] v2 = str2.split(&quot;\\.&quot;);
 int i = 0;
 for (; i &lt; v1.length &amp;&amp; i &lt; v2.length; i++) {
 double iv1 = parseVersion(v1[i]);
 double iv2 = parseVersion(v2[i]);

 if (iv1 != iv2) {
 return iv1 - iv2 &lt; 0 ? -1 : 1;
 }
 }
 if (i &lt; v1.length) {
 // &quot;1.0.1&quot;, &quot;1.0&quot;
 double iv1 = parseVersion(v1[i]);
 return iv1 &lt; 0 ? -1 : (int) Math.ceil(iv1);
 }
 if (i &lt; v2.length) {
 double iv2 = parseVersion(v2[i]);
 return -iv2 &lt; 0 ? -1 : (int) Math.ceil(iv2);
 }
 return 0;
 }


 public static void main(String[] args) {
 System.out.println(&quot;versionCompare(v1.0.0, 1.0.0)&quot;);
 System.out.println(versionCompare(&quot;v1.0.0&quot;, &quot;1.0.0&quot;)); // 0

 System.out.println(&quot;versionCompare(v1.0.0b, 1.0.0)&quot;);
 System.out.println(versionCompare(&quot;v1.0.0b&quot;, &quot;1.0.0&quot;)); // -1

 System.out.println(&quot;versionCompare(v1.0.0.preview, 1.0.0)&quot;);
 System.out.println(versionCompare(&quot;v1.0.0.preview&quot;, &quot;1.0.0&quot;)); // -1

 System.out.println(&quot;versionCompare(v1.0, 1.0.0)&quot;);
 System.out.println(versionCompare(&quot;v1.0&quot;, &quot;1.0.0&quot;)); // 0

 System.out.println(&quot;versionCompare(ver1.0, 1.0.1)&quot;);
 System.out.println(versionCompare(&quot;ver1.0&quot;, &quot;1.0.1&quot;)); // -1
 }
}
</code></pre>
It still falls short on cases where you need to compare &quot;alpha&quot; with &quot;beta&quot; though.

blocks|key|1719084|text|基于https://stackoverflow.com/a/27891752/2642478|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1719085|class+Version(private+val+value:+String)+:+Comparable<Version>+{
++++private+val+splitted+by+lazy+{+value.split("-").first().split(".").map+{+it.toIntOrNull()+?:+0+}+}

++++override+fun+compareTo(other:+Version):+Int+{
++++++++for+(i+in+0+until+maxOf(splitted.size,+other.splitted.size))+{
++++++++++++val+compare+=+splitted.getOrElse(i)+{+0+}.compareTo(other.splitted.getOrElse(i)+{+0+})
++++++++++++if+(compare+!=+0)
++++++++++++++++return+compare
++++++++}
++++++++return+0
++++}
}|code-block|syntax|javascript|1719086|您可以使用like：|1719087|++++System.err.println(Version("1.0").compareTo(+Version("1.0")))
++++System.err.println(Version("1.0")+<+Version("1.1"))
++++System.err.println(Version("1.10")+>+Version("1.9"))
++++System.err.println(Version("1.10.1")+>+Version("1.10"))
++++System.err.println(Version("0.0.1")+<+Version("1"))|1719088|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/27891752/2642478^0|2|18|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

based on <a href="https://stackoverflow.com/a/27891752/2642478">https://stackoverflow.com/a/27891752/2642478</a>
<pre><code>class Version(private val value: String) : Comparable&lt;Version&gt; {
 private val splitted by lazy { value.split(&quot;-&quot;).first().split(&quot;.&quot;).map { it.toIntOrNull() ?: 0 } }

 override fun compareTo(other: Version): Int {
 for (i in 0 until maxOf(splitted.size, other.splitted.size)) {
 val compare = splitted.getOrElse(i) { 0 }.compareTo(other.splitted.getOrElse(i) { 0 })
 if (compare != 0)
 return compare
 }
 return 0
 }
}
</code></pre>
you can use like:
<pre><code> System.err.println(Version(&quot;1.0&quot;).compareTo( Version(&quot;1.0&quot;)))
 System.err.println(Version(&quot;1.0&quot;) &lt; Version(&quot;1.1&quot;))
 System.err.println(Version(&quot;1.10&quot;) &gt; Version(&quot;1.9&quot;))
 System.err.println(Version(&quot;1.10.1&quot;) &gt; Version(&quot;1.10&quot;))
 System.err.println(Version(&quot;0.0.1&quot;) &lt; Version(&quot;1&quot;))
</code></pre>

blocks|key|1504009|text|也许有人会对我的解决方案感兴趣：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504010|class+Version+private+constructor(private+val+versionString:+String)+:+Comparable<Version>+{

++++private+val+major:+Int+by+lazy+{+versionString.split(".")[0].toInt()+}

++++private+val+minor:+Int+by+lazy+{+versionString.split(".")[1].toInt()+}

++++private+val+patch:+Int+by+lazy+{
++++++++val+splitArray+=+versionString.split(".")

++++++++if+(splitArray.size+==+3)
++++++++++++splitArray[2].toInt()
++++++++else
++++++++++++0
++++}

++++override+fun+compareTo(other:+Version):+Int+{
++++++++return+when+{
++++++++++++major+>+other.major+->+1
++++++++++++major+<+other.major+->+-1
++++++++++++minor+>+other.minor+->+1
++++++++++++minor+<+other.minor+->+-1
++++++++++++patch+>+other.patch+->+1
++++++++++++patch+<+other.patch+->+-1
++++++++++++else+->+0
++++++++}
++++}

++++override+fun+equals(other:+Any?):+Boolean+{
++++++++if+(other+==+null+%7C%7C+other+!is+Version)+return+false
++++++++return+compareTo(other)+==+0
++++}

++++override+fun+hashCode():+Int+{
++++++++return+major+*+minor+*+patch
++++}

++++companion+object+{
++++++++private+fun+doesContainsVersion(string:+String):+Boolean+{
++++++++++++val+versionArray+=+string.split(".")

++++++++++++return+versionArray.size+in+2..3
++++++++++++++++++++&&+versionArray[0].toIntOrNull()+!=+null
++++++++++++++++++++&&+versionArray[1].toIntOrNull()+!=+null
++++++++++++++++++++&&+(versionArray.size+==+2+%7C%7C+versionArray[2].toIntOrNull()+!=+null)
++++++++}

++++++++fun+from(string:+String):+Version?+{
++++++++++++return+if+(doesContainsVersion(string))+{
++++++++++++++++Version(string)
++++++++++++}+else+{
++++++++++++++++null
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|1504011|用法：|1504012|val+version1+=+Version.from("3.2")
val+version2+=+Version.from("3.2.1")
version1+<=+version2|1504013|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Maybe someone will be interested in my solution:
<pre><code>class Version private constructor(private val versionString: String) : Comparable&lt;Version&gt; {

 private val major: Int by lazy { versionString.split(&quot;.&quot;)[0].toInt() }

 private val minor: Int by lazy { versionString.split(&quot;.&quot;)[1].toInt() }

 private val patch: Int by lazy {
 val splitArray = versionString.split(&quot;.&quot;)

 if (splitArray.size == 3)
 splitArray[2].toInt()
 else
 0
 }

 override fun compareTo(other: Version): Int {
 return when {
 major &gt; other.major -&gt; 1
 major &lt; other.major -&gt; -1
 minor &gt; other.minor -&gt; 1
 minor &lt; other.minor -&gt; -1
 patch &gt; other.patch -&gt; 1
 patch &lt; other.patch -&gt; -1
 else -&gt; 0
 }
 }

 override fun equals(other: Any?): Boolean {
 if (other == null || other !is Version) return false
 return compareTo(other) == 0
 }

 override fun hashCode(): Int {
 return major * minor * patch
 }

 companion object {
 private fun doesContainsVersion(string: String): Boolean {
 val versionArray = string.split(&quot;.&quot;)

 return versionArray.size in 2..3
 &amp;&amp; versionArray[0].toIntOrNull() != null
 &amp;&amp; versionArray[1].toIntOrNull() != null
 &amp;&amp; (versionArray.size == 2 || versionArray[2].toIntOrNull() != null)
 }

 fun from(string: String): Version? {
 return if (doesContainsVersion(string)) {
 Version(string)
 } else {
 null
 }
 }
 }
}
</code></pre>
Usage:
<pre><code>val version1 = Version.from(&quot;3.2&quot;)
val version2 = Version.from(&quot;3.2.1&quot;)
version1 &lt;= version2

</code></pre>

blocks|key|1718508|text|使用列表编写了一个小函数myself.Simpler|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718509|+public+static+boolean+checkVersionUpdate(String+olderVerison,+String+newVersion)+{
++++++++if+(olderVerison.length()+==+0+%7C%7C+newVersion.length()+==+0)+{
++++++++++++return+false;
++++++++}
++++++++List<String>+newVerList+=+Arrays.asList(newVersion.split("\\."));
++++++++List<String>+oldVerList+=+Arrays.asList(olderVerison.split("\\."));

++++++++int+diff+=+newVerList.size()+-+oldVerList.size();
++++++++List<String>+newList+=+new+ArrayList<>();
++++++++if+(diff+>+0)+{
++++++++++++newList.addAll(oldVerList);
++++++++++++for+(int+i+=+0;+i+<+diff;+i%2B%2B)+{
++++++++++++++++newList.add("0");
++++++++++++}
++++++++++++return+examineArray(newList,+newVerList,+diff);
++++++++}+else+if+(diff+<+0)+{
++++++++++++newList.addAll(newVerList);
++++++++++++for+(int+i+=+0;+i+<+-diff;+i%2B%2B)+{
++++++++++++++++newList.add("0");
++++++++++++}
++++++++++++return+examineArray(oldVerList,+newList,+diff);
++++++++}+else+{
++++++++++++return+examineArray(oldVerList,+newVerList,+diff);
++++++++}

++++}

++++public+static+boolean+examineArray(List<String>+oldList,+List<String>+newList,+int+diff)+{
++++++++boolean+newVersionGreater+=+false;
++++++++for+(int+i+=+0;+i+<+oldList.size();+i%2B%2B)+{
++++++++++++if+(Integer.parseInt(newList.get(i))+>+Integer.parseInt(oldList.get(i)))+{
++++++++++++++++newVersionGreater+=+true;
++++++++++++++++break;
++++++++++++}+else+if+(Integer.parseInt(newList.get(i))+<+Integer.parseInt(oldList.get(i)))+{
++++++++++++++++newVersionGreater+=+false;
++++++++++++++++break;
++++++++++++}+else+{
++++++++++++++++newVersionGreater+=+diff+>+0;
++++++++++++}
++++++++}

++++++++return+newVersionGreater;
++++}|code-block|syntax|javascript|1718510|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Wrote a little function myself.Simpler Using Lists

<pre><code> public static boolean checkVersionUpdate(String olderVerison, String newVersion) {
 if (olderVerison.length() == 0 || newVersion.length() == 0) {
 return false;
 }
 List&lt;String&gt; newVerList = Arrays.asList(newVersion.split("\\."));
 List&lt;String&gt; oldVerList = Arrays.asList(olderVerison.split("\\."));

 int diff = newVerList.size() - oldVerList.size();
 List&lt;String&gt; newList = new ArrayList&lt;&gt;();
 if (diff &gt; 0) {
 newList.addAll(oldVerList);
 for (int i = 0; i &lt; diff; i++) {
 newList.add("0");
 }
 return examineArray(newList, newVerList, diff);
 } else if (diff &lt; 0) {
 newList.addAll(newVerList);
 for (int i = 0; i &lt; -diff; i++) {
 newList.add("0");
 }
 return examineArray(oldVerList, newList, diff);
 } else {
 return examineArray(oldVerList, newVerList, diff);
 }

 }

 public static boolean examineArray(List&lt;String&gt; oldList, List&lt;String&gt; newList, int diff) {
 boolean newVersionGreater = false;
 for (int i = 0; i &lt; oldList.size(); i++) {
 if (Integer.parseInt(newList.get(i)) &gt; Integer.parseInt(oldList.get(i))) {
 newVersionGreater = true;
 break;
 } else if (Integer.parseInt(newList.get(i)) &lt; Integer.parseInt(oldList.get(i))) {
 newVersionGreater = false;
 break;
 } else {
 newVersionGreater = diff &gt; 0;
 }
 }

 return newVersionGreater;
 }
</code></pre>

blocks|key|1503653|text|我写了一个小的Java/Android库来比较版本号：https://github.com/G00fY2/version-compare|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1503654|它主要做的是：|1503655|++public+int+compareVersions(String+versionA,+String+versionB)+{
++++String[]+versionTokensA+=+versionA.split("\\.");
++++String[]+versionTokensB+=+versionB.split("\\.");
++++List<Integer>+versionNumbersA+=+new+ArrayList<>();
++++List<Integer>+versionNumbersB+=+new+ArrayList<>();

++++for+(String+versionToken+:+versionTokensA)+{
++++++versionNumbersA.add(Integer.parseInt(versionToken));
++++}
++++for+(String+versionToken+:+versionTokensB)+{
++++++versionNumbersB.add(Integer.parseInt(versionToken));
++++}

++++final+int+versionASize+=+versionNumbersA.size();
++++final+int+versionBSize+=+versionNumbersB.size();
++++int+maxSize+=+Math.max(versionASize,+versionBSize);

++++for+(int+i+=+0;+i+<+maxSize;+i%2B%2B)+{
++++++if+((i+<+versionASize+?+versionNumbersA.get(i)+:+0)+>+(i+<+versionBSize+?+versionNumbersB.get(i)+:+0))+{
++++++++return+1;
++++++}+else+if+((i+<+versionASize+?+versionNumbersA.get(i)+:+0)+<+(i+<+versionBSize+?+versionNumbersB.get(i)+:+0))+{
++++++++return+-1;
++++++}
++++}
++++return+0;
++}|code-block|syntax|javascript|1503656|此代码段不提供任何错误检查或处理。除此之外，我的库还支持像"1.2-rc“>+"1.2-beta”这样的后缀。|1503657|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/G00fY2/version-compare^0|R|15|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

I have written a small Java/Android library for comparing version numbers: <a href="https://github.com/G00fY2/version-compare" rel="nofollow noreferrer">https://github.com/G00fY2/version-compare</a>

What it basically does is this:

<pre><code> public int compareVersions(String versionA, String versionB) {
 String[] versionTokensA = versionA.split("\\.");
 String[] versionTokensB = versionB.split("\\.");
 List&lt;Integer&gt; versionNumbersA = new ArrayList&lt;&gt;();
 List&lt;Integer&gt; versionNumbersB = new ArrayList&lt;&gt;();

 for (String versionToken : versionTokensA) {
 versionNumbersA.add(Integer.parseInt(versionToken));
 }
 for (String versionToken : versionTokensB) {
 versionNumbersB.add(Integer.parseInt(versionToken));
 }

 final int versionASize = versionNumbersA.size();
 final int versionBSize = versionNumbersB.size();
 int maxSize = Math.max(versionASize, versionBSize);

 for (int i = 0; i &lt; maxSize; i++) {
 if ((i &lt; versionASize ? versionNumbersA.get(i) : 0) &gt; (i &lt; versionBSize ? versionNumbersB.get(i) : 0)) {
 return 1;
 } else if ((i &lt; versionASize ? versionNumbersA.get(i) : 0) &lt; (i &lt; versionBSize ? versionNumbersB.get(i) : 0)) {
 return -1;
 }
 }
 return 0;
 }
</code></pre>

This snippet doesn't offer any error checks or handling. Beside that my library also supports suffixes like "1.2-rc" > "1.2-beta".

blocks|key|1503720|text|使用Java+8+Stream替换组件中的前导零。这段代码通过了interviewbit.com上的所有测试|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1503721|public+int+compareVersion(String+A,+String+B)+{
++++List<String>+strList1+=+Arrays.stream(A.split("\\."))
+++++++++++++++++++++++++++++++++++++++++++.map(s+->+s.replaceAll("%5E0%2B(?!$)",+""))
+++++++++++++++++++++++++++++++++++++++++++.collect(Collectors.toList());
++++List<String>+strList2+=+Arrays.stream(B.split("\\."))
+++++++++++++++++++++++++++++++++++++++++++.map(s+->+s.replaceAll("%5E0%2B(?!$)",+""))
+++++++++++++++++++++++++++++++++++++++++++.collect(Collectors.toList());
++++int+len1+=+strList1.size();
++++int+len2+=+strList2.size();
++++int+i+=+0;
++++while(i+<+len1+&&+i+<+len2){
++++++++if+(strList1.get(i).length()+>+strList2.get(i).length())+return+1;
++++++++if+(strList1.get(i).length()+<+strList2.get(i).length())+return+-1;
++++++++int+result+=+new+Long(strList1.get(i)).compareTo(new+Long(strList2.get(i)));
++++++++if+(result+!=+0)+return+result;
++++++++i%2B%2B;
++++}
++++while+(i+<+len1){
++++++++if+(!strList1.get(i%2B%2B).equals("0"))+return+1;
++++}
++++while+(i+<+len2){
++++++++if+(!strList2.get(i%2B%2B).equals("0"))+return+-1;
++++}
++++return+0;
}|code-block|syntax|javascript|1503722|entityMap|0|LINK|mutability|MUTABLE|url|https://www.interviewbit.com/problems/compare-version-numbers/^0|W|G|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Using Java 8 Stream to replace leading zeroes in components. This code passed all tests on <a href="https://www.interviewbit.com/problems/compare-version-numbers/" rel="nofollow noreferrer">interviewbit.com</a>

<pre><code>public int compareVersion(String A, String B) {
 List&lt;String&gt; strList1 = Arrays.stream(A.split("\\."))
 .map(s -&gt; s.replaceAll("^0+(?!$)", ""))
 .collect(Collectors.toList());
 List&lt;String&gt; strList2 = Arrays.stream(B.split("\\."))
 .map(s -&gt; s.replaceAll("^0+(?!$)", ""))
 .collect(Collectors.toList());
 int len1 = strList1.size();
 int len2 = strList2.size();
 int i = 0;
 while(i &lt; len1 &amp;&amp; i &lt; len2){
 if (strList1.get(i).length() &gt; strList2.get(i).length()) return 1;
 if (strList1.get(i).length() &lt; strList2.get(i).length()) return -1;
 int result = new Long(strList1.get(i)).compareTo(new Long(strList2.get(i)));
 if (result != 0) return result;
 i++;
 }
 while (i &lt; len1){
 if (!strList1.get(i++).equals("0")) return 1;
 }
 while (i &lt; len2){
 if (!strList2.get(i++).equals("0")) return -1;
 }
 return 0;
}
</code></pre>

blocks|key|1503838|text|对于将要根据版本号显示Force+Update+Alert的人，我有一个想法。在比较Android当前应用版本和firebase远程配置版本之间的版本时，可以使用此选项。这并不是所问问题的确切答案，但这肯定会对某人有所帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503839|import+java.util.List;
import+java.util.ArrayList;
import+java.util.Arrays;
public+class+Main
{
++static+String+firebaseVersion+=+"2.1.3";+//+or+2.1
++static+String+appVersion+=+"2.1.4";
++static+List<String>+firebaseVersionArray;
++static+List<String>+appVersionArray;
++static+boolean+isNeedToShowAlert+=+false;
++public+static+void+main+(String[]args)
++{
++++System.out.println+("Hello+World");
++++firebaseVersionArray+=+new+ArrayList<String>(Arrays.asList(firebaseVersion.split+("\\.")));
++++appVersionArray+=+new+ArrayList<String>(Arrays.asList(appVersion.split+("\\.")));
++++if(appVersionArray.size()+<+firebaseVersionArray.size())+{
++++++++appVersionArray.add("0");
++++}
++++if(firebaseVersionArray.size()+<+appVersionArray.size())+{
++++++++firebaseVersionArray.add("0");
++++}
++++isNeedToShowAlert+=+needToShowAlert();+//Returns+false
++++System.out.println+(isNeedToShowAlert);

++}
++static+boolean+needToShowAlert()+{
++++++boolean+result+=+false;
++++++for(int+i+=+0+;+i+<+appVersionArray.size()+;+i%2B%2B)+{
++++++++++if+(Integer.parseInt(appVersionArray.get(i))+==+Integer.parseInt(firebaseVersionArray.get(i)))+{
++++++++++++++continue;
++++++++++}+else+if+(Integer.parseInt(appVersionArray.get(i))+>+Integer.parseInt(firebaseVersionArray.get(i))){
+++++++++++++result+=+false;
+++++++++++++break;
++++++++++}+else+if+(Integer.parseInt(appVersionArray.get(i))+<+Integer.parseInt(firebaseVersionArray.get(i)))+{
+++++++++++++result+=+true;
+++++++++++++break;++
++++++++++}
++++++}
++++++return+result;
++}
}|code-block|syntax|javascript|1503840|您可以通过在https://www.onlinegdb.com/online_java_compiler中复制粘贴来运行此代码|offset|length|1503841|entityMap|0|LINK|mutability|MUTABLE|url|https://www.onlinegdb.com/online_java_compiler^0|0|0|6|1A|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

For someone who is going to show Force Update Alert based on version number I have a following Idea. This may be used when comparing the versions between Android Current App version and firebase remote config version. This is not exactly the answer for the question asked but this will help someone definitely.

<pre><code>import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
public class Main
{
 static String firebaseVersion = "2.1.3"; // or 2.1
 static String appVersion = "2.1.4";
 static List&lt;String&gt; firebaseVersionArray;
 static List&lt;String&gt; appVersionArray;
 static boolean isNeedToShowAlert = false;
 public static void main (String[]args)
 {
 System.out.println ("Hello World");
 firebaseVersionArray = new ArrayList&lt;String&gt;(Arrays.asList(firebaseVersion.split ("\\.")));
 appVersionArray = new ArrayList&lt;String&gt;(Arrays.asList(appVersion.split ("\\.")));
 if(appVersionArray.size() &lt; firebaseVersionArray.size()) {
 appVersionArray.add("0");
 }
 if(firebaseVersionArray.size() &lt; appVersionArray.size()) {
 firebaseVersionArray.add("0");
 }
 isNeedToShowAlert = needToShowAlert(); //Returns false
 System.out.println (isNeedToShowAlert);

 }
 static boolean needToShowAlert() {
 boolean result = false;
 for(int i = 0 ; i &lt; appVersionArray.size() ; i++) {
 if (Integer.parseInt(appVersionArray.get(i)) == Integer.parseInt(firebaseVersionArray.get(i))) {
 continue;
 } else if (Integer.parseInt(appVersionArray.get(i)) &gt; Integer.parseInt(firebaseVersionArray.get(i))){
 result = false;
 break;
 } else if (Integer.parseInt(appVersionArray.get(i)) &lt; Integer.parseInt(firebaseVersionArray.get(i))) {
 result = true;
 break; 
 }
 }
 return result;
 }
}
</code></pre>

You can run this code by copy pasting in 
<a href="https://www.onlinegdb.com/online_java_compiler" rel="nofollow noreferrer">https://www.onlinegdb.com/online_java_compiler</a>

blocks|key|1503843|text|public+static+void+main(String[]+args)+{

++++String+version1+=+"1.0";
++++String+version2+=+"1.0.0";
++++String[]+version1_splits+=+version1.split("\\.");
++++String[]+version2_splits+=+version2.split("\\.");
++++int+length+=+version1_splits.length+>=+version2_splits.length+?+version1_splits.length+:+version2_splits.length;
++++int+i=0;
++++for(;i<length;i%2B%2B){
++++++++int+version1_int+=+getValue(version1_splits,i);
++++++++int+version2_int+=+getValue(version2_splits,i);
++++++++if(version1_int+>+version2_int){
++++++++++++System.out.println("version1+>+version2");
++++++++++++break;
++++++++}
++++++++else+if(version1_int+<+version2_int){
++++++++++++System.out.println("version2+>+version1");
++++++++++++break;
++++++++}
++++++++else{
++++++++++++if(i+==+length-1)
++++++++++++System.out.println("version1+=+version2");
++++++++}
++++}
}

private+static+int+getValue(String[]+version1_splits,+int+i)+{
++++int+temp;
++++try{
++++++++temp+=+Integer.valueOf(version1_splits[i]);
++++}
++++catch(IndexOutOfBoundsException+e){
++++++++temp=0;
++++}

++++return+temp;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503844|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static void main(String[] args) {

 String version1 = "1.0";
 String version2 = "1.0.0";
 String[] version1_splits = version1.split("\\.");
 String[] version2_splits = version2.split("\\.");
 int length = version1_splits.length &gt;= version2_splits.length ? version1_splits.length : version2_splits.length;
 int i=0;
 for(;i&lt;length;i++){
 int version1_int = getValue(version1_splits,i);
 int version2_int = getValue(version2_splits,i);
 if(version1_int &gt; version2_int){
 System.out.println("version1 &gt; version2");
 break;
 }
 else if(version1_int &lt; version2_int){
 System.out.println("version2 &gt; version1");
 break;
 }
 else{
 if(i == length-1)
 System.out.println("version1 = version2");
 }
 }
}

private static int getValue(String[] version1_splits, int i) {
 int temp;
 try{
 temp = Integer.valueOf(version1_splits[i]);
 }
 catch(IndexOutOfBoundsException e){
 temp=0;
 }

 return temp;
}
</code></pre>

blocks|key|1719169|text|kotlin：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719170|@kotlin.jvm.Throws(InvalidParameterException::class)
fun+String.versionCompare(remoteVersion:+String?):+Int+{
++++val+remote+=+remoteVersion?.splitToSequence(".")?.toList()+?:+return+1
++++val+local+=+this.splitToSequence(".").toList()

++++if(local.filter+{+it.toIntOrNull()+!=+null+}.size+!=+local.size)+throw+InvalidParameterException("version+invalid:+$this")
++++if(remote.filter+{+it.toIntOrNull()+!=+null+}.size+!=+remote.size)+throw+InvalidParameterException("version+invalid:+$remoteVersion")

++++val+totalRange+=+0+until+kotlin.math.max(local.size,+remote.size)
++++for+(i+in+totalRange)+{
++++++++if+(i+<+remote.size+&&+i+<+local.size)+{
++++++++++++val+result+=+local[i].compareTo(remote[i])
++++++++++++if+(result+!=+0)+return+result
++++++++}+else+(
++++++++++++return+local.size.compareTo(remote.size)
++++++++)
++++}
++++return+0
}|code-block|syntax|javascript|1719171|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

kotlin:
<pre><code>@kotlin.jvm.Throws(InvalidParameterException::class)
fun String.versionCompare(remoteVersion: String?): Int {
 val remote = remoteVersion?.splitToSequence(&quot;.&quot;)?.toList() ?: return 1
 val local = this.splitToSequence(&quot;.&quot;).toList()

 if(local.filter { it.toIntOrNull() != null }.size != local.size) throw InvalidParameterException(&quot;version invalid: $this&quot;)
 if(remote.filter { it.toIntOrNull() != null }.size != remote.size) throw InvalidParameterException(&quot;version invalid: $remoteVersion&quot;)

 val totalRange = 0 until kotlin.math.max(local.size, remote.size)
 for (i in totalRange) {
 if (i &lt; remote.size &amp;&amp; i &lt; local.size) {
 val result = local[i].compareTo(remote[i])
 if (result != 0) return result
 } else (
 return local.size.compareTo(remote.size)
 )
 }
 return 0
}
</code></pre>

blocks|key|1718437|text|我喜欢@Peter+Lawrey的想法，并将其扩展到更多的限制：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718438|++++/**
++++*+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%2B%2B)+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)+==+'.'+%7C%7C+s.charAt(i)+==+'0')){
++++++++++if(s.charAt(i)+==+'.')+k+=+i-1;
++++++++++i--;++
++++++++}+
++++++++return+s.substring(0,k%2B1);
++++}

++++/**
++++*+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);
++++}|code-block|syntax|javascript|1718439|希望这能帮助到别人。它通过了interviewbit和leetcode中的所有测试用例(需要取消compareVersion函数中两行的注释)。|1718440|易于测试！|1718441|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I liked the idea from @Peter Lawrey, And i extended it to further limits : 

<pre><code> /**
 * 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&lt;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 &gt;= 0 &amp;&amp; (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 &gt; v2, returns 0 if v1 == v2,
 * and returns -1 if v1 &lt; 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 &gt; 0 ? 1 : (cmp &lt; 0 ? -1 : 0);
 }
</code></pre>

Hope it helps someone. It passed all test cases in interviewbit and leetcode (need to uncomment two lines in compareVersion function). 

Easily tested !

blocks|key|1718205|text|public+class+VersionComparator+{

++++/*+loop+through+both+version+strings
+++++*+then+loop+through+the+inner+string+to+computer+the+val+of+the+int
+++++*+for+each+integer+read,+do+num*10%2B<integer+read>
+++++*+and+stop+when+stumbling+upon+'.'
+++++*+When+'.'+is+encountered...
+++++*+see+if+'.'+is+encountered+for+both+strings
+++++*+if+it+is+then+compare+num1+and+num2+
+++++*+if+num1+==+num2...+iterate+over+p1%2B%2B,+p2%2B%2B
+++++*+else+return+(num1+>+num2)+?+1+:+-1
+++++*+If+both+the+string+end+then+compare(num1,+num2)+return+0,+1,+-1
+++++*+else+loop+through+the+longer+string+and+
+++++*+verify+if+it+only+has+trailing+zeros
+++++*+If+it+only+has+trailing+zeros+then+return+0
+++++*+else+it+is+greater+than+the+other+string
+++++*/
++++public+static+int+compareVersions(String+v1,+String+v2)+{
++++++++int+num1+=+0;
++++++++int+num2+=+0;
++++++++int+p1+=+0;
++++++++int+p2+=+0;

++++++++while+(p1+<+v1.length()+&&+p2+<+v2.length())+{
++++++++++++num1+=+Integer.parseInt(v1.charAt(p1)+%2B+"");
++++++++++++num2+=+Integer.parseInt(v2.charAt(p2)+%2B+"");
++++++++++++p1%2B%2B;
++++++++++++p2%2B%2B;

++++++++++++while+(p1+<+v1.length()+&&+p2+<+v2.length()+&&+v1.charAt(p1)+!=+'.'+&&+v2.charAt(p2)+!=+'.')+{
++++++++++++++++if+(p1+<+v1.length())+num1+=+num1+*+10+%2B+Integer.parseInt(v1.charAt(p1)+%2B+"");
++++++++++++++++if+(p2+<+v2.length())+num2+=+num2+*+10+%2B+Integer.parseInt(v2.charAt(p2)+%2B+"");
++++++++++++++++p1%2B%2B;
++++++++++++++++p2%2B%2B;
++++++++++++}

++++++++++++if+(p1+<+v1.length()+&&+p2+<+v2.length()+&&+v1.charAt(p1)+==+'.'+&&+v2.charAt(p2)+==+'.')+{
++++++++++++++++if+((num1+%5E+num2)+==+0)+{
++++++++++++++++++++p1%2B%2B;
++++++++++++++++++++p2%2B%2B;
++++++++++++++++}
++++++++++++++++else+return+(num1+>+num2)+?+1+:+-1;
++++++++++++}
++++++++++++else+if+(p1+<+v1.length()+&&+p2+<+v2.length()+&&+v1.charAt(p1)+==+'.')+return+-1;
++++++++++++else+if+(p1+<+v1.length()+&&+p2+<+v2.length()+&&+v2.charAt(p2)+==+'.')+return+1;
++++++++}

++++++++if+(p1+==+v1.length()+&&+p2+==+v2.length())+{
++++++++++++if+((num1+%5E+num2)+==+0)+return+0;
++++++++++++else+return+(num1+>+num2)+?+1+:+-1;
++++++++}
++++++++else+if+(p1+==+v1.length())+{
++++++++++++if+((num1+%5E+num2)+==+0)+{
++++++++++++++++while+(p2+<+v2.length())+{
++++++++++++++++++++if+(v2.charAt(p2)+!=+'.'+&&+v2.charAt(p2)+!=+'0')+return+-1;
++++++++++++++++++++p2%2B%2B;
++++++++++++++++}
++++++++++++++++return+0;
++++++++++++}
++++++++++++else+return+(num1+>+num2)+?+1+:+-1;
++++++++}
++++++++else+{
++++++++++++if+((num1+%5E+num2)+==+0)+{
++++++++++++++++while+(p1+<+v1.length())+{
++++++++++++++++++++if+(v1.charAt(p1)+!=+'.'+&&+v1.charAt(p1)+!=+'0')+return+1;
++++++++++++++++++++p1%2B%2B;
++++++++++++++++}
++++++++++++++++return+0;
++++++++++++}
++++++++++++else+return+(num1+>+num2)+?+1+:+-1;
++++++++}
++++}

++++public+static+void+main(String[]+args)+{
++++++++System.out.println(compareVersions("11.23",+"11.21.1.0.0.1.0")+%5E+1);
++++++++System.out.println(compareVersions("11.21.1.0.0.1.0",+"11.23")+%5E+-1);
++++++++System.out.println(compareVersions("11.23",+"11.23.0.0.0.1.0")+%5E+-1);
++++++++System.out.println(compareVersions("11.2",+"11.23")+%5E+-1);
++++++++System.out.println(compareVersions("11.23",+"11.21.1.0.0.1.0")+%5E+1);
++++++++System.out.println(compareVersions("1.21.1.0.0.1.0",+"2.23")+%5E+-1);
++++++++System.out.println(compareVersions("11.23",+"11.21.1.0.0.1.0")+%5E+1);
++++++++System.out.println(compareVersions("11.23.0.0.0.0.0",+"11.23")+%5E+0);
++++++++System.out.println(compareVersions("11.23",+"11.21.1.0.0.1.0")+%5E+1);
++++++++System.out.println(compareVersions("1.5.1.3",+"1.5.1.3.0")+%5E+0);
++++++++System.out.println(compareVersions("1.5.1.4",+"1.5.1.3.0")+%5E+1);
++++++++System.out.println(compareVersions("1.2.1.3",+"1.5.1.3.0")+%5E+-1);
++++++++System.out.println(compareVersions("1.2.1.3",+"1.22.1.3.0")+%5E+-1);
++++++++System.out.println(compareVersions("1.222.1.3",+"1.22.1.3.0")+%5E+1);
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1718206|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class VersionComparator {

 /* loop through both version strings
 * then loop through the inner string to computer the val of the int
 * for each integer read, do num*10+&lt;integer read&gt;
 * and stop when stumbling upon '.'
 * When '.' is encountered...
 * see if '.' is encountered for both strings
 * if it is then compare num1 and num2 
 * if num1 == num2... iterate over p1++, p2++
 * else return (num1 &gt; num2) ? 1 : -1
 * If both the string end then compare(num1, num2) return 0, 1, -1
 * else loop through the longer string and 
 * verify if it only has trailing zeros
 * If it only has trailing zeros then return 0
 * else it is greater than the other string
 */
 public static int compareVersions(String v1, String v2) {
 int num1 = 0;
 int num2 = 0;
 int p1 = 0;
 int p2 = 0;

 while (p1 &lt; v1.length() &amp;&amp; p2 &lt; v2.length()) {
 num1 = Integer.parseInt(v1.charAt(p1) + "");
 num2 = Integer.parseInt(v2.charAt(p2) + "");
 p1++;
 p2++;

 while (p1 &lt; v1.length() &amp;&amp; p2 &lt; v2.length() &amp;&amp; v1.charAt(p1) != '.' &amp;&amp; v2.charAt(p2) != '.') {
 if (p1 &lt; v1.length()) num1 = num1 * 10 + Integer.parseInt(v1.charAt(p1) + "");
 if (p2 &lt; v2.length()) num2 = num2 * 10 + Integer.parseInt(v2.charAt(p2) + "");
 p1++;
 p2++;
 }

 if (p1 &lt; v1.length() &amp;&amp; p2 &lt; v2.length() &amp;&amp; v1.charAt(p1) == '.' &amp;&amp; v2.charAt(p2) == '.') {
 if ((num1 ^ num2) == 0) {
 p1++;
 p2++;
 }
 else return (num1 &gt; num2) ? 1 : -1;
 }
 else if (p1 &lt; v1.length() &amp;&amp; p2 &lt; v2.length() &amp;&amp; v1.charAt(p1) == '.') return -1;
 else if (p1 &lt; v1.length() &amp;&amp; p2 &lt; v2.length() &amp;&amp; v2.charAt(p2) == '.') return 1;
 }

 if (p1 == v1.length() &amp;&amp; p2 == v2.length()) {
 if ((num1 ^ num2) == 0) return 0;
 else return (num1 &gt; num2) ? 1 : -1;
 }
 else if (p1 == v1.length()) {
 if ((num1 ^ num2) == 0) {
 while (p2 &lt; v2.length()) {
 if (v2.charAt(p2) != '.' &amp;&amp; v2.charAt(p2) != '0') return -1;
 p2++;
 }
 return 0;
 }
 else return (num1 &gt; num2) ? 1 : -1;
 }
 else {
 if ((num1 ^ num2) == 0) {
 while (p1 &lt; v1.length()) {
 if (v1.charAt(p1) != '.' &amp;&amp; v1.charAt(p1) != '0') return 1;
 p1++;
 }
 return 0;
 }
 else return (num1 &gt; num2) ? 1 : -1;
 }
 }

 public static void main(String[] args) {
 System.out.println(compareVersions("11.23", "11.21.1.0.0.1.0") ^ 1);
 System.out.println(compareVersions("11.21.1.0.0.1.0", "11.23") ^ -1);
 System.out.println(compareVersions("11.23", "11.23.0.0.0.1.0") ^ -1);
 System.out.println(compareVersions("11.2", "11.23") ^ -1);
 System.out.println(compareVersions("11.23", "11.21.1.0.0.1.0") ^ 1);
 System.out.println(compareVersions("1.21.1.0.0.1.0", "2.23") ^ -1);
 System.out.println(compareVersions("11.23", "11.21.1.0.0.1.0") ^ 1);
 System.out.println(compareVersions("11.23.0.0.0.0.0", "11.23") ^ 0);
 System.out.println(compareVersions("11.23", "11.21.1.0.0.1.0") ^ 1);
 System.out.println(compareVersions("1.5.1.3", "1.5.1.3.0") ^ 0);
 System.out.println(compareVersions("1.5.1.4", "1.5.1.3.0") ^ 1);
 System.out.println(compareVersions("1.2.1.3", "1.5.1.3.0") ^ -1);
 System.out.println(compareVersions("1.2.1.3", "1.22.1.3.0") ^ -1);
 System.out.println(compareVersions("1.222.1.3", "1.22.1.3.0") ^ 1);
 }
}
</code></pre>

blocks|key|1503118|text|下面是一个优化的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503119|public+static+final+Comparator<CharSequence>+VERSION_ORDER+=+new+Comparator<CharSequence>()+{

++@Override
++public+int+compare+(CharSequence+lhs,+CharSequence+rhs)+{
++++int+ll+=+lhs.length(),+rl+=+rhs.length(),+lv+=+0,+rv+=+0,+li+=+0,+ri+=+0;
++++char+c;
++++do+{
++++++lv+=+rv+=+0;
++++++while+(--ll+>=+0)+{
++++++++c+=+lhs.charAt(li%2B%2B);
++++++++if+(c+<+'0'+%7C%7C+c+>+'9')
++++++++++break;
++++++++lv+=+lv*10+%2B+c+-+'0';
++++++}
++++++while+(--rl+>=+0)+{
++++++++c+=+rhs.charAt(ri%2B%2B);
++++++++if+(c+<+'0'+%7C%7C+c+>+'9')
++++++++++break;
++++++++rv+=+rv*10+%2B+c+-+'0';
++++++}
++++}+while+(lv+==+rv+&&+(ll+>=+0+%7C%7C+rl+>=+0));
++++return+lv+-+rv;
++}

};|code-block|syntax|javascript|1503120|结果：|1503121|"0.1"+-+"1.0"+=+-1
"1.0"+-+"1.0"+=+0
"1.0"+-+"1.0.0"+=+0
"10"+-+"1.0"+=+9
"3.7.6"+-+"3.7.11"+=+-5
"foobar"+-+"1.0"+=+-1|1503122|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's an optimized implementation:

<pre><code>public static final Comparator&lt;CharSequence&gt; VERSION_ORDER = new Comparator&lt;CharSequence&gt;() {

 @Override
 public int compare (CharSequence lhs, CharSequence rhs) {
 int ll = lhs.length(), rl = rhs.length(), lv = 0, rv = 0, li = 0, ri = 0;
 char c;
 do {
 lv = rv = 0;
 while (--ll &gt;= 0) {
 c = lhs.charAt(li++);
 if (c &lt; '0' || c &gt; '9')
 break;
 lv = lv*10 + c - '0';
 }
 while (--rl &gt;= 0) {
 c = rhs.charAt(ri++);
 if (c &lt; '0' || c &gt; '9')
 break;
 rv = rv*10 + c - '0';
 }
 } while (lv == rv &amp;&amp; (ll &gt;= 0 || rl &gt;= 0));
 return lv - rv;
 }

};
</code></pre>

Result:

<pre><code>"0.1" - "1.0" = -1
"1.0" - "1.0" = 0
"1.0" - "1.0.0" = 0
"10" - "1.0" = 9
"3.7.6" - "3.7.11" = -5
"foobar" - "1.0" = -1
</code></pre>

Is there a standard idiom for comparing version numbers? I can't just use a straight String compareTo because I don't know yet what the maximum number of point releases there will be. I need to compare the versions and have the following hold true:

<pre><code>1.0 &lt; 1.1
1.0.1 &lt; 1.1
1.9 &lt; 1.10
</code></pre>

How do you compare two version Strings in Java?

Android

Kotlin

Java

有没有比较版本号的标准习惯用法？我不能只使用一个直接的字符串compareTo，因为我还不知道最大释放点的数量是多少。我需要比较不同的版本，并满足以下条件：1.0 < 1.11.0.1 < 1.11.9 < 1.10

问在Java中如何比较两个版本的字符串？
EN

回答 25

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中如何比较两个版本的字符串？EN

回答 25

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中如何比较两个版本的字符串？
EN