Java 将数组中给定的语义版本作为字符串排序

我的意见如下：

字符串[]a={1.0.0,13.2.4,1.0.1,0.0.0,2.3.4,1.1.2,12.2.2,12.2.1}； 我希望输出为：

{0.0.0, 1.0.0, 1.0.1, 1.1.2, 2.3.4, 12.2.1, 12.2.2, 13.2.4};

我被困在无法找到比较两个元素的方法的地方。我的代码只比较一次，而不是比较所有元素：

公共静态字符串[]比较字符串[]a{ 字符串温度； 字符串[]a1； 字符串[]a2； 对于int i=0；iv2{ 温度=a[i]； a[i]=a[i+1]； a[i+1]=温度； j=a1.5米长； }如果v1==v2，则为else{ 持续 }否则{ j=a1.5米长； } } } 返回a； }

---

创建一个类、一个列表和一个比较器。

您可以使用比较器链将每个字符串按点拆分为一个数组，并按这些数组列中的整数值顺序排序：

字符串[]a={ 1.0.0, 13.2.4, 1.0.1, 0.0.0, 2.3.4, 1.1.2, 12.2.2, 12.2.1}; 字符串[]b=数组 //溪流 streama先生 //将字符串按点拆分为数组 //回流 .mapstr->str.split\\。 //按列对字符串数组排序：第一列、第二列和最后一列 .sortedComparator//使用比较器链 .comparingtarr->Integer.parseIntar[0] .Then比较tarr->Integer.parseIntar[1] .Then比较tarr->Integer.parseIntar[2] //将字符串数组重新连接为单个字符串 //回流 .maparr->String.join.，arr //返回排序数组 .toArrayString[]：：新的； //输出 System.out.printlnArrays.toString； // [0.0.0, 1.0.0, 1.0.1, 1.1.2, 2.3.4, 12.2.1, 12.2.2, 13.2.4]

---

另请参见：

这里有一个选项。为了演示，我使用了一个夸张的标题列表。你的也可以

首先，它将级别拆分为字符串数组。 然后，它使用这些数组根据节数计算存在的最大级别。 然后，它使用级别的数量来构建足以比较所有级别的比较器。 然后，它对已经使用比较器拆分的数组进行排序，并将它们重新连接到原始的节标题中。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Test implements Comparable {
    int a;
    int b;
    int c;
    public Test(String s) {
        String []s1 = s.split("\\.");

        this.a = Integer.parseInt(s1[0]);
        this.b = Integer.parseInt(s1[1]);
        this.c = Integer.parseInt(s1[2]);
    }
    public String toString () {
        return a + "." + b + "." + c;
    }

    public static void main (String[] args) {
        String []a = {"1.0.0", "13.2.4","1.0.1","0.0.0","2.3.4", "1.1.2","12.2.2","12.2.1"};
        List<Test> tests = Arrays.stream(a).map(Test::new).collect(Collectors.toList());
        System.out.println(tests);
        Collections.sort(tests);
        System.out.println(tests);
    }

    @Override
    public int compareTo(Object o) {
        Test t = (Test) o;
        if (t.a != a) return a - t.a;
        if (t.b != b) return b - t.b;
        return c - t.c;
    }
}

String[] sections = { "1.0.0", "13.2.4", "1.0.1", "0.0.0", "2.3.4",
        "1.1.1.1.2.2", "12.2.2.2", "12.2.1" };

// split up the levels into an array of arrays.
String[][] levels =
        Arrays.stream(sections).map(str -> str.split("\\."))
                .toArray(String[][]::new);

// calculate the maximum level
int maxLevel = 0;
for (String[] arr : levels) {
    maxLevel = Math.max(maxLevel, arr.length);
}

// now use that to build the comparator.
Comparator<String[]> comp = Comparator
        .comparingInt(arr -> Integer.parseInt(arr[0]));
for (int i = 1; i < maxLevel; i++) {
    final int k = i;
    comp = comp.thenComparingInt(
            arr -> Integer.parseInt(arr[k]));
}

// and then sort them and rejoin the numbers.
String[] result = Arrays.stream(levels).sorted(comp)
        .map(arr -> Arrays.stream(arr)
                .collect(Collectors.joining(".")))
        .toArray(String[]::new);


Arrays.stream(result).forEach(System.out::println);

0.0.0
1.0.0
1.0.1
1.1.1.1.2.2
2.3.4
12.2.1
12.2.2.2
13.2.4