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

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

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

Collections.sort（myStringArrayList，
新的AlphanumComparator（String.CASE_-INSENSITIVE_-ORDER））；
/*
*Alphanum算法是一种改进的字符串排序算法
*包含数字。而不是像这样按ASCII顺序对数字进行排序
*作为一种标准排序，该算法按数字顺序对数字进行排序。
* 
*Alphanum算法在http://www.DaveKoelle.com 
* 
* 
*这个图书馆是免费软件；您可以重新分发它和/或
*根据GNU小公众的条款对其进行修改
*自由软件基金会发布的许可证；任何一个
*许可证的2.1版或任何更高版本。
* 
*这个图书馆的发行是希望它会有用，
*但无任何保证；甚至没有任何关于
*适销性或适合某一特定目的。见GNU
*有关更多详细信息，请参阅较低的通用公共许可证。
* 
*您应该已经收到GNU Lesser General Public的副本
*与此库一起使用的许可证；如果没有，请写信给自由软件
＊基金会，公司，51富兰克林街，第五楼，波士顿，美国02110-1301
* 
*/ 
导入java.util.Comparator；
/** 
*这是由Daniel Migowski改进的更新版本，
*安德烈·博格斯和大卫·科勒
* 
*要转换为使用模板（Java 1.5+），请执行以下操作：
*-将“implements Comparator”更改为“implements Comparator”
*-将“比较（对象o1，对象o2）”更改为“比较（字符串s1，字符串s2）”
*-在compare（）中移除类型检查和强制转换。
* 
*要使用此类，请执行以下操作：
*使用java.util.Collections类中的静态“sort”方法：
*排序（您的列表，新的AlphanumComparator（））；
*/ 
公共类AlphanumComparator实现比较器
{ 
专用比较器比较器=新的自然比较器（）；
公共字母计算器（比较器）{
这个比较器=比较器；
} 
公共AlphanumComparator（）{
} 
专用最终布尔值isDigit（字符ch）
{ 
返回ch>=48&&ch可以通过在getChunck（）方法中添加if c！=''来实现

上面的代码不会向块添加空间。
可以通过在getChunck（）方法中添加if c！=''来实现

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

上面的代码不会为区块添加空间。
Collections.sort（myStringArrayList，newcomparator（））{
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;
            }
        }
    });

@凌驾
公共整数比较（字符串o1、字符串o2）{
int temp=o1.length（）-o2.length（）；
o1=o1.replaceAll（“，”）；
o2=o2.replaceAll（“，”）；
int compareTo=o1。compareTo（o2）；
如果（比较=0）{
返回温度；
}
否则{
返回比较；
}
}
});

比较器还可用于控制某些数据结构（如排序集或排序映射）的顺序，或为没有自然排序的对象集合提供排序。
collections.sort（myStringArrayList，new Comparator（）{
@凌驾
公共整数比较（字符串o1、字符串o2）{
int temp=o1.length（）-o2.length（）；
o1=o1.replaceAll（“，”）；
o2=o2.replaceAll（“，”）；
int compareTo=o1。compareTo（o2）；
如果（比较=0）{
返回温度；
}
否则{
返回比较；
}
}
});

比较器还可用于控制某些数据结构（如排序集或排序映射）的顺序，或为没有自然排序的对象集合提供排序。
一个简单的解决方案应该通过您介绍的四种情况的测试，即通过相同代码的构造函数和自定义比较器，如下所示：

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

公共类SpaceInsensitiveComparator实现比较器{
公共整数比较（字符串o1，字符串o2）{
返回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());   
    }   
 } 

公共类SpaceInsensitiveComparator实现比较器{
公共整数比较（字符串o1，字符串o2）{
返回字符串。不区分大小写。\u顺序。比较（o1.trim（），o2.trim（））；
}   
} 
一个简单的解决方案应该通过您介绍的四个案例的测试，即通过同一代码的构造函数和自定义比较器，如下所示：

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

公共类SpaceInsensitiveComparator实现比较器{
公共整数比较（字符串o1，字符串o2）{
返回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());   
    }   
 } 

公共类SpaceInsensitiveComparator实现比较器{
公共整数比较（字符串o1，字符串o2）{
返回字符串。不区分大小写。\u顺序。比较（o1.trim（），o2.trim（））；
}   
} 
不，它没有区别也没有区别我已将此代码放在NaturalComparator中，在我的问题代码的底部，但它没有区别，“级别3”位于“级别2”之前，而不是after@Lumis，尝试将JCN的比较器作为NaturalComparator构造函数中的比较器传递租金结果，de