Question

我有一个ArrayList，每个索引有几个对象。我想特别用一个对象按字母顺序排列这个列表。对象是＆＃34; my_id＆＃34;此对象的值类似于：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);
        }

我知道你在想什么，我在重新映射时不会添加所有对象。这就是我目前所拥有的，但我想要的是一种对整个列表进行排序的方法，而不仅仅是一个对象＆＃34; my_id＆＃34;。我想重新安排索引，所以我不必在最后重新映射所有内容。

Answer 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]

Answer 2

经过仔细重建比较器和所有评论后，我终于想出了如何做到这一点。

<强>问题：重申我的目标，以及解决方案。我有ArrayList<HashMap<String, String>>。我想通过HashMap中的一个对象对ArrayList进行排序。我的HashMap中有多个对象，所以我想保留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解决方案： 在我的自定义Comparator函数public int compare(object firstObj, Object secondObj)中，我需要将String值更改为HashMap对象引用/值。这里KEY_ID是我想要排序的对象。一旦我这样做，我使用Collections.sort按HashMap比较器排序，而不是Arrays.sort（集合处理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;

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

2 个答案: