【问题标题】：Alphanum - alphanum sorting字母数字 - 字母数字排序
【发布时间】：2017-06-05 01:32:58
【问题描述】：

我有这样的输入

Online Add-on 3 GB 2015
Online Add-on 1.5 GB 2015
Online Add-on 12 GB 2015
Online Add-on 6 GB
Online Add-on 375 MB 2015
Online Add-on 750 MB 2014

我已经尝试过link 中给出的 alphanum 排序，它给了我如下所示的输出。

Online Add-on 1.5 GB 2015
Online Add-on 3 GB 2015
Online Add-on 6 GB
Online Add-on 12 GB 2015
Online Add-on 375 MB 2015
Online Add-on 750 MB 2014

但是，为了更好的人类可读性，我需要如下所示的输出，如果存在年份，则基于年份，必须先降低 MB，然后再降低 GB

Online Add-on 750 MB 2014
Online Add-on 375 MB 2015
Online Add-on 6 GB
Online Add-on 1.5 GB 2015
Online Add-on 3 GB 2015
Online Add-on 12 GB 2015

在 Java 中有什么方法可以做到这一点？？？

【问题讨论】：

stackoverflow.com/questions/14337682/… 从这里引用一次
特别是。 stackoverflow.com/a/14337783/2310289您需要拆分行并比较第三个元素
定义一个扩展Comparable的类，它有两条数据：兆字节数（或字节数）和年份。定义一个比较器，首先比较年份，然后在年份相等时比较兆字节。当您阅读您的字符串时，使用split 并查看第 4 个元素，看看您是否需要将第 3 个元素乘以 1000。（如果您还想允许 KB、TB 等，请调整此项）。为每个输入字符串创建一个对象。使用比较器进行排序。谷歌上有关在 Java 中排序的任何教程以获取更多详细信息。
那"if year exists then based on the year"是什么意思？如果您有10 MB 2014、900 MB 2014、20 MB 2015 和800 MB 2015，那么500 MB（无年份）的第五个值将在哪里排序？如果先按年份排序，那么size就会全部分散，那么“无年份”的值在哪里呢？
我宁愿将字符串解析为有意义的对象，并使用对象进行排序。例如。用String rawString; int size; SizeUnit unit; Year year 上课。然后用这些属性写比较应该是微不足道的

标签： java arrays string sorting comparator

【解决方案1】：

首先以规范的方式格式化信息，为此定义一个格式： “Online Add-on 750 MB 2014”，例如 “frefix size 年份”

然后为它定义一个类（在下面的示例中为 Capac）

幅度可以是一个枚举（示例中的单位）正确覆盖哈希码和等式。

然后用这些 Capac 对象制作一个列表，并使用预定义的比较器使用双重标准对其进行排序，第一个按 magnitde，然后按大小...

示例：

public class Capac {

    public static void main(String[] args) {
        final String arr[] = { "Online Add-on 750 MB 2014", "Online Add-on 375 MB 2015", "Online Add-on 1.5 GB 2015",
                "Online Add-on 3 GB 2015", "Online Add-on 6 GB 2015", "Online Add-on 12 GB 2015" };

        final List<Capac> myList = new ArrayList<>();
        for (final String string : arr) {
            myList.add(new Capac(string));
        }
        System.out.println(myList);
        // sort
        Collections.sort(myList, new Comparator<Capac>() {
            
            @Override
            public int compare(Capac o1, Capac o2) {
                if (o1.unit == o2.unit) {
                    return Double.compare(o1.size, o2.size);
                } else {
                    
                    return Integer.compare(o1.unit.ordinal(), o2.unit.ordinal());
                }

            }
        });
        System.out.println(myList);
    }
    
    private final double size;
    private final int year;
    private final Unit unit;
    private final String prefix;

    public Capac(String ss) {
        final String[] rr = ss.split(" ");
        prefix = rr[0] + " " + rr[1];
        size = Double.parseDouble(rr[2]);
        unit = Unit.valueOf(rr[3]);
        year = Integer.parseInt(rr[4]);
    }

    @Override
    public String toString() {
        return prefix + " " + size + " " + unit + " " + year;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
        long temp;
        temp = Double.doubleToLongBits(size);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        result = prime * result + ((unit == null) ? 0 : unit.hashCode());
        result = prime * result + year;
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final Capac other = (Capac) obj;
        if (prefix == null) {
            if (other.prefix != null)
                return false;
        } else if (!prefix.equals(other.prefix))
            return false;
        if (Double.doubleToLongBits(size) != Double.doubleToLongBits(other.size))
            return false;
        if (unit != other.unit)
            return false;
        if (year != other.year)
            return false;
        return true;
    }
    
}

enum Unit {
    KB, MB, GB, TB
}

输出看起来像

[在线插件 750.0 MB 2014，在线插件 375.0 MB 2015，在线插件 1.5 GB 2015，在线插件 3.0 GB 2015，在线插件 6.0 GB 2015，在线插件 12.0 GB 2015]

和

[在线插件 375.0 MB 2015，在线插件 750.0 MB 2014，在线插件 1.5 GB 2015，在线插件 3.0 GB 2015，在线插件 6.0 GB 2015，在线插件 12.0 GB 2015]

【讨论】：