Java ArrayList的复杂排序

我在

trendList

变量中存储了以下字符串。我做了一个排序，但是数据没有正确排序

---

i、 e.

ACLK\u-SCRN\u 200MHZ\u-DATAB\u-S0\u-P1:8

应位于

ACLK\u-SCRN\u 200MHZ\u-DATAB\u-S0\u-P10:8

自

1<10

，依此类推

问题：如何进行字母数字排序以获得正确的顺序

我必须要做我自己的功能吗？那会是什么样子

List<String> trendList = new ArrayList<String>(80000);

Collections.sort(trendList);

ACLK_SCRN_200MHZ_DATAB_S0_P0:8
ACLK_SCRN_200MHZ_DATAB_S0_P10:8
ACLK_SCRN_200MHZ_DATAB_S0_P11:8
ACLK_SCRN_200MHZ_DATAB_S0_P12:8
ACLK_SCRN_200MHZ_DATAB_S0_P13:8
ACLK_SCRN_200MHZ_DATAB_S0_P14:8
ACLK_SCRN_200MHZ_DATAB_S0_P15:8
ACLK_SCRN_200MHZ_DATAB_S0_P1:8
ACLK_SCRN_200MHZ_DATAB_S0_P2:8
ACLK_SCRN_200MHZ_DATAB_S0_P3:8
ACLK_SCRN_200MHZ_DATAB_S0_P4:8
ACLK_SCRN_200MHZ_DATAB_S0_P5:8
ACLK_SCRN_200MHZ_DATAB_S0_P6:8
ACLK_SCRN_200MHZ_DATAB_S0_P7:8
ACLK_SCRN_200MHZ_DATAB_S0_P8:8
ACLK_SCRN_200MHZ_DATAB_S0_P9:8
ACLK_SCRN_200MHZ_DATAB_S1_P0:8
ACLK_SCRN_200MHZ_DATAB_S1_P10:8
ACLK_SCRN_200MHZ_DATAB_S1_P11:8
ACLK_SCRN_200MHZ_DATAB_S1_P12:8
ACLK_SCRN_200MHZ_DATAB_S1_P13:8
ACLK_SCRN_200MHZ_DATAB_S1_P14:8
ACLK_SCRN_200MHZ_DATAB_S1_P15:8
ACLK_SCRN_200MHZ_DATAB_S1_P1:8
ACLK_SCRN_200MHZ_DATAB_S1_P2:8
ACLK_SCRN_200MHZ_DATAB_S1_P3:8
ACLK_SCRN_200MHZ_DATAB_S1_P4:8
ACLK_SCRN_200MHZ_DATAB_S1_P5:8
MLC_C_SAMPLE
MLC_SAMPLE
SWR
TOUCHDOWN
TEST_REV

List-trendList=new-ArrayList（80000）；
集合。排序（趋势列表）；
ACLK\u SCRN\u 200MHZ\u数据0\u P0:8
ACLK_SCRN_200MHZ_数据_S0_P10:8
ACLK_SCRN_200MHZ_数据_S0_P11:8
ACLK_SCRN_200MHZ_数据_S0_P12:8
ACLK_SCRN_200MHZ_数据_S0_P13:8
ACLK_SCRN_200MHZ_数据_S0_P14:8
ACLK_SCRN_200MHZ_数据_S0_P15:8
ACLK_SCRN_200MHZ_数据_S0_P1:8
ACLK_SCRN_200MHZ_数据_S0_P2:8
ACLK_SCRN_200MHZ_数据_S0_P3:8
ACLK_SCRN_200MHZ_数据_S0_P4:8
ACLK_SCRN_200MHZ_数据_S0_P5:8
ACLK\u SCRN\u 200MHZ\u数据0\u P6:8
ACLK_SCRN_200MHZ_数据_S0_P7:8
ACLK_SCRN_200MHZ_数据_S0_P8:8
ACLK_SCRN_200MHZ_数据_S0_P9:8
ACLK_SCRN_200MHZ_数据集S1_P0:8
ACLK\u SCRN\u 200MHZ\u数据集\u S1\u P10:8
ACLK\u SCRN\u 200MHZ\u数据集\u S1\u P11:8
ACLK_SCRN_200MHZ_数据S1_P12:8
ACLK\u SCRN\u 200MHZ\u数据集\u S1\u P13:8
ACLK\u SCRN\u 200MHZ\u数据集\u S1\u P14:8
ACLK_SCRN_200MHZ_数据S1_P15:8
ACLK_SCRN_200MHZ_数据S1_P1:8
ACLK_SCRN_200MHZ_数据S1_P2:8
ACLK\u SCRN\u 200MHZ\u数据集\u S1\u P3:8
ACLK_SCRN_200MHZ_数据_S1_P4:8
ACLK_SCRN_200MHZ_数据S1_P5:8
MLC__样本
MLC_样本
SWR
触地得分
测试修订版

之所以得到该结果，是因为它仅使用默认字符串比较字符串。compareTo使用原始字符代码。“：”出现在“0”-“9”之后，因此它在后面进行整理

您需要提供自己的

比较器

并调用

Collections.sort(trendList, new CustomComparator());

---

您可以创建自己的类来实现接口。在

compare

方法中，您需要解析字符串，并从字符串的相关部分提取需要按数字排序的数字。如果s1小于s2，则该方法返回的数字应小于0；如果s1等于s2，则返回的数字应为0；如果s1大于s2，则返回的数字应大于0

public class MyTrendListComparator implements Comparator<String>
{
    public int compare(String s1, String s2)
    {
        // Parse and compare here.
    }
}

---

您可以将自定义比较器传递给

Collections.sort（）

函数：

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

    @Override
    public int compare(String s1, String s2) {
        int sValue1 = s1.split(...) // split the strings to retrieve their values
        int sValue2 = // ...
        int pValue1 = // ...
        int pValue2 = // ...
        if (sValue1 > sValue2) { return 1; }
        if (sValue1 < sValue2) { return -1; }
        if (pValue1 > pValue2) { return 1; }
        if (pValue 1 < pValue2) { return -1; }
        return 0;
    }

});

Collections.sort（趋势列表，新比较器（）{
@凌驾
公共整数比较（字符串s1、字符串s2）{
int sValue1=s1.split（…）//拆分字符串以检索其值
int sValue2=/。。。
int pValue1=/。。。
int pValue2=/。。。
如果（sValue1>sValue2）{return 1；}
if（sValue1pValue2）{return 1；}
if（pValue 1

您可以使用自己的比较器执行以下操作：

class TrendListComparator implements Comparator<String> {
     // retrieve the P and S
     final Pattern p = Pattern.compile(".*_S(\\d+)_P(\\d+).*");
     public int compare(String str1, String str2) {
         Matcher m1 = p.matcher(str1);
         Matcher m2 = p.matcher(str2);
         if (m1.matches() && m2.matches()) {
             Integer s1 = Integer.valueOf(m.group(1));
             Integer p1 = Integer.valueOf(m.group(2));
             Integer s2 = Integer.valueOf(m.group(1));
             Integer p2 = Integer.valueOf(m.group(2));
             // compare
             return s1.equals(s2) ? p1.compareTo(p2) : s1.compareTo(s2);
         } else {
             return str1.compareTo(str2); // standard sort if no P and S
         }
     }
}

Collections.sort(trendList, new TrendListComparator());

类TrendListComparator实现Comparator{
//检索P和S
最终模式p=Pattern.compile（“.*S（\\d+）\u p（\\d+）.”；
公共整数比较（字符串str1、字符串str2）{
匹配器m1=p.匹配器（str1）；
匹配器m2=p.匹配器（str2）；
if（m1.matches（）&&m2.matches（））{
整数s1=整数.valueOf（m.group（1））；
整数p1=整数.valueOf（m.组（2））；
整数s2=整数.valueOf（m.组（1））；
整数p2=整数.valueOf（m.group（2））；
//比较
返回s1.equals（s2）？p1.compareTo（p2）：s1.compareTo（s2）；
}否则{
返回str1.compareTo（str2）；//如果没有P和S，则进行标准排序
}
}
}
排序（trendList，new TrendListComparator（））；

您可以在此处看到一个运行示例：

您甚至可以只使用一个匹配器进行匹配，并在相同的排序过程中重复使用它：

class TrendListComparator implements Comparator<String> {
     // retrieve the P and S
     final Matcher m = Pattern.compile(".*_S(\\d+)_P(\\d+).*_S(\\d+)_P(\\d+).*").matcher("");
     public int compare(String str1, String str2) {
         if (m.reset(str1 + str2).matches()) {
             Integer s1 = Integer.valueOf(m.group(1));
             Integer p1 = Integer.valueOf(m.group(2));
             Integer s2 = Integer.valueOf(m.group(3));
             Integer p2 = Integer.valueOf(m.group(4));
             // compare
             return s1.equals(s2) ? p1.compareTo(p2) : s1.compareTo(s2);
         } else {
             return str1.compareTo(str2); // standard sort if no P and S
         }
     }
}

类TrendListComparator实现Comparator{
//检索P和S
最终匹配器m=Pattern.compile（“.*S（\\d+）\P（\\d+）.*.*S（\\d+）\P（\\d+）.*”）.Matcher（”；
公共整数比较（字符串str1、字符串str2）{
if（m.reset（str1+str2）.matches（））{
整数s1=整数.valueOf（m.group（1））；
整数p1=整数.valueOf（m.组（2））；
整型s2=整型.valueOf（m.组（3））；
整数p2=整数.valueOf（m.group（4））；
//比较
返回s1.equals（s2）？p1.compareTo（p2）：s1.compareTo（s2）；
}否则{
返回str1.compareTo（str2）；//如果没有P和S，则进行标准排序
}
}
}

请参阅：

以下是代码：

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

public class CustomSorter {
   public static void main( String[] args ) {
      String[] data = {
         "ACLK_SCRN_200MHZ_DATAB_S0_P0:8",
         "ACLK_SCRN_200MHZ_DATAB_S0_P10:8",
         ...
         "ACLK_SCRN_200MHZ_DATAB_S1_P4:8",
         "ACLK_SCRN_200MHZ_DATAB_S1_P5:8",
      };
      List<String> trendList = Arrays.asList( data );
      Collections.sort( trendList, new Comparator< String >(){
         @Override public int compare( String o1, String o2 ){
            String[] p1 = o1.split( "_S\\d+_P" );
            String[] p2 = o2.split( "_S\\d+_P" );
            if( p1.length != 2 ) {
               throw new IllegalStateException("Unexpected item: '"+o1+"'");
            }
            if( p2.length != 2 ) {
               throw new IllegalStateException("Unexpected item: '"+o1+"'");
            }
            final int i1;
            try{
               i1 = Integer.parseInt(p1[1].substring(0,p1[1].indexOf(':')));
            } catch( NumberFormatException x ) {
               throw new IllegalStateException( "Unexpected item: '"+o1+"'");
            }
            final int i2;
            try{
               i2 = Integer.parseInt(p2[1].substring(0,p2[1].indexOf(':')));
            } catch( NumberFormatException x ) {
               throw new IllegalStateException("Unexpected item: '"+o2+"'");
            }
            int cmp = p1[0].compareTo( p2[0] );
            if( cmp == 0 ) {
               cmp = i1 - i2;
            }
            return cmp;
         }});
      for( String entry : trendList ) {
         System.out.println( entry );
      }
   }
}

---

您可以编写一个正则表达式并对数字使用自定义字符串比较器。但是，实现一个解析这些字符串的对象并在对象上实现一个自定义的

compareTo（）

方法或

比较器将更有意义。非常好，但是STR_长度是多少？
ACLK_SCRN_200MHZ_DATAB_S12
将在
ACLK_SCRN_200MHZ_DATAB_S2
之前出现，如果您不同时检查
S\\d+
编号。好的，按照您的建议修改答案。这非常好。最后一个问题。如果有一个字符串不包含“u”或“：”，但我仍然希望正确排序，该怎么办？子字符串（0，p1[1]）indexOf（“：”）似乎会破坏代码，因为indexOf将返回-1。然后我会重新分配i1和i2什么？添加了错误处理。请发布输入字符串的详细说明。嘿，我真的很喜欢这段代码，但如何进行错误检查？喜欢检查字符串中是否有整数吗？我总是被“搞错”了@user1022944您可以在此处看到一个运行示例：
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CustomSorter {
   public static void main( String[] args ) {
      String[] data = {
         "ACLK_SCRN_200MHZ_DATAB_S0_P0:8",
         "ACLK_SCRN_200MHZ_DATAB_S0_P10:8",
         ...
         "ACLK_SCRN_200MHZ_DATAB_S1_P4:8",
         "ACLK_SCRN_200MHZ_DATAB_S1_P5:8",
      };
      List<String> trendList = Arrays.asList( data );
      Collections.sort( trendList, new Comparator< String >(){
         @Override public int compare( String o1, String o2 ){
            String[] p1 = o1.split( "_S\\d+_P" );
            String[] p2 = o2.split( "_S\\d+_P" );
            if( p1.length != 2 ) {
               throw new IllegalStateException("Unexpected item: '"+o1+"'");
            }
            if( p2.length != 2 ) {
               throw new IllegalStateException("Unexpected item: '"+o1+"'");
            }
            final int i1;
            try{
               i1 = Integer.parseInt(p1[1].substring(0,p1[1].indexOf(':')));
            } catch( NumberFormatException x ) {
               throw new IllegalStateException( "Unexpected item: '"+o1+"'");
            }
            final int i2;
            try{
               i2 = Integer.parseInt(p2[1].substring(0,p2[1].indexOf(':')));
            } catch( NumberFormatException x ) {
               throw new IllegalStateException("Unexpected item: '"+o2+"'");
            }
            int cmp = p1[0].compareTo( p2[0] );
            if( cmp == 0 ) {
               cmp = i1 - i2;
            }
            return cmp;
         }});
      for( String entry : trendList ) {
         System.out.println( entry );
      }
   }
}

ACLK_SCRN_200MHZ_DATAB_S0_P0:8
ACLK_SCRN_200MHZ_DATAB_S0_P1:8
ACLK_SCRN_200MHZ_DATAB_S0_P2:8
ACLK_SCRN_200MHZ_DATAB_S0_P3:8
ACLK_SCRN_200MHZ_DATAB_S0_P4:8
ACLK_SCRN_200MHZ_DATAB_S0_P5:8
ACLK_SCRN_200MHZ_DATAB_S0_P6:8
ACLK_SCRN_200MHZ_DATAB_S0_P7:8
ACLK_SCRN_200MHZ_DATAB_S0_P8:8
ACLK_SCRN_200MHZ_DATAB_S0_P9:8
ACLK_SCRN_200MHZ_DATAB_S0_P10:8
ACLK_SCRN_200MHZ_DATAB_S0_P11:8
ACLK_SCRN_200MHZ_DATAB_S0_P12:8
ACLK_SCRN_200MHZ_DATAB_S0_P13:8
ACLK_SCRN_200MHZ_DATAB_S0_P14:8
ACLK_SCRN_200MHZ_DATAB_S0_P15:8
ACLK_SCRN_200MHZ_DATAB_S1_P0:8
ACLK_SCRN_200MHZ_DATAB_S1_P1:8
ACLK_SCRN_200MHZ_DATAB_S1_P2:8
ACLK_SCRN_200MHZ_DATAB_S1_P3:8
ACLK_SCRN_200MHZ_DATAB_S1_P4:8
ACLK_SCRN_200MHZ_DATAB_S1_P5:8
ACLK_SCRN_200MHZ_DATAB_S1_P10:8
ACLK_SCRN_200MHZ_DATAB_S1_P11:8
ACLK_SCRN_200MHZ_DATAB_S1_P12:8
ACLK_SCRN_200MHZ_DATAB_S1_P13:8
ACLK_SCRN_200MHZ_DATAB_S1_P14:8
ACLK_SCRN_200MHZ_DATAB_S1_P15:8