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

这并不像你想象的那么容易。因为版本号也是3.1beta。我不打算在下面详细讨论这些问题，只是勾勒出一些挑战。

但基本思路如下：

将.处的字符串分成数组，将各个组件转换为整数。
按组件比较。如果两个数字在第一个组件上达成一致，请跳到下一个。

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

现在，如果你想支持beta和类似的东西，它会变得非常混乱。以Debian版本编号为例。除了点，它还有一个 epoch 分隔符。因此2:1.0 > 2.0的验证（新纪元大于前一个纪元编号）。 -分隔修订号。所以2-2 < 2.1-1，因为2 < 2.1（并且版本是主版本号的次要版本！）。还有否定版本。所以1.0~beta < 1.0，但是1.0final > 1.0 - 将其读作“1.0减去beta”和“1.0加上最终结果”。

没有独特的标准可供阅读。只有.分隔低优先级组件的常见约定，而~是预发布的流行指标（这就是它应该在非后缀版本之前排序的原因）。

Answer 2

这在代码中基本上是Anny-Mousse's answer：限制是，版本号中只允许使用数字和点。

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 3

尝试

    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]);
        }

    });

我如何获得最高版本？

3 个答案: