Java program to sort a versioning string in an ascending order

I have a list containing version strings, such as things:

List<String> versions_list = Arrays.asList("1.1.2", "1.0.0", "1.3.3", "1.0.12", "1.0.2");

I would like to sort it, so the result would be something like this:

["1.0.0", "1.0.2", "1.0.12", "1.1.2", "1.3.3"]

How to do this in Java.

Here is a modern solution, using Comparator.comparing to build a version string comparator, based on the pre-existing standard library Arrays.compare(int[]) method.

    List<String> versionList = Arrays.asList("1.1.2", "1.0.0", "1.3.3", "1.0.12", "1.0.2");

    Pattern pattern = Pattern.compile("\\.");
    Comparator<String> versionComparator = Comparator.comparing(
        str -> pattern.splitAsStream(str)
            .mapToInt(Integer::parseInt)
            .toArray(),
        Arrays::compare);
    versionList.sort(versionComparator);
    
    System.out.println(versionList);

You can do this using Comparator as shown below:

    List<String> sorted = List.of("1.1.2", "1.0.0", "1.3.3", "1.0.12", "1.0.2")
            .stream()
            .sorted((s1, s2) -> {
                String[] s1Parts = s1.split("\\.");
                String[] s2Parts = s2.split("\\.");

                Integer[] s1IntParts = Arrays.stream(s1Parts).map(Integer::parseInt).toArray(Integer[]::new);
                Integer[] s2IntParts = Arrays.stream(s2Parts).map(Integer::parseInt).toArray(Integer[]::new);

                int comparisonResult = -1;
                for (int i=0; i<3; i++) {
                    comparisonResult = Integer.compare(s1IntParts[i], s2IntParts[i]);
                    if (comparisonResult != 0) {
                        break;
                    }
                }
                return comparisonResult;
            })
            .collect(Collectors.toList());

public static void main(String[] args) {
    String[] versions_list = {"1.1.2", "1.0.0", "1.3.3", "1.0.12", "1.0.2"};
    Arrays.sort(versions_list, (o1, o2) -> {
        String[] str1 = o1.split("\\.");
        String[] str2 = o2.split("\\.");
        if (!Integer.valueOf(str1[0]).equals(Integer.valueOf(str2[0])))
            return Integer.valueOf(str1[0]) - Integer.valueOf(str2[0]);
        if (!Integer.valueOf(str1[1]).equals(Integer.valueOf(str2[1])))
            return Integer.valueOf(str1[1]) - Integer.valueOf(str2[1]);
        return Integer.valueOf(str1[2]) - Integer.valueOf(str2[2]);
    });
    for (String str : versions_list) {
        System.out.println(str);
    }
}

sorry，I wirte code again
output：1.0.0 1.0.2 1.0.12 1.1.2 1.3.3, you also use cycle to do it!

Assuming:

List<String> versions = Arrays.asList("1.1.2", "1.0.0", "1.3.3", "1.0.12", "1.0.2");

You should use a custom Comparator as long as the default comparator cannot be applied to this type of the String, otherwise the numbers will not be sorted numerically (ex, 12 is considered lower than 2.

versions.sort(new Comparator<String>() {
	@Override
	public int compare(final String l, final String r) {
		String[] left = l.split("\\.");
		String[] right = r.split("\\.");
		int iterableLength = Math.min(left.length, right.length);
		for (int i=0; i<iterableLength; i++) {
			if (!left[i].equals(right[i])) {
				return Integer.parseInt(left[i]) - Integer.parseInt(right[i]);
			}
		}
		return 0;
	}
});

... using a lambda expression ...

versions.sort((l, r) -> {
	String[] left = l.split("\\.");
	String[] right = r.split("\\.");
	int iterableLength = Math.min(left.length, right.length);
	for (int i=0; i<iterableLength; i++) {
		if (!left[i].equals(right[i])) {
			return Integer.parseInt(left[i]) - Integer.parseInt(right[i]);
		}
	}
	return 0;
});

This is a very straightforward solution using Regex to split the version notation into 3 separate parts. Each part not equal to another is a subject for the numeric comparison, hence Integer.parseInt(String) is needed.

Here is one way using a lambda of the Comparator. Takes care of varying length version ids.

Comparator<String> comp = (a, b) -> {
	String[] aa = a.split("\\.");
	String[] bb = b.split("\\.");
	int r = 0;
	for (int i = 0; i < Math.min(aa.length, bb.length); i++) {
		r = Integer
				.compare(Integer.valueOf(aa[i]),Integer.valueOf(bb[i]));
		if (r != 0) {
			return r;
		}
	}
	return Integer.compare(aa.length, bb.length);
};
			
List<String> versions_list = Arrays.asList("1.1.2", "1.0.0",
		"1.3.3", "1.0.12", "1.0.0.12", "1.1.0.2", "1.0.2", "1.2.1.2.3");
versions_list.sort(comp);
System.out.println(versions_list);

Prints

[1.0.0, 1.0.0.12, 1.0.2, 1.0.12, 1.1.0.2, 1.1.2, 1.2.1.2.3, 1.3.3]


</details>