Java 比较和排序字符串

我有一个字符串数组：15MB、12MB、1TB、1GB。我想通过遵循MB小于GB和TB的规则，从词典的角度对它们进行比较。 所以最后我想得到：12MB，15MB，1GB，1TB。我找到了一种比较字母的方法：

 final static String ORDER="MGT";

public int compare(String o1, String o2) {
       int pos1 = 0;
       int pos2 = 0;
       for (int i = 0; i < Math.min(o1.length(), o2.length()) && pos1 == pos2; i++) {
          pos1 = ORDER.indexOf(o1.charAt(i));
          pos2 = ORDER.indexOf(o2.charAt(i));
       }

       if (pos1 == pos2 && o1.length() != o2.length()) {
           return o1.length() - o2.length();
       }

       return pos1  - pos2  ;
    }

final static String ORDER=“MGT”；
公共整数比较（字符串o1、字符串o2）{
int pos1=0；
int pos2=0；
对于（inti=0；i

---

我正在考虑将字符串按数字和字母拆分，但如何按字母“MB..”再按数字排序呢。我是使用两个比较器还是其他什么？

如果首先将数据转换为一个公共单位（例如MB），比较起来会容易得多。如果此转换后的值相同，则应应用字典排序，它可能如下所示：

private int convertToMegaBytes(String s) {

    char c = s.charAt(s.length() - 2);

    if(c == 'G')
        return 1024 * Integer.parseInt(s.substring(0, s.length() - 2));
    if(c == 'T')
        return 1024 * 1024 * Integer.parseInt(s.substring(0, s.length() - 2));

    return Integer.parseInt(s.substring(0, s.length() - 2));

}

final static String ORDER = "MGT";

public int compare(String o1, String o2) {
    int v = convertToMegaBytes(o1)  - convertToMegaBytes(o2);
    // if values are equal then compare lexicographically
    return v == 0 ? ORDER.indexOf(o1.charAt(o1.length() - 2)) - ORDER.indexOf(o2.charAt(o2.length() - 2)) : v;
}

这可能会奏效。

compare

方法获取每个字符串表示为长（10KB变为10000）的字节数，然后比较这些字节数。

getSizeOfString

方法将字符串转换为表示其所代表字节数的长字符串

public int比较（字符串o1、字符串o2）{
long size1=getSizeOfString（o1）；
long size2=getSizeOfString（o2）；
返回Long.compare（size1、size2）；
}
私有长GetSizeOffString（字符串sizeString）{
Pattern validSizePattern=Pattern.compile（“（\\d+）（[KMG]）B”）；
Matcher Matcher=validSizePattern.Matcher（大小限制）；
matcher.find（）；
长尺寸=长数值（匹配器组（1））；
开关（匹配器组（2））{
案例“K”：
大小*=1024；
打破
案例“M”：
大小*=（1024*1024）；
打破
案例“G”：
大小*=（1024*1024*1024）；
打破
}
返回大小；
}

现在，首先按单位排序，然后按单位内的值排序。这一点已被修改，以反映OP的最后评论

import java.util.*;

enum Memory {
   B(1), KB(2), MB(3), GB(4), TB(5);
   public long val;

   private Memory(long val) {
      this.val = val;
   }
}

public class MemorySort {
   public static void main(String[] args) {
      List<String> memory = Arrays.asList("122003B",
            "1TB",
            "2KB",
            "100000MB",
            "1027MB",
            "2024GB");

      Comparator<String> units = Comparator.comparing(
            a -> Memory.valueOf(a.replaceAll("\\d+", "")).val);

      Comparator<String> values = Comparator.comparing(
            a -> Integer.parseInt(a.replaceAll("[A-Z]+", "")));

      Collections.sort(memory, units.thenComparing(values));
      System.out.println(memory);
   }
}

import java.util.*；
枚举内存{
B（1）、KB（2）、MB（3）、GB（4）、TB（5）；
公共长假；
专用内存（长值）{
this.val=val；
}
}
公共类记忆体育{
公共静态void main（字符串[]args）{
List memory=Arrays.asList（“122003B”，
“1TB”，
“2KB”，
“10万兆”，
“1027MB”，
“2024GB”）；
比较器单位=比较器。比较(
a->Memory.valueOf（a.replaceAll（“\\d+”，“”））.val）；
比较器值=比较器。比较(
a->Integer.parseInt（a.replaceAll（“[a-Z]+”，”）；
排序（内存，单位，然后比较（值））；
System.out.println（内存）；
}
}

看看：这里有一个有趣的解决方案。他们已经做了，但是他们只比较了数字而不是字母。这很有帮助，但不是我想做的。我只需要比较给定的值，而不是解析它们。例如，如果给我1GB，1024MB，我仍然需要它们像这样排序：1024MB，1GB，但不是我想要做的。不需要解析。如果我得到1001MB和1GB，我仍然需要按相同的顺序对它们进行排序。尝试使用这两个数字，它会显示1001MB大于1GB。这不是您想要的吗？解析只是让它们更容易比较，您是否也需要性能要求？不，我希望1001MB被排序为小于1GB，但我认为您希望1025MB大于1GB。所以订单是1GB，1025MB。非常有用，但根本不是我需要的。简单地说，如果我有：1200MB，2MB，1GB，我希望他们被排序为：2MB，1200MB，1GB修改它以反映需求。使用字符串替换仍然不是很有效，但它可以工作。