Use the alphanum algorithm to sort IDs

src/com/github/ss111/AlphanumComparator.java

@@ -0,0 +1,132 @@
+package com.github.ss111;
+/*
+ * The Alphanum Algorithm is an improved sorting algorithm for strings
+ * containing numbers.  Instead of sorting numbers in ASCII order like
+ * a standard sort, this algorithm sorts numbers in numeric order.
+ *
+ * The Alphanum Algorithm is discussed at http://www.DaveKoelle.com
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+import java.util.Comparator;
+
+/**
+ * This is an updated version with enhancements made by Daniel Migowski,
+ * Andre Bogus, and David Koelle
+ *
+ * To convert to use Templates (Java 1.5+):
+ *   - Change "implements Comparator" to "implements Comparator<String>"
+ *   - Change "compare(Object o1, Object o2)" to "compare(String s1, String s2)"
+ *   - Remove the type checking and casting in compare().
+ *
+ * To use this class:
+ *   Use the static "sort" method from the java.util.Collections class:
+ *   Collections.sort(your list, new AlphanumComparator());
+ */
+@SuppressWarnings("rawtypes")
+public class AlphanumComparator implements Comparator
+{
+    private final boolean isDigit(char ch)
+    {
+        return ch >= 48 && ch <= 57;
+    }
+
+    /** Length of string is passed in for improved efficiency (only need to calculate it once) **/
+    private final String getChunk(String s, int slength, int marker)
+    {
+        StringBuilder chunk = new StringBuilder();
+        char c = s.charAt(marker);
+        chunk.append(c);
+        marker++;
+        if (isDigit(c))
+        {
+            while (marker < slength)
+            {
+                c = s.charAt(marker);
+                if (!isDigit(c))
+                    break;
+                chunk.append(c);
+                marker++;
+            }
+        } else
+        {
+            while (marker < slength)
+            {
+                c = s.charAt(marker);
+                if (isDigit(c))
+                    break;
+                chunk.append(c);
+                marker++;
+            }
+        }
+        return chunk.toString();
+    }
+
+    public int compare(Object o1, Object o2)
+    {
+        if (!(o1 instanceof String) || !(o2 instanceof String))
+        {
+            return 0;
+        }
+        String s1 = (String)o1;
+        String s2 = (String)o2;
+
+        int thisMarker = 0;
+        int thatMarker = 0;
+        int s1Length = s1.length();
+        int s2Length = s2.length();
+
+        while (thisMarker < s1Length && thatMarker < s2Length)
+        {
+            String thisChunk = getChunk(s1, s1Length, thisMarker);
+            thisMarker += thisChunk.length();
+
+            String thatChunk = getChunk(s2, s2Length, thatMarker);
+            thatMarker += thatChunk.length();
+
+            // If both chunks contain numeric characters, sort them numerically
+            int result = 0;
+            if (isDigit(thisChunk.charAt(0)) && isDigit(thatChunk.charAt(0)))
+            {
+                // Simple chunk comparison by length.
+                int thisChunkLength = thisChunk.length();
+                result = thisChunkLength - thatChunk.length();
+                // If equal, the first different number counts
+                if (result == 0)
+                {
+                    for (int i = 0; i < thisChunkLength; i++)
+                    {
+                        result = thisChunk.charAt(i) - thatChunk.charAt(i);
+                        if (result != 0)
+                        {
+                            return result;
+                        }
+                    }
+                }
+            } else
+            {
+                result = thisChunk.compareTo(thatChunk);
+            }
+
+            if (result != 0)
+                return result;
+        }
+
+        return s1Length - s2Length;
+    }
+}

src/com/github/ss111/SortingHelper.java

@@ -0,0 +1,27 @@
+package com.github.ss111;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import javax.swing.DefaultListModel;
+
+public class SortingHelper {
+
+	@SuppressWarnings("unchecked")
+	public static void sortListModel(DefaultListModel<String> input) {
+
+		Object[] unsortedArray = input.toArray();
+
+		List<Object> listToBeSorted = Arrays.asList(unsortedArray);
+
+		Collections.sort(listToBeSorted, new AlphanumComparator());
+
+		input.clear();
+
+		for (Object o : listToBeSorted) {
+
+			input.addElement(o.toString());
+		}
+	}
+}

src/com/github/ss111/WindowMain.java

@@ -445,6 +445,7 @@ public void actionPerformed(ActionEvent e) {
 							listModelBlocks.addElement(getColoredString(ConflictHelper.getConfigConflictString(ConfigHelper.getBlockIDs(), ID, "BLOCK")));
 							conflicts++;
 
+
 						} else {
 
 							listModelBlocks.addElement("Block ID: " + ID + " | " + "Block name: " + ConflictHelper.getName(ConfigHelper.getBlockIDs(), ID));
@@ -491,12 +492,18 @@ public void actionPerformed(ActionEvent e) {
     					} else {
 
     						listModelUnknown.addElement("ID: " + ID + " | " + "Name: " + ConflictHelper.getName(ConfigHelper.getUnknownIDs(), ID));
+
     					}
     				}
                 }
 
+                SortingHelper.sortListModel(listModelBlocks);
+                SortingHelper.sortListModel(listModelItems);
+                SortingHelper.sortListModel(listModelUnknown);
+
                 btnSearch.setText("Done!");
 
+
                 if (conflicts == 0) {
 
                 	JOptionPane.showMessageDialog(null, "No conflicts were found! Hooray!", "Information", JOptionPane.INFORMATION_MESSAGE);