From 09b2c44def1080ad1fdec9d0a761327489521866 Mon Sep 17 00:00:00 2001 From: Sam Mauck Date: Sat, 28 Sep 2013 12:23:34 -0600 Subject: [PATCH] Use the alphanum algorithm to sort IDs --- src/com/github/ss111/AlphanumComparator.java | 132 +++++++++++++++++++ src/com/github/ss111/SortingHelper.java | 27 ++++ src/com/github/ss111/WindowMain.java | 7 + 3 files changed, 166 insertions(+) create mode 100644 src/com/github/ss111/AlphanumComparator.java create mode 100644 src/com/github/ss111/SortingHelper.java diff --git a/src/com/github/ss111/AlphanumComparator.java b/src/com/github/ss111/AlphanumComparator.java new file mode 100644 index 0000000..4ef0d9b --- /dev/null +++ b/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" + * - 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; + } +} diff --git a/src/com/github/ss111/SortingHelper.java b/src/com/github/ss111/SortingHelper.java new file mode 100644 index 0000000..9785c8d --- /dev/null +++ b/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 input) { + + Object[] unsortedArray = input.toArray(); + + List listToBeSorted = Arrays.asList(unsortedArray); + + Collections.sort(listToBeSorted, new AlphanumComparator()); + + input.clear(); + + for (Object o : listToBeSorted) { + + input.addElement(o.toString()); + } + } +} diff --git a/src/com/github/ss111/WindowMain.java b/src/com/github/ss111/WindowMain.java index 3a93da0..10b94f1 100644 --- a/src/com/github/ss111/WindowMain.java +++ b/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);