Java tutorial
package org.apache.archiva.common.utils; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ import org.apache.commons.lang.ArrayUtils; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.math.NumberUtils; import java.util.ArrayList; import java.util.Comparator; import java.util.List; /** * VersionComparator - compare the parts of two version strings. * <p> * Technique. * </p> * <p> * * Split the version strings into parts by splitting on <code>"-._"</code> first, then breaking apart words from numbers. * </p> * <code> * "1.0" = "1", "0" * "1.0-alpha-1" = "1", "0", "alpha", "1" * "2.0-rc2" = "2", "0", "rc", "2" * "1.3-m2" = "1", "3", "m", "3" * </code> * <p> * compare each part individually, and when they do not match, perform the following test. * </p> * <p> * Numbers are calculated per normal comparison rules. * Words that are part of the "special word list" will be treated as their index within that heirarchy. * Words that cannot be identified as special, are treated using normal case-insensitive comparison rules. * </p> * */ public class VersionComparator implements Comparator<String> { private static final Comparator<String> INSTANCE = new VersionComparator(); private final List<String> specialWords; public VersionComparator() { specialWords = new ArrayList<>(23); // ids that refer to LATEST specialWords.add("final"); specialWords.add("release"); specialWords.add("current"); specialWords.add("latest"); specialWords.add("g"); specialWords.add("gold"); specialWords.add("fcs"); // ids that are for a release cycle. specialWords.add("a"); specialWords.add("alpha"); specialWords.add("b"); specialWords.add("beta"); specialWords.add("pre"); specialWords.add("rc"); specialWords.add("m"); specialWords.add("milestone"); // ids that are for dev / debug cycles. specialWords.add("dev"); specialWords.add("test"); specialWords.add("debug"); specialWords.add("unofficial"); specialWords.add("nightly"); specialWords.add("incubating"); specialWords.add("incubator"); specialWords.add("snapshot"); } public static Comparator<String> getInstance() { return INSTANCE; } @Override public int compare(String o1, String o2) { if (o1 == null && o2 == null) { return 0; } if (o1 == null) { return 1; } if (o2 == null) { return -1; } String[] parts1 = toParts(o1); String[] parts2 = toParts(o2); int diff; int partLen = Math.max(parts1.length, parts2.length); for (int i = 0; i < partLen; i++) { diff = comparePart(safePart(parts1, i), safePart(parts2, i)); if (diff != 0) { return diff; } } diff = parts2.length - parts1.length; if (diff != 0) { return diff; } return o1.compareToIgnoreCase(o2); } private String safePart(String[] parts, int idx) { if (idx < parts.length) { return parts[idx]; } return "0"; } private int comparePart(String s1, String s2) { boolean is1Num = NumberUtils.isNumber(s1); boolean is2Num = NumberUtils.isNumber(s2); // (Special Case) Test for numbers both first. if (is1Num && is2Num) { int i1 = NumberUtils.toInt(s1); int i2 = NumberUtils.toInt(s2); return i1 - i2; } // Test for text both next. if (!is1Num && !is2Num) { int idx1 = specialWords.indexOf(s1.toLowerCase()); int idx2 = specialWords.indexOf(s2.toLowerCase()); // Only operate perform index based operation, if both strings // are found in the specialWords index. if (idx1 >= 0 && idx2 >= 0) { return idx1 - idx2; } } // Comparing text to num if (!is1Num && is2Num) { return -1; } // Comparing num to text if (is1Num && !is2Num) { return 1; } // Return comparison of strings themselves. return s1.compareToIgnoreCase(s2); } public static String[] toParts(String version) { if (StringUtils.isBlank(version)) { return ArrayUtils.EMPTY_STRING_ARRAY; } int modeOther = 0; int modeDigit = 1; int modeText = 2; List<String> parts = new ArrayList<>(); int len = version.length(); int i = 0; int start = 0; int mode = modeOther; while (i < len) { char c = version.charAt(i); if (Character.isDigit(c)) { if (mode != modeDigit) { if (mode != modeOther) { parts.add(version.substring(start, i)); } mode = modeDigit; start = i; } } else if (Character.isLetter(c)) { if (mode != modeText) { if (mode != modeOther) { parts.add(version.substring(start, i)); } mode = modeText; start = i; } } else { // Other. if (mode != modeOther) { parts.add(version.substring(start, i)); mode = modeOther; } } i++; } // Add remainder if (mode != modeOther) { parts.add(version.substring(start, i)); } return parts.toArray(new String[parts.size()]); } }