1

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

  • 文件 1

    文件2

    文件 3

    文件 11

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

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

  • 文件 1

    文件 1

    文件2

    文件 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); 
        } 
    }
4

3 回答 3

2 
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;
            }
        }
    });

比较器还可用于控制某些数据结构（例如排序集或排序图）的顺序，或为不具有自然排序的对象集合提供排序。

于 2012-09-21T18:57:36.043 回答
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());   
    }   
 }
于 2012-09-23T02:38:40.857 回答
0

可以通过在 getChunck() 方法中添加 if c != ''

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

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

于 2012-09-21T18:42:48.383 回答