[Ilugc] Java :: Alphanumeric Sorting Issue

  • From: karthikeyan.balasubramanian@xxxxxxxxxxxxx (Karthikeyan)
  • Date: Thu, 13 May 2004 12:54:37 +0530

Hi,

  I followed the below link to sort a set of Items.  I have kept
that Items in a HashMap rather then List(this is my requirement).  It
works perfectly ok but some items get lost while doing
sorting.  I would love to have some comments as to why its happening.

http://www.davekoelle.com/alphanum.jsp

Here is my sample code.

===============================
package ConsoleApplication1;

import java.util.*;


/**
* Summary description for Class1.
*
* @author     karthikeyan
* @created    May 12, 2004
*/
public class Class1 {
    /**
     *Constructor for the Class1 object
     */
    public Class1() { }


    /**
     * @param  args  The command line arguments
     * @attribute    System.STAThread()
     */
    public static void main(String[] args) {
        //
        // TODO: Add code to start application here
        //
        HashMap ipcModelHashMap = new HashMap();

        ipcModelHashMap.put("1", "1000X Radonius Maximus");
        ipcModelHashMap.put("2", "10X Radonius");
        ipcModelHashMap.put("3", "200X Radonius");
        ipcModelHashMap.put("4", "20X Radonius");
        ipcModelHashMap.put("5", "20X Radonius Prime");
        ipcModelHashMap.put("6", "30X Radonius");
        ipcModelHashMap.put("7", "40X Radonius");
        ipcModelHashMap.put("8", "Allegia 50 Clasteron");
        ipcModelHashMap.put("9", "Allegia 500 Clasteron");
        ipcModelHashMap.put("10", "Allegia 51 Clasteron");
        ipcModelHashMap.put("11", "Allegia 51B Clasteron");
        ipcModelHashMap.put("12", "Allegia 52 Clasteron");
        ipcModelHashMap.put("13", "Allegia 60 Clasteron");
        ipcModelHashMap.put("14", "Alpha 100");
        ipcModelHashMap.put("15", "Alpha 2");
        ipcModelHashMap.put("16", "Alpha 200");
        ipcModelHashMap.put("17", "Alpha 2A");
        ipcModelHashMap.put("18", "Alpha 2A-8000");
        ipcModelHashMap.put("19", "Alpha 2A-900");
        ipcModelHashMap.put("20", "Callisto Morphamax");
        ipcModelHashMap.put("21", "Callisto Morphamax 500");
        ipcModelHashMap.put("22", "Callisto Morphamax 5000");
        ipcModelHashMap.put("23", "Callisto Morphamax 600");
        ipcModelHashMap.put("24", "Callisto Morphamax 700");
        ipcModelHashMap.put("25", "Callisto Morphamax 7000");
        ipcModelHashMap.put("26", "Callisto Morphamax 7000 SE");
        ipcModelHashMap.put("27", "Callisto Morphamax 7000 SE2");
        ipcModelHashMap.put("28", "QRS-60 Intrinsia Machine");
        ipcModelHashMap.put("29", "QRS-60F Intrinsia Machine");
        ipcModelHashMap.put("30", "QRS-62 Intrinsia Machine");
        ipcModelHashMap.put("31", "QRS-62F Intrinsia Machine");
        ipcModelHashMap.put("32", "Xiph Xlater 10000");
        ipcModelHashMap.put("33", "Xiph Xlater 2000");
        ipcModelHashMap.put("34", "Xiph Xlater 300");
        ipcModelHashMap.put("35", "Xiph Xlater 40");
        ipcModelHashMap.put("36", "Xiph Xlater 5");
        ipcModelHashMap.put("37", "Xiph Xlater 50");
        ipcModelHashMap.put("38", "Xiph Xlater 500");
        ipcModelHashMap.put("39", "Xiph Xlater 5000");
        ipcModelHashMap.put("40", "Xiph Xlater 58");
        ipcModelHashMap.put("41", "z1.html");
        ipcModelHashMap.put("42", "z10.html");
        ipcModelHashMap.put("43", "z101.html");
        ipcModelHashMap.put("44", "z102.html");
        ipcModelHashMap.put("45", "z103.html");
        ipcModelHashMap.put("46", "z104.html");
        ipcModelHashMap.put("47", "z105.html");
        ipcModelHashMap.put("48", "z106.html");
        ipcModelHashMap.put("49", "z107.html");
        ipcModelHashMap.put("50", "z108.html");
        ipcModelHashMap.put("51", "z109.html");
        ipcModelHashMap.put("52", "z11.html");
        ipcModelHashMap.put("53", "z110.html");

        Comparator ipcModelComparator = new
AlphanumComparator(ipcModelHashMap);

        Map ipcModelSortedMap = new TreeMap(ipcModelComparator);

        ipcModelSortedMap.putAll(ipcModelHashMap);

        Set ipcModelSet = ipcModelSortedMap.entrySet();

        for (Iterator ipcModelIterator = ipcModelSet.iterator();
ipcModelIterator.hasNext(); ) {
            Map.Entry ipcModelMapEntry = (Map.Entry)
ipcModelIterator.next();
            String ipcModelKey = (String) ipcModelMapEntry.getKey();
            String ipcModelValue = (String) ipcModelMapEntry.getValue();

            System.out.println("Key : " + ipcModelKey + "  Value : " +
ipcModelValue);
        }
    }
}


/**
*  Description of the Class
*
* @author     karthikeyan
* @created    May 12, 2004
*/
class AlphanumComparator implements Comparator {


    private Map secondaryMap;


    /**
     *Constructor for the AlphanumComparator object
     *
     * @param  maptosort  Description of the Parameter
     */
    public AlphanumComparator(Map maptosort) {
        secondaryMap = new HashMap(maptosort);
    }


    char[] numbers = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};


    /**
     *  Gets the in attribute of the AlphanumComparator object
     *
     * @param  ch     Description of the Parameter
     * @param  chars  Description of the Parameter
     * @return        The in value
     */
    private boolean isIn(char ch, char[] chars) {
        for (int i = 0; i < chars.length; i++) {
            if (ch == chars[i]) {
                return true;
            }
        }
        return false;
    }


    /**
     *  Description of the Method
     *
     * @param  ch  Description of the Parameter
     * @param  s   Description of the Parameter
     * @return     Description of the Return Value
     */
    private boolean inChunk(char ch, String s) {
        if (s.length() == 0) {
            return true;
        }

        char s0 = s.charAt(0);
        int chunkType = 0;
        // 0 = alphabetic, 1 = numeric

        if (isIn(s0, numbers)) {
            chunkType = 1;
        }

        if ((chunkType == 0) && (isIn(ch, numbers))) {
            return false;
        }
        if ((chunkType == 1) && (!isIn(ch, numbers))) {
            return false;
        }

        return true;
    }


    /**
     *  Description of the Method
     *
     * @param  o1  Description of the Parameter
     * @param  o2  Description of the Parameter
     * @return     Description of the Return Value
     */
    public int compare(Object o1, Object o2) {

        String s1 = (String) secondaryMap.get(o1);
        String s2 = (String) secondaryMap.get(o2);

        int thisMarker = 0;
        int thisNumericChunk = 0;
        String thisChunk = new String();
        int thatMarker = 0;
        int thatNumericChunk = 0;
        String thatChunk = new String();

        while ((thisMarker < s1.length()) && (thatMarker < s2.length())) {
            char thisCh = s1.charAt(thisMarker);
            char thatCh = s2.charAt(thatMarker);

            thisChunk = "";
            thatChunk = "";

            while ((thisMarker < s1.length()) && inChunk(thisCh,
thisChunk)) {
                thisChunk = thisChunk + thisCh;
                thisMarker++;
                if (thisMarker < s1.length()) {
                    thisCh = s1.charAt(thisMarker);
                }
            }

            while ((thatMarker < s2.length()) && inChunk(thatCh,
thatChunk)) {
                thatChunk = thatChunk + thatCh;
                thatMarker++;
                if (thatMarker < s2.length()) {
                    thatCh = s2.charAt(thatMarker);
                }
            }

            int thisChunkType = isIn(thisChunk.charAt(0), numbers) ? 1 : 0;
            int thatChunkType = isIn(thatChunk.charAt(0), numbers) ? 1 : 0;

            // If both chunks contain numeric characters, sort them
numerically
            int result = 0;

            if ((thisChunkType == 1) && (thatChunkType == 1)) {
                thisNumericChunk = Integer.parseInt(thisChunk);
                thatNumericChunk = Integer.parseInt(thatChunk);
                if (thisNumericChunk < thatNumericChunk) {
                    result = -1;
                }
                if (thisNumericChunk > thatNumericChunk) {
                    result = 1;
                }
            } else {
                result = thisChunk.compareTo(thatChunk);
            }

            if (result != 0) {
                return result;
            }
        }

        return 0;
    }
}

===============================

  Have a great day.

Karthikeyan B


Other related posts: