Question

我发现此示例代码由Yishai发布在此论坛上，效果非常好。它帮助我按照“自然顺序”对磁盘上的文件名进行排序，即人们喜欢看的方式：

文件1

file2的

file3的

FILE11

如果只是正常（ascii）排序，那么 file11 将在 file1 之后和 file2 之前

问题是如何改进此代码并提供一个可以忽略空格的选项，这在读取长列表中的文件名时可能是非常有用的排序类型，如：

文件1

档案1

file2的

file 3

这是代码

Collections.sort(myStringArrayList, 
                 new AlphanumComparator(String.CASE_INSENSITIVE_ORDER));



 /*
 * 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()); 
 */ 
public class AlphanumComparator implements Comparator<String> 
{ 
    private Comparator<String> comparator = new NaturalComparator(); 

    public AlphanumComparator(Comparator<String> comparator) { 
        this.comparator = comparator; 
    } 

    public AlphanumComparator() { 

    } 

    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(String s1, String s2) 
    { 

        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 = comparator.compare(thisChunk, thatChunk); 
            } 

            if (result != 0) 
                return result; 
        } 

        return s1Length - s2Length; 
    } 

    private static class NaturalComparator implements Comparator<String> { 
        public int compare(String o1, String o2) { 
            return o1.compareTo(o2); 
        } 
    }

Answer 1

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


@Override
        public int compare(String o1, String o2) {
            int temp = o1.length() - o2.length();
            o1 = o1.replaceAll(" ", "");
            o2 = o2.replaceAll(" ", "");
            int compareTo = o1.compareTo(o2);
            if(compareTo == 0){
                return temp;
            }
            else{
                return compareTo;
            }
        }
    });

比较器也可用于控制某些数据结构的顺序（例如有序集或有序映射），或者为没有自然顺序的对象集合提供排序。

Answer 2

一个简单的解决方案应该通过你提出的四个案例的测试，是传递相同代码的构造函数一个自定义比较器，如下所示：

 public class SpaceInsensitiveComparator implements Comparator<String> {   
    public int compare(String o1, String o2) {   
        return o1.trim().compareTo(o2.trim());   
    }   
 }

或者不区分大小写：

 public class SpaceInsensitiveComparator implements Comparator<String> {   
    public int compare(String o1, String o2) {   
        return String.CASE_INSENSITIVE_ORDER.compare(o1.trim(), o2.trim());   
    }   
 }

Answer 3

可以通过在getChunck（）方法中添加if c！=''

if (c != ' ')
{
        chunk.append(c);
}

上面的代码不会为chunk添加空间。

按自然顺序排序字符串数组并忽略空格

3 个答案: