我如何获得最大版本？

Question

我如何排序String阵列

String[] s = {"0.1","0.3","0.6","0.4","0.5","0.2","0.7","0.8","0.9","0.10"}; 

排序我不意味在这里将其转换成整数，并得到结果作为0.9。

这里我想要得到的值为0.10。

这里在这种情况下，如果字符串数组包含1.1那么最大值将是1.1。

我能够获得最高值，如果数组是这样的，即

String[] s = {"0.1","0.4","0.3","0.4","0.5","0.2","0.7","1.8","2.9","3.1"}; 

我的代码将这个字符串数组工作，但假设如果

String[] s = {"0.1","1.4","1.3","0.4","0.5","0.2","2.7","1.8","2.9","0.1"}; 

我的代码。

public String createNewVersion(
      String[] entityVersionHistory) { 

Map<Integer, List<Integer>> m_Map1 = new HashMap<Integer, List<Integer>>(); 

String prevKey = "0"; 
String currentKey = null; 

List<Integer> list = new ArrayList<Integer>(); 

for (String str : entityVersionHistory) 
{ 
    String[] splitVersion = str.split("\\."); 
    currentKey = splitVersion[0]; 
    if(!prevKey.equals(currentKey)) 
    { 
     Integer s = new Integer(splitVersion[1]); 

     m_Map1.put(Integer.valueOf(prevKey), list); 
     list = new ArrayList<Integer>(); 
     list.add(s); 

     prevKey = currentKey; 
    } 
    else 
    { 
     Integer s = new Integer(splitVersion[1]); 
     list.add(s); 
    } 
} 
m_Map1.put(Integer.valueOf(prevKey), list); 

我该如何做到这一点？

Answer 1

这基本上是Anny-Mousses答案在代码中：限制是，只有数字和点允许在版本号。

public class Version implements Comparable<Version> { 

    private int[] version; 

    public Version(String str) { 
     if (!str.matches("\\d+[.\\d]*?\\d")) { 
      throw new IllegalArgumentException(
        "Version must start and end with digit and" 
        + "only contain digits and dots." 
        + " You provided '" + str + "'"); 
     } 
     String[] tokens = str.split("\\."); 
     version = new int[tokens.length]; 
     for (int i = 0; i < tokens.length; i++) { 
      version[i] = Integer.parseInt(tokens[i], 10); 
     } 
    } 

    @Override 
    public int compareTo(Version other) { 
     Version shorterOne = 
       this.version.length < other.version.length ? 
       this : other; 
     int min = shorterOne.version.length; 
     for (int i = 0; i < min; i++) { 
      if (this.version[i] != other.version[i]) { 
       return this.version[i] - other.version[i]; 
      } 
     } 
     return this.version.length - other.version.length; 
    } 

    @Override 
    public String toString() { 
     StringBuilder str = new StringBuilder(2 * version.length); 
     for (Integer i : version) { 
      str.append(i).append('.'); 
     } 
     return str.deleteCharAt(str.length() - 1).toString(); 
    } 

    public static void main(String[] args) { 
     String[] s = {"1.4","1.3","0.4","0.5","0.2","2.7","1.8","2.9","0.1"}; 
     List<Version> list = new ArrayList<>(s.length); 
     for (String str : s) { 
      list.add(new Version(str)); 
     } 
     Version max = Collections.max(list); 
     System.out.println(max); 
    } 
} 

Answer 2

这并不像您想象的那么简单。因为也有版本号码，如3.1beta。我不打算在下面全面讨论这些问题，只是勾勒出一些出现的挑战。

但基本思想如下：

1. 在.拆分串入一个数组，转换的各个部件成整数。

2. 比较分组。如果两个号码在第一个组件上达成一致，请跳到下一个。

所以，给出的版本号3.10.1和3.9.2我们首先将其转换为整型数组：{ 3, 10, 1 }和{3, 9, 2}。然后我们测试第一个组件，但3 == 3，所以我们跳到下一个组件。 10 > 9，所以结果是第一个更大。

现在，如果你想支持beta和类似的东西，它会变得非常混乱。以Debian版本编号为例。除了点之外，它还有一个时期分隔符。所以一个2:1.0 > 2.0（一个新的时代比以前的时代编号更大）的视图。 A -分隔修订号码。所以2-2 < 2.1-1，因为2 < 2.1（和修订是次要的主版本号！）。还有负号版本。因此1.0~beta < 1.0，但1.0final > 1.0 - 将此读作“1.0减去beta”和“1.0 plus final”。

关于如何读取这些信息没有独特的标准。 .分开了较低优先级的组件，而~是预发布的流行指标（这就是为什么它应该在非后缀版本之前进行排序）的常见约定。

Answer 3

如果不是使用Integer.parseInt（）;你可以使用Double.parseDouble（）;你可以很容易地得到最大值..我没有看到任何问题

Answer 4

尝试为

Arrays.sort(s, new Comparator<String>() { 
     @Override 
     public int compare(String o1, String o2) { 
      String[] a1 = o1.split("\\."); 
      String[] a2 = o2.split("\\."); 
      int c1 = Integer.parseInt(a1[0]) - Integer.parseInt(a2[0]); 
      if (c1 != 0) { 
       return c1; 
      } 
      return a1[1].compareTo(a2[1]); 
     } 

    });