Java 根据每个字符串的子字符串对字符串ArrayList的一半进行排序

例如，我有一个大小为的字符串数组列表

[12，10L，10，10R，10S，10L]

输出应该是

[10S、10R、10L、10、12]

所以基本上大小必须先按数字排序-（1,2,3,4,5…等等），然后按字母排序

我设法得到了要排序的数字，因此上面输入的当前输出是

10L，10，10R，10S，10L，12

如果缺少一个字母，则它是最大的（参见-10以上的输出在10L-10S<10R<10L<10<12之后）

我应该如何编写一个比较器来允许我这样做

---

考虑输入数组的大小。此数组包含AB格式的产品尺寸，其中：

---

A是一个强制整数B是[S，R，L]大小的可选字符，必须先按A从最小到最大排序，然后按B的顺序排序S

我假设

finalList

列表中有排序数据

10L, 10, 10R, 10S, 10L, 12

使用正则表达式匹配整数，合并

字母数字

和

数字

的列表

在已排序的列表中，运行以下命令

List<String> numberList= new ArrayList<String>(); // store number list
List<String> sizeList= new ArrayList<String>(); // store alphanumerics
for(String value: finalList){

  if(!value.matches("[0-9]+")){  // if contains characters
     sizeList.add(value);
   }
   else{
        numberList.add(value);
  }
}

sizeList.addAll(numberList); 

List numberList=new ArrayList（）；//门店编号列表
列表大小列表=新建ArrayList（）；//存储字母数字
for（字符串值：finalList）{
if（！value.matches（“[0-9]+”）{//if包含字符
增加（价值）；
}
否则{
数字列表。添加（值）；
}
}
sizeList.addAll（数字列表）；

---

sizeList

具有您所需的功能

如果它适用于您的测试用例，请尝试此功能。如果需要，我们可以随时对其进行改进。（添加了一个助手方法）

List List=newarraylist（Arrays.asList（“12”、“10L”、“10”、“10R”、“10S”、“10L”、“14L”、“14”、“8”、“12S”）；
List orderArray=newArrayList（Arrays.asList（“S”、“R”、“L”））；
List sortedList=List.stream（）
.sorted（Comparator.comparing（str->Integer.parseInt（（（字符串）str）.replaceAll（“[A-Z]*”，”））
.Then比较（str->getanit（orderArray，（String）str）））
.distinct（）
.collect（Collectors.toList（））；
系统输出打印LN（分类列表）；
private int getanit（List orderArray，String str）{
inti=orderArray.indexOf（str.substring（str.length（）-1））；
如果（i==-1）返回Integer.MAX_值；
返回i；
}

输出：[8，10S，10R，10L，10，12S，12，14L，14]

如果您不想使用流：

List<String> list = new ArrayList<>(Arrays.asList("12","10L","10","10R","10S","10L","14L","14","8","12S"));
List<String> orderArray = new ArrayList<>(Arrays.asList("S", "R", "L"));

list.sort(new Comparator<String>() {
        @Override
        public int compare(String lhs, String rhs) {
            int lInt = Integer.parseInt(lhs.replaceAll("[A-Z]*", ""));
            int rInt = Integer.parseInt(rhs.replaceAll("[A-Z]*", ""));
            if (lInt != rInt) {
               return lInt - rInt;
            } else {
                return getAnInt(orderArray, lhs) - getAnInt(orderArray, rhs);
            }
        }
    });

System.out.println(list);

List List=newarraylist（Arrays.asList（“12”、“10L”、“10”、“10R”、“10S”、“10L”、“14L”、“14”、“8”、“12S”）；
List orderArray=newArrayList（Arrays.asList（“S”、“R”、“L”））；
list.sort（新的比较器（）{
@凌驾
公共整数比较（字符串lhs、字符串rhs）{
int lInt=Integer.parseInt（lhs.replaceAll（“[A-Z]*”，”）；
int rInt=Integer.parseInt（rhs.replaceAll（“[A-Z]*”，”）；
if（lInt！=rInt）{
返回皮棉打印；
}否则{
返回getanit（orderArray，lhs）-getanit（orderArray，rhs）；
}
}
});
系统输出打印项次（列表）；

正确的方法很可能是将每个

字符串

解析为一个专用类，该类表示扩展

可比

，以提供正确的

比较

方法。还有，为什么S应该小于R，R应该小于L？字母顺序正好相反，那么这里的规则是什么呢？这些是规则，小的，规则的和大的，我应该提到它对衣服的作用，这就是为什么它们是这样的，在上面的例子中，“12”会落在哪里？在“10”和“12”之间？还是在“10L”和“10”之间？考虑输入数组，大小。此数组包含AB格式的产品尺寸，其中：A是一个强制整数B是[S，R，L]中的可选字符。尺寸必须先按A从最小到最大排序，然后按B排序S@Mivakes：编写一个

Size

类来实现

Comparable

，可能是最干净的。然后去掉

列表

，改用

列表

。我不确定这是否正确，因为这可能是因为我的解释不好，我应该复制并粘贴我在编辑中所做的操作。它只是以与之前相同的方式返回列表

我设法获得了要排序的数字，因此我当前对上面输入的输出是10L，10、10R、10S、10L、12

将此结果存储在finalList中，该列表是您正在检查的sizeList？它将有一个排序list@Mivakes让我来修一下…给我2分钟我修好了，也测试了输出。。我更改了正则表达式，它给出了正确的输出。实际上之前，我在检查数字是否为字母数字。10是一个有效的字母数字字符，也是一个有效的整数，这就是为什么它总是在第一次检查中出现的原因。这只是在java 7中不起作用的流，否则基本思想是一样的。您可以使用循环而不是streams@Mivakes已将答案更新为不使用流。尝试

数组。asList

已经返回了

列表

。无需通过

新建ArrayList（…）

复制列表。此外，不使用流并不意味着您必须通过匿名内部类实现

比较器。不要使用减号来实现比较器，因为减号会溢出。使用
整数。比较（…，…）
。您可以通过为第一个lambda声明一个显式参数类型来避免类型强制转换，而
comparingit
在这里可能更有效：
Comparator.comparingInt（（String str）->Integer.parseInt（str.replaceAll（“[A-Z]*”，”）。然后是comparingInt（str->getanit（orderArray，str））
，由于
getAnInt
假定数字后有一个字母的固定格式，因此上一步可能使用与
Comparator.comparingInt（（String str）->Integer.parseInt（str.substring（0，str.length（）-1））相同的假定，而不是昂贵的正则表达式替换操作。顺便说一下，
getanit
可以像
returnorderarray.indexOf（str.substring（str.length））一样简单地实现(
List<String> list = new ArrayList<>(Arrays.asList("12","10L","10","10R","10S","10L","14L","14","8","12S"));
List<String> orderArray = new ArrayList<>(Arrays.asList("S", "R", "L"));

list.sort(new Comparator<String>() {
        @Override
        public int compare(String lhs, String rhs) {
            int lInt = Integer.parseInt(lhs.replaceAll("[A-Z]*", ""));
            int rInt = Integer.parseInt(rhs.replaceAll("[A-Z]*", ""));
            if (lInt != rInt) {
               return lInt - rInt;
            } else {
                return getAnInt(orderArray, lhs) - getAnInt(orderArray, rhs);
            }
        }
    });

System.out.println(list);