如何对List<List<String>>排序

Question

我有一项任务需要对文本文件进行排序：

1. 根据列对行进行排序
2. 按第一列对行进行排序(如果列中的数据相同，则按第二列排序)等等，数据在排序后保持不变；
3. 数字必须按升序排序，字母按字母顺序排列，数字高于字母。
4. 用制表符分隔的列("\t")

我所做的:读取文件并将所有内容复制到List>中，其中列表中的每个元素都是存储在List中的文件中的行，下面是代码：

public class ReadDataFile {
public static List<List<String>> readData(String fileName) throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(fileName + ".txt"));
    List<List<String>> data = new ArrayList<List<String>>();
    String line;
    while (true) {
        line = br.readLine();
        if (line == null)
            break;
        List<String>lines = Arrays.asList(line.split("\t"));
        data.add(lines);
        System.out.println(lines);
    }
    br.close();
    return data;

并将数据写入另一个文件：

    public void writeToFile(String fileName) throws IOException {
    FileWriter writer = new FileWriter(fileName);
    List<List<String>> data = ReadDataFile.readData("input");

    Collections.sort(data, new Comparator<List<String>>() {
        @Override
        public int compare(List<String> o1, List<String> o2) {
            // TODO Auto-generated method stub
            return o1.get(0).compareTo(o2.get(0));
        }
    });

    for (List<String> lines : data) {
        for (int i = 0; i < lines.size(); i++) {
            writer.write(lines.get(i));
            if (i < lines.size() - 1) {
                writer.write("\t");
            }
        }
        writer.write("\n");

    }
    writer.close();
}

问题是：

public int compare(List<String> o1, List<String> o2) {
  // TODO Auto-generated method stub
  return o1.get(0).compareTo(o2.get(0));
}

我所需要的没有正确的分类。

有一个输入文件的例子：

-2.2 2 3 4 329 2
2.2 12345q 69 -afg
2.2 12345q 69 -asdf
-22 1234234 asdfasf asdgas
-22 11 abc
-22 -3 4
-1.1
qqqq 1.1

预期的最终产出如下：

-22 -3 4
-22 11 abc
-22 1234234 asdfasf asdgas
-2.2 2 3 4 329 2
-1.1
 2.2 12345q 69 -afg
 2.2 12345q 69 -asdf
 qqqq 1.1

但是，我得到的是：

-1.1
-2.2 2 3 4 329 2
-22 -3 4
-22 11 abc
-22 1234234 asdfasf asdgas
 2.2 12345q 69 -afg
 2.2 12345q 69 -asdf
 qqqq 1.1

问题是，如何写一个合适的排序？谢谢你的回答

Answer 1

似乎您希望使用数字比较来排序有效数字的字符串值。由于您的示例包含非整数值，所以可以选择使用double或BigDecimal进行数字比较。下面的代码使用BigDecimal，这样就可以比较任意大小的数字，而不会丢失精度，但它不支持"Infinite"、"-Infinite"和"NaN"的特殊值，也不支持Double.parseDouble()支持的HexFloatingPointLiteral格式。

将数字与字符串进行比较，应该在字符串之前对数字进行排序。

为了比较字符串和字符串，您可以对词典学、大小写不敏感地排序，或者使用Collator进行区分地区的比较。下面的代码对默认的区域设置使用排序规则。

比较将比较列表的第一个值，如果相等，将比较第二个值，依此类推。如果一个列表较短，且列表在此之前相等，则该较短的列表首先排序。

public final class NumberStringComparator implements Comparator<List<String>> {
    private Collator collator = Collator.getInstance();
    @Override
    public int compare(List<String> r1, List<String> r2) {
        for (int i = 0; ; i++) {
            if (i == r1.size())
                return (i == r2.size() ? 0 : -1);
            if (i == r2.size())
                return 1;
            String v1 = r1.get(i), v2 = r2.get(i);
            BigDecimal n1 = null, n2 = null;
            try { n1 = new BigDecimal(v1); } catch (@SuppressWarnings("unused") NumberFormatException unused) {/**/}
            try { n2 = new BigDecimal(v2); } catch (@SuppressWarnings("unused") NumberFormatException unused) {/**/}
            int cmp = (n1 == null ? (n2 == null ? this.collator.compare(v1, v2) : 1) : (n2 == null ? -1 : n1.compareTo(n2)));
            if (cmp != 0)
                return cmp;
        }
    }
}

测试

String input = "-2.2\t2\t3\t4\t329\t2\n" +
               "2.2\t12345q\t69\t-afg\n" +
               "2.2\t12345q\t69\t-asdf\n" +
               "-22\t1234234\tasdfasf\tasdgas\n" +
               "-22\t11\tabc\n" +
               "-22\t-3\t4\n" +
               "-1.1\n" +
               "qqqq\t1.1";
List<List<String>> data = new ArrayList<>();
try (BufferedReader in = new BufferedReader(new StringReader(input))) {
    for (String line; (line = in.readLine()) != null; )
        data.add(Arrays.asList(line.split("\t")));
}
data.sort(new NumberStringComparator());
data.forEach(System.out::println);

输出

[-22, -3, 4]
[-22, 11, abc]
[-22, 1234234, asdfasf, asdgas]
[-2.2, 2, 3, 4, 329, 2]
[-1.1]
[2.2, 12345q, 69, -afg]
[2.2, 12345q, 69, -asdf]
[qqqq, 1.1]