读入txt文本按每行的末尾数字进行排序

不规则的文本文件
1-2-5-4-6-19
4-3-1-8-10
1-2-6-7-10
1-20

如何排序输出？
1-20
1-2-5-4-6-19
4-3-1-8-10
1-2-6-7-10

也就是按最后一个数字的大小排序txt文本文件
谢谢

还有另外一种做法就是了：写一个类让它存着要比较的行的内容，并在构造器里就记下该行最后一个数字的值。让这个类实现Comparable接口，就可以很方便的直接用Collections.sort()来排序。

以前用其它语言写过一组类似的程序，也是这两种办法都用过。这里：[url]http://rednaxelafx.iteye.com/blog/176731[/url]

[code="java"]import java.io.*;
import java.util.*;

public class SortFile {
private static void printUsage() {
System.out.println("Usage: java SortFile filename");
}

private static boolean verifyArgs(String[] args) {
    return (1 <= args.length) && (new File(args[0]).isFile());
}

public static void main(String[] args) {
    if (!verifyArgs(args)) {
        printUsage();
        System.exit(1);
    }

    List<Line> lines = new ArrayList<Line>();
    BufferedReader in = null;

    try {
        in = new BufferedReader(new InputStreamReader(new FileInputStream(args[0])));
        String s = null;
        while (null != (s = in.readLine())) {
            lines.add(new Line(s));
        }
    } catch(Exception e) {
        e.printStackTrace();
        System.exit(1);
    } finally {
       if (null != in) {
           in.close();
       }
    }

    Collections.sort(lines);

    for (Line l : lines) {
        // do whatever with the sorted lines
        System.out.println(l.getText());
    }
}

}

class Line implements Comparable {
private int compareKey;
private String text;

public Line(String text) {
    this.text = text;
    this.compareKey = Integer.parseInt(text.substring(text.lastIndexOf('-')));
}

public int compareTo(Line other) {
    return this.compareKey - other.compareKey;
}

public String getText() {
    return this.text;
}

}[/code]

排序可以利用java.util.Collections类里的sort()方法。这组方法有两个重载，一个是按照自然顺序来对List排序，另一个是指定一个自定义的Comparator来指定排序方式。可以通过匿名内部类来方便的写出这里需要的Comparator的实现，其中可以用正则表达式来抽取每行最后的数字。

SortFile.java：
[code="java"]import java.io.*;
import java.util.*;
import java.util.regex.*;

public class SortFile {
private static void printUsage() {
System.out.println("Usage: java SortFile filename");
}

private static boolean verifyArgs(String[] args) {
    return (1 <= args.length) && (new File(args[0]).isFile());
}

public static void main(String[] args) throws Exception {
    if (!verifyArgs(args)) {
        printUsage();
        System.exit(1);
    }

    List<String> lines = new ArrayList<String>();
    BufferedReader in = null;

    try {
        in = new BufferedReader(new InputStreamReader(new FileInputStream(args[0])));
        String line = null;
        while (null != (line = in.readLine())) {
            lines.add(line);
        }
    } finally {
       if (null != in) {
           in.close();
       }
    }

    Collections.sort(lines, new Comparator<String>() {
        private Pattern extractLastNumberPattern = Pattern.compile("\\d+$");

        private int extractLastNumber(String s) {
            Matcher m = this.extractLastNumberPattern.matcher(s);
            if (!m.find()) {
                throw new RuntimeException("Invalid line format: missing number at the end of the line.");
            }
            return Integer.parseInt(m.group());
        }

        public int compare(String first, String second) {
            int num1 = extractLastNumber(first);
            int num2 = extractLastNumber(second);
            return num2 - num1; // for descending order
        }

        public boolean equals(Object obj) {
            return obj.getClass().equals(this.getClass());
        }
    });

    for (String s : lines) {
        // do whatever with the sorted lines
        System.out.println(s);
    }
}

}[/code]

楼上的回答不错， 但是数据多了， 可能性能有点问题， 楼主写的是： 也就是按最后一个数字的大小排序txt文本文件 。

那么我觉得可以这么抽取排序的数字
private int extractLastNumber(String s) {

int idx = s.lastIndexOf('-');
return Integer.parseInt(s.subString(idex+1)); //自己确定下idx
}

这样性能会提高不少。

嗯，数据量大的时候这样用正则表达式可能会带来性能问题
不过原问的描述太模糊了。如果有很强的保证说输入的文本文件一定是每行都为横杠分隔的数字，那么楼上的方法会非常合适。
另外如果是.NET的话可以用从右向左的匹配模式，只匹配结尾的\d+的话效率也不会很低。不过这边是Java就是了呃呵呵。