使用 HashMap 对 ArrayList 进行字母数字排序答案

【问题标题】：Alphanumeric sorting of ArrayList with HashMap使用 HashMap 对 ArrayList 进行字母数字排序
【发布时间】：2015-02-26 15:34:11
【问题描述】：

我有一个ArrayList，每个索引有几个对象。我想特别按一个对象按字母数字顺序对这个列表进行排序。对象是“my_id”，该对象的值可能类似于：1A、10B、11B、2C、205Z 等。

我需要将这些排序出来：1A、2C、10B、11B、205Z。首先对数字部分进行排序，然后对字母部分进行排序。 1,2,3,4,5,... A,B,C,D,E,...

我检查了一些非常有效的字母数字字符串排序： http://sanjaal.com/java/206/java-data-structure/alphanumeric-string-sorting-in-java-implementation/

不幸的是，我只能对该对象进行排序，结果我丢失了ArrayList 中的其他对象。我真的需要一种排序算法，它可以通过我选择的对象重新排列ArrayList 索引并且不会丢失其他对象！

有没有一种方法可以做到这一点？我一直找不到。我认为添加 ArrayList 中的所有对象都是映射字符串很有用：ArrayList<HashMap<String, String>>

[编辑] 我有我的数组： ArrayList<HashMap<String, String>> al

然后我存储对象：

String[] alphaNumericStringArray = new String[al.size()];
        for(int i = 0; i < al.size(); i++)
        {
            alphaNumericStringArray[i] = al.get(i).get("my_id");
        }

我现在对字符串数组进行排序：

// Sort the array now.
        Arrays.sort(alphaNumericStringArray, new AlphanumericSorting());

然后我把物体放回去：

for(int i = 0; i < al.size(); i++)
        {
            HashMap<String, String> map = new HashMap<String, String>();
                map.put("my_id", alphaNumericStringArray[i]);
                // TODO, need to append the rest of the objects.
            al.set(i, map);
        }

我知道你在想什么，当我重新映射它时，我不会将所有对象添加回去。这是我目前拥有的，但我想要的是一种对整个列表进行排序的方法，而不仅仅是一个对象“my_id”。我想重新排列索引，这样我就不必在最后重新映射所有内容。

【问题讨论】：

为什么会丢失物品？我看不出如何通过对列表进行排序来丢失对象？
"ArrayList with multiple objects per index"，详细说明...
你能发布你的代码吗？也许你的排序正确，但你没有保存你的对象。
@waqaslam 操作指的是包含哈希图的列表
@UrielArvizu 这就是我的想法，但他没有在任何地方提到这个重要的线索。但是，这仍然是我们的假设。 :)

标签： java android sorting arraylist

【解决方案1】：

运行main 方法：

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Sorter {

    public static void main(String[] args) {

        List<String> unsorted = Arrays.asList("1A", "10B", "B", "753c", "Z", "M7", "32x", "11B", "2C", "205Z");

        Collections.sort(unsorted, new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {

                if (o1.isEmpty())
                    return -1;

                if (o2.isEmpty())
                    return 1;

                String o1number = extractNumberPrefix(o1);

                String o2number = extractNumberPrefix(o2);

                if (o1number.isEmpty())
                    if (o2number.isEmpty())
                        return o1.compareTo(o2);
                    else return 1;

                if (o2number.isEmpty())
                    return -1;

                if (o1number.equals(o2number))
                    return o1.compareTo(o2);

                return Integer.parseInt(o1number) - Integer.parseInt(o2number);
            }

            private String extractNumberPrefix(String o1) {

                String result = "";
                for (int i = 0; i < o1.length(); i++) {
                    try {
                        Integer.parseInt(o1.substring(i, i + 1));
                        result += o1.substring(i, i + 1);
                    } catch (Exception e) {
                        break;
                    }
                }
                return result;
            }
        });

        System.out.println("sorted = " + unsorted);
    }
}

sorted = [1A, 2C, 10B, 11B, 32x, 205Z, 753c, B, M7, Z]

【讨论】：

我使用字符串数组String[] 对字母数字进行排序，但我需要一个带有映射对象的ArrayList，以根据我选择的对象进行排序，即"my_id" ex：al。 get(i).get("my_id")
OP 想要按一个键后面的值对HashMaps 进行排序。其余的你似乎是正确的。

【解决方案2】：

在仔细重建 Comparator 和所有 cmets 之后，我终于想出了如何做到这一点。

问题： 重申我的目标是什么，以及解决方案。我有一个ArrayList<HashMap<String, String>>。我想按 HashMap 中的一个对象对 ArrayList 进行排序。我的 HashMap 中有超过 1 个对象，所以我想保留 Array 的整个索引。我还想按字母数字排序，其中数值是第一个排序的，而不是按字母排序。即 1,2,3,4,... A,B,C,D,...

参考资料： http://sanjaal.com/java/206/java-data-structure/alphanumeric-string-sorting-in-java-implementation/

TL;DR 解决方案： 在我的自定义比较器函数public int compare(object firstObj, Object secondObj) 中，我需要将字符串值更改为 HashMap 对象引用/值。这里的 KEY_ID 是我想要排序的对象。完成此操作后，我使用 Collections.sort 按 HashMap 比较器而不是 Arrays.sort 进行排序（Collections 处理 ArrayList/HashMaps）。

代码解决方案：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;

/** 
 * DOCUMENTATION: 
 * http://sanjaal.com/java/206/java-data-structure/alphanumeric-string-sorting-in-java-implementation/ 
 **/

@SuppressWarnings({"rawtypes", "unchecked"})
public class AlphanumericSorting implements Comparator 
{
    public int compare(Object firstObjToCompare, Object secondObjToCompare) 
    {
        String firstString  = ((HashMap<String,String>) firstObjToCompare).get("KEY_ID");
        String secondString = ((HashMap<String,String>) secondObjToCompare).get("KEY_ID");

        //String firstString    = firstObjToCompare.toString();
        //String secondString = secondObjToCompare.toString();

        if (secondString == null || firstString == null) 
        {
            return 0;
        }

        int lengthFirstStr  = firstString.length();
        int lengthSecondStr = secondString.length();

        int index1 = 0;
        int index2 = 0;

        while(index1 < lengthFirstStr && index2 < lengthSecondStr) 
        {
            char ch1 = firstString.charAt(index1);
            char ch2 = secondString.charAt(index2);

            char[] space1 = new char[lengthFirstStr];
            char[] space2 = new char[lengthSecondStr];

            int loc1 = 0;
            int loc2 = 0;

            do 
            {
                space1[loc1++] = ch1;
                index1++;

                if (index1 < lengthFirstStr) 
                {
                    ch1 = firstString.charAt(index1);
                } 
                else 
                {
                    break;
                }
            } 
            while (Character.isDigit(ch1) == Character.isDigit(space1[0]));

            do 
            {
                space2[loc2++] = ch2;
                index2++;

                if (index2 < lengthSecondStr) 
                {
                    ch2 = secondString.charAt(index2);
                } else 
                {
                    break;
                }
            } 
            while (Character.isDigit(ch2) == Character.isDigit(space2[0]));

            String str1 = new String(space1);
            String str2 = new String(space2);

            int result;

            if (Character.isDigit(space1[0]) && Character.isDigit(space2[0])) 
            {
                Integer firstNumberToCompare    = new Integer(Integer.parseInt(str1.trim()));
                Integer secondNumberToCompare   = new Integer(Integer.parseInt(str2.trim()));

                result = firstNumberToCompare.compareTo(secondNumberToCompare);
            } 
            else 
            {
                result = str1.compareTo(str2);
            }

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

        return lengthFirstStr - lengthSecondStr;
    }

    /**
     * ALPHANUMERIC SORTING
     */
    public static ArrayList<HashMap<String, String>> sortArrayList(ArrayList<HashMap<String, String>> al)
    {
        Collections.sort(al, new AlphanumericSorting());

        return al;
    }
}

返回排序后的 ArrayList：

myArrayList = AlphanumericSorting.sortArrayList(myArrayList);

在哪里，

ArrayList<HashMap<String, String>> myArrayList;

【讨论】：