JAVA按数字顺序对数组排序

基本上，我有一个名为highscore.txt的文件，其中包含以下内容：

24 01詹姆斯7
24 01詹姆斯11
24 01詹姆斯1234
24 01詹姆斯3
24 01詹姆斯3
24 01詹姆士41
24 01詹姆斯431
24 01詹姆斯3
24 01詹姆士2
24 01詹姆斯444
24 01詹姆斯44
24 01詹姆斯876
24 01詹姆斯865
24 01詹姆士1

[我想做的是创建一个包含十个“空格”（0-9）的数组。这十个空格将是最后数字最少的行。]

换句话说：数组[0]是“24 01 James 1”，数组[9]是24 01 James 444

我所尝试的：

FileInputStream fstream = null;
try {
fstream = new FileInputStream("highscore.txt");
} catch (FileNotFoundException ex) {}
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;

List<String> list = new ArrayList<String>();

try {
while ((strLine = br.readLine()) != null)   {    
list.add(strLine);} } 
catch (IOException ex) {}

String[] stringArr = list.toArray(new String[0]);

FileInputStream fstream=null；
试一试{
fstream=新文件输入流（“highscore.txt”）；
}catch（FileNotFoundException ex）{}
DataInputStream in=新的DataInputStream（fstream）；
BufferedReader br=新的BufferedReader（新的InputStreamReader（in））；
弦斯特林；
列表=新的ArrayList（）；
试一试{
而（（strLine=br.readLine（））！=null）{
list.add（strLine）；}
catch（IOException ex）{}
String[]stringArr=list.toArray（新字符串[0]）；

现在，我不完全确定该怎么办：

我在想，也许：

 for(int i = 0; i < stringArr.length; i++){
 String words[] = stringArr[i].split(" "); }

for（int i=0；i

然后，我可以用[3]来检查结尾的数字

无论如何，我将非常感谢任何帮助，我不太确定如何处理这个问题，我才刚刚开始使用Java

---

谢谢

我想这是一个游戏，因此您可以创建一个类

HighscorePlayer

，该类在构造函数中包含name和score。然后您可以直接从

words[]

向其提供信息，并将其存储在与

stringArr[]

大小相同的数组中。您可能需要使用

Integer.parseInt（string）

将字符串转换为int。这将为您提供一个包含名称和分数的

HighscorePlayer

s数组

现在，您需要能够根据球员的得分值对他们进行排序。为此，

HighscorePlayer

需要实现

Compariable

class HighscorePlayer implements Comparable<HighscorePlayer>{
    public int score;
    public String name;

    public HighscorePlayer(String name, int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public int compareTo(HighscorePlayer player) {
        return Integer.compare(score, player.score);
    }
}

class HighscorePlayer实现了可比较的{
公众智力得分；
公共字符串名称；
公共HighscorePlayer（字符串名称，整数分数）{
this.name=名称；
这个分数=分数；
}
@凌驾
公开智力比较（高分球员）{
返回整数。比较（分数，玩家。分数）；
}
}

---

然后你可以运行一个

array.sort（players）

并遍历该数组。这将使您保留与分数相关的名称，并允许您在需要时添加更多相关信息。

如果您确实需要分数，我建议您：

...
catch(IOException ex){}
String[] stringArr = new String[list.size()];
stringArr = list.toArray(stringArr);
int score[] = new int[stringArr.length];

for(int i = 0; i < score.length; i++){
    for (String strScore : stringArr[i].split("24 01 James "))
    {
       score[i] = Integer.parseInt(strScore);
    }
 }

。。。
catch（IOException ex）{}
String[]stringArr=新字符串[list.size（）]；
stringArr=list.toArray（stringArr）；
整数分数[]=新整数[stringArr.length]；
for（int i=0；i

现在，所有分数都存储在整数数组中。只需按升序排序，然后取前10个元素：）

以下是我用来回答你问题的一些来源：

---

（最重要的一个）

我认为使用

对象是唯一的方法，因为它允许在其中存储不同的类型。这对于对象数组的排序是可取的，因为排序
int
不会出错

public class JavaApplication9 {

    static private ReadFile readFile;

    public static void main(String[] args) {
        readFile = new ReadFile();
        readFile.readnewFile();
        readFile.wordRead();
        readFile.convertToObject();
        readFile.sortIng();
        readFile.display();
    }
}

第二个文件：

public class WordsClass {

    final public Object[][] finalTest;
    private int nElems;

    public WordsClass(String theDay, String theMonth, String theName, String theScore) {
        finalTest = new Object[14][4];
        nElems = 0;
    }

    public Object myObject(String a, String b, String c, String d) {
        finalTest[nElems][0] = Integer.parseInt(a);
        finalTest[nElems][1] = Integer.parseInt(b);
        finalTest[nElems][2] = c;
        finalTest[nElems][3] = Integer.parseInt(d);
        nElems++;
        return finalTest;
    }
}

和第三个文件：

public class ReadFile {

    static private FileInputStream fstream;
    static private DataInputStream in;
    static private BufferedReader br;
    static private String strLine;
    static private Object[][] words;
    static private int nElems;

    WordsClass wordsClass = new WordsClass(null, null, null, null);

    public ReadFile() {
        words = new Object[14][4];
        nElems = 0;
    }

    public void readnewFile() throws FileNotFoundException {
        fstream = new FileInputStream("highscore.txt");
        in = new DataInputStream(fstream);
        br = new BufferedReader(new InputStreamReader(in));
        // wordRead(); 
    }

    public Object wordRead() throws IOException {
        try {
            while ((strLine = br.readLine()) != null) {
                words[nElems] = strLine.split(" ");
                nElems++;
            }
        } catch (IOException e) {
        }
        br = null;
        in = null;
        fstream = null;
        return words;
    }

    public Object convertToObject() {

        for (Object[] word : words) {
            wordsClass.myObject(word[0].toString(), word[1].toString(), 
                   word[2].toString(), word[3].toString());
        }
        words = null;
        return wordsClass;
    }

    public boolean sortIng() {
        Arrays.sort(wordsClass.finalTest, new Comparator<Object[]>() {
            @Override
            public int compare(final Object[] w1, final Object[] w2) {
                final Integer a = Integer.parseInt(w1[3].toString());
                final Integer b = Integer.parseInt(w2[3].toString());
                return a.compareTo(b);
            }
        });
        return true;
    }

    public void display() {
        for (Object[] finalTest : wordsClass.finalTest) {
            for (Object finalTest1 : finalTest) {
                System.out.print(finalTest1 + " ");
            }
            System.out.println("");
        }
    }
}

公共类读取文件{
静态私有文件输入流；
静态私有数据输入流；
静态专用缓冲读取程序br；
静态私有字符串strLine；
静态私有对象[][]字；
静态私有整数；
WordsClass WordsClass=新的WordsClass（null，null，null，null）；
公共读取文件（）{
单词=新对象[14][4]；
nElems=0；
}
public void readnewFile（）引发FileNotFoundException{
fstream=新文件输入流（“highscore.txt”）；
in=新数据输入流（fstream）；
br=新的BufferedReader（新的InputStreamReader（in））；
//wordRead（）；
}
公共对象wordRead（）引发IOException{
试一试{
而（（strLine=br.readLine（））！=null）{
单词[nElems]=strLine.split（“”）；
nElems++；
}
}捕获（IOE异常）{
}
br=null；
in=null；
fstream=null；
返回单词；
}
公共对象convertToObject（）{
for（Object[]单词：words）{
wordsClass.myObject（单词[0].toString（），单词[1].toString（），
word[2].toString（），word[3].toString（）；
}
单词=空；
返回单词类；
}
公共布尔排序（）{
Arrays.sort（wordsClass.finalTest，newcomparator（））{
@凌驾
公共整数比较（最终对象[]w1，最终对象[]w2）{
最后一个整数a=Integer.parseInt（w1[3].toString（））；
最后一个整数b=Integer.parseInt（w2[3].toString（））；
返回a.compareTo（b）；
}
});
返回true；
}
公共空间显示（）{
对于（对象[]finalTest:wordsClass.finalTest）{
用于（对象finalTest1:finalTest）{
系统输出打印（finalTest1+“”）；
}
System.out.println（“”）；
}
}
}

所有这些都提供了以下输出：


24 1詹姆斯1
24 1詹姆斯2
241詹姆士3
241詹姆士3
241詹姆士3
241詹姆士7
24 1詹姆斯11
241詹姆士41
241詹姆斯44
241詹姆士431
241詹姆斯444
241詹姆士865
241詹姆斯876
241詹姆士1234

硅